netsukuku/src/dnslib.c

				 /**************************************
                *     AUTHOR: Federico Tomassini        *
               *     Copyright (C) Federico Tomassini    *
              *     Contact effetom@gmail.com             *
             ***********************************************
             *******          BEGIN 3/2006          ********
*************************************************************************
*                                                                       *
*  This program 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 2 of the License, or    *
*  (at your option) any later version.                                  *
*                                                                       *
*  This program 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.                         *
*                                                                       *
************************************************************************/
#define _GNU_SOURCE
#include <string.h>
#include "dnslib.h"
#include "err_errno.h"
#include "log.h"
#include "xmalloc.h"

/*
 * Takes a label: is there a ptr?
 * Returns:
 *      -1  is a malformed label is found
 *       0  if there's no pointer
 *      <offset from start_pkt> if a pointer is found
 */
int
getlblptr(char *buf)
{
	uint16_t dlbl;
	char c[2];

	memcpy(c, buf, 2);

	if (!LBL_PTR(*c))			/* No ptr */
		return 0;
	if (LBL_PTR(*c) != LBL_PTR_MASK) {
		debug(DBG_INSANE, "In getlblptr: invalid octet %02x",
			  (unsigned char) c[0]);
		err_ret(ERR_DNSMLO, -1);
	}
	(*c) &= LBL_PTR_OFF_MASK;
	memcpy(&dlbl, c, 2);
	dlbl = ntohs(dlbl);
	return dlbl;				/* offset */
}

/*
 * Reads a contiguous octet-sequence-label.
 * Writes on dst.
 * There are two limits: 
 * 	the name has to be less than MAX_SEQ_LBL_LEN
 * 	we must stay in pkt_len
 * -limit- is the less limit
 * 
 * Returns:
 *      -1 On error
 *      Bytes readed if OK
 */
int
read_label_octet(const char *src, char *dst, int limit)
{
	int how;

	how = *src++;
	if (how > limit || how > DNS_MAX_LABELS) {
		error("In read_label_octet: got %d with limti %d\n", how, limit);
		err_ret(ERR_DNSMSL, -1);
	}
	memcpy(dst, src, how);
	return how;
}

/*
 * Converts a dns compliant sequence label name to string.
 * we start to read at -buf-
 * we need start_pkt for pointers
 * we need limit to remain under pktlen
 * Returns:
 *      Bytes readed if OK
 *      -1 on error
 */
int
lbltoname(char *buf, char *start_pkt, char *dst, int limit)
{
	char *crow;
	int how, recursion = 0;
	int ptr;
	int writed = 0, readed = 0;
	int new_limit = limit;

	crow = buf;

	while (*crow) {
		ptr = getlblptr(crow);
		if (ptr) {				/* Got a pointer.... or got an error */
			if (ptr == -1) {
				debug(DBG_INSANE, err_str);
				err_ret(ERR_DNSMSL, -1);
			}
			if (++recursion > MAX_RECURSION_PTR)
				err_ret(ERR_DNSTRP, -1);
			if (recursion == 1)
				readed += 2;	/* we read the pointer */
			crow = start_pkt + ptr;
			new_limit = limit - (int) (crow - buf);
			if (new_limit <= 0
				|| new_limit > (int) (buf - start_pkt) + limit)
				err_ret(ERR_DNSPLB, -1);
			if (getlblptr(crow))
				err_ret(ERR_DNSPTP, -1);
		}
		how =
			read_label_octet(crow, dst,
							 min(new_limit, DNS_MAX_HNAME_LEN - writed));
		if (how == -1) {
			debug(DBG_INSANE, err_str);
			err_ret(ERR_DNSMSL, -1);
		}
		if (!recursion)
			readed += how + 1;
		writed += how + 1;
		dst += how;
		crow += how + 1;
		*dst++ = (*crow) ? '.' : 0;
	}
	if (!recursion)
		readed++;
	return readed;
}

/*
 * DNS PTR query ask for 4.3.2.1.in-addr.arpa to know
 * who is 1.2.3.4.
 * This function reads this type of query transalting it
 * in the second form.
 * Writes result on *dst.
 * -1 on error.
 */

int
swap_straddr(char *src, char *dst)
{
	char a[3];
	int i, slen;
	char *crow, *tmp, *atom;
	int count = 0, offset = 0;

	slen = strlen(src);
	if (slen > DNS_MAX_HNAME_LEN)
		goto mlf_addr;
	tmp = src;
	for (i = 0; i < 4; i++) {
		count = 0;
		atom = a;
		while (*tmp && *tmp != '.') {
			if (count > 2)
				goto mlf_addr;
			*atom++ = *tmp++;
			count++;
		}
		if (!count)
			goto mlf_addr;
		crow = dst + slen - count - offset;
		strncpy(crow, a, count);
		offset += count;
		if (!(*tmp))
			break;
		else {
			if (i == 3)
				goto mlf_addr;
			*(crow - 1) = '.';
			offset++;
			tmp++;
		}

	}
	*(dst + slen) = 0;
	return 0;
  mlf_addr:
	debug(DBG_INSANE, "in swap_straddr: invalid address `%s`.\n", src);
	err_ret(ERR_DNSMDD, -1);
}

int
swap_straddr6(char *src, char *dst)
{
	int slen;
	char *tmp;
	slen = strlen(src);
	tmp = src + slen - 1;
	while (tmp != src)
		*dst++ = *tmp--;
	*dst++ = *tmp;
	*dst = 0;
	return 0;
}

int
rm_inv_prefix(char *src, char *dst)
{
	char *temp;
	int ret;
	if (!src) {
		debug(DBG_INSANE, "In rm_inv_prefix: NULL argument!");
		err_ret(ERR_DNSMDD, -1);
	}
	if (!
		((temp = (char *) strcasestr(src, DNS_INV_PREFIX)) ||
		 (temp = (char *) strcasestr(src, DNS_INV_PREFIX6)) ||
		 (temp = (char *) strcasestr(src, OLD_DNS_INV_PREFIX6)))) {
		debug(DBG_INSANE, "In rm_inv_prefix(): no suffix for PTR query.");
		err_ret(ERR_DNSMDD, -1);
	}
	if (temp - src >= DNS_MAX_HNAME_LEN) {
		error("In rm_inv_prefix(): name too long.");
		err_ret(ERR_DNSMDD, -1);
	}
	ret = strstr(temp, "6") ? AF_INET6 : AF_INET;
	strncpy(dst, src, temp - src);
	dst[temp - src] = 0;
	return ret;
}

int
add_inv_prefix(char *s, int family)
{
	int len;

	len = strlen(s);
	if (family == AF_INET)
		strcat(s, DNS_INV_PREFIX);
	else
		strcat(s, DNS_INV_PREFIX6);
	return 0;
}

int
swapped_straddr(char *src, char *dst)
{
	char temp[DNS_MAX_HNAME_LEN];
	int res;

	res = rm_inv_prefix(src, temp);
	if (res == -1) {
		error(err_str);
		err_ret(ERR_DNSMDD, -1);
	}
	if (res == AF_INET)
		res = swap_straddr(temp, dst);
	else
		res = swap_straddr6(temp, dst);
	if (res == -1) {
		error(err_str);
		err_ret(ERR_DNSMDD, -1);
	}
	return 0;
}

int
swapped_straddr_pref(char *src, char *dst, int family)
{
	int res;

	if (family == AF_INET)
		res = swap_straddr(src, dst);
	else
		res = swap_straddr6(src, dst);
	if (res == -1) {
		error(err_str);
		err_ret(ERR_DNSMDD, -1);
	}
	add_inv_prefix(dst, family);
	return 0;
}

/*
 * Converts a domain_name_string into a sequence label format,
 * dns compliant. Writes on dst.
 * -1 on error, number of bytes writed on success
 */
int
nametolbl(char *name, char *dst)
{
	char *crow;
	int offset = 0, res;

	if (strlen(name) > DNS_MAX_HNAME_LEN) {
		debug(DBG_INSANE, "Malformed name: %s.", name);
		err_ret(ERR_DNSMDA, -1);
	}
	while ((crow = strstr(name + 1, "."))) {
		res = crow - name;
		if (res > DNS_MAX_LABELS) {
			debug(DBG_INSANE, "Malformed name: %s.", name);
			err_ret(ERR_DNSMDA, -1);
		}
		*dst = (char) res;		/* write the octet length */
		dst++;
		offset++;
		memcpy(dst, name, (size_t) res);	/* write label */
		name += res + 1;
		dst += res;
		offset += res;			/* shift ptrs */
	}
	if (!name)
		return offset;
	if ((res = (char) strlen(name)) > DNS_MAX_LABELS) {
		debug(DBG_INSANE, "Malformed name: %s", name);
		err_ret(ERR_DNSMDA, -1);
	}
	*dst++ = (char) res;
	strcpy(dst, name);
	offset += res + 2;
	return offset;
}

/*
 * Disassembles DNS packet headers, writing a yet allocated
 * dns_pkt_hdr struct.
 * No controls on len, bcz <<--the min_pkt_len is controlled
 * by recv.-->>
 * Returns the number of bytes readed (always DNS_HDR_SZ).
 */
int
d_hdr_u(char *buf, dns_pkt_hdr * dph)
{
	uint8_t c;
	uint16_t s;

	// ROW 1
	memcpy(&s, buf, sizeof(uint16_t));
	dph->id = ntohs(s);
	// ROW 2
	buf += 2;
	memcpy(&c, buf, sizeof(uint8_t));
	dph->qr = (c >> 7) & 0x01;
	dph->opcode = (c >> 3) & 0x0f;
	dph->aa = (c >> 2) & 0x01;
	dph->tc = (c >> 1) & 0x01;
	dph->rd = c & 0x01;

	buf++;
	memcpy(&c, buf, sizeof(uint8_t));
	dph->ra = (c >> 7) & 0x01;
	dph->z = (c >> 4) & 0x07;
	dph->rcode = c & 0x0f;

	// ROW 3
	buf++;
	memcpy(&s, buf, sizeof(uint16_t));
	dph->qdcount = ntohs(s);
	// ROW 4
	buf += 2;
	memcpy(&s, buf, sizeof(uint16_t));
	dph->ancount = ntohs(s);
	// ROW 5
	buf += 2;
	memcpy(&s, buf, sizeof(uint16_t));
	dph->nscount = ntohs(s);
	// ROW 6
	buf += 2;
	memcpy(&s, buf, sizeof(uint16_t));
	dph->arcount = ntohs(s);

	buf += 2;
	return DNS_HDR_SZ;			// i.e. 12 :)
}

/*
 * This function alloc a new dns_pkt_qst to store a dns_question_section.
 * The new dns_pkt_qst is also added to the principal dp-struct
 * Returns bytes readed if OK. -1 otherwise.
 */
int
d_qst_u(char *start_buf, char *buf, dns_pkt * dp, int limit_len)
{
	int count;
	uint16_t s;
	dns_pkt_qst *dpq;

	dpq = dns_add_qst(dp);

	/* get name */
	if ((count = lbltoname(buf, start_buf, dpq->qname, limit_len)) == -1) {
		error(err_str);
		err_ret(ERR_DNSMDD, 1);
	}
	buf += count;
	/* Now we have to write 2+2 bytes */
	if (count + 4 > limit_len)
		err_ret(ERR_DNSPLB, 1);

	/* shift to type and class */
	memcpy(&s, buf, 2);
	dpq->qtype = ntohs(s);
	count += 2;
	buf += 2;

	memcpy(&s, buf, 2);
	dpq->qclass = ntohs(s);
	count += 2;

	return count;
}

/*
 * Disassembles a DNS qst_section_set.
 * Use the above function for each question section.
 * -1 on error. Number of bytes readed on success.
 *  If -1 is returned, rcode ha sto be set to E_INTRPRT
 */
int
d_qsts_u(char *start_buf, char *buf, dns_pkt * dp, int limit_len)
{
	int offset = 0, res;
	int i, count;

	if (!(count = DP_QDCOUNT(dp)))
		return 0;				/* No questions. */

	for (i = 0; i < count; i++) {
		if ((res =
			 d_qst_u(start_buf, buf + offset, dp,
					 limit_len - offset)) == -1) {
			error(err_str);
			err_ret(ERR_DNSMDD, -1);
		}
		offset += res;
	}
	return offset;
}

/*
 * The behavior of this function is in all similar to dpkttoqst.
 * Returns -1 on error. Bytes readed otherwise.
 */
int
d_a_u(char *start_buf, char *buf, dns_pkt_a ** dpa_orig, int limit_len)
{
	int count, rdlen;
	dns_pkt_a *dpa;
	uint16_t s;
	uint32_t ui;

	dpa = dns_add_a(dpa_orig);

	/* get name */
	if ((count = lbltoname(buf, start_buf, dpa->name, limit_len)) == -1) {
		error(err_str);
		err_ret(ERR_DNSMDD, -1);
	}
	buf += count;
	/* Now we have to write 2+2+4+2 bytes */
	if (count + 10 > limit_len)
		err_ret(ERR_DNSPLB, -1);

	memcpy(&s, buf, 2);
	dpa->type = ntohs(s);
	count += 2;
	buf += 2;

	memcpy(&s, buf, 2);
	dpa->cl = ntohs(s);
	count += 2;
	buf += 2;

	memcpy(&ui, buf, 4);
	dpa->ttl = ntohl(ui);
	count += 4;
	buf += 4;

	memcpy(&s, buf, 2);
	dpa->rdlength = ntohs(s);
	count += 2;
	buf += 2;

	rdlen = dpa->rdlength;
	if (rdlen > DNS_MAX_HNAME_LEN)
		err_ret(ERR_DNSMDD, -1);
	/* Now we have to write dpa->rdlength bytes */
	if (count + rdlen > limit_len)
		err_ret(ERR_DNSPLB, -1);
	if (dpa->type == T_A) {
		memcpy(dpa->rdata, buf, rdlen);	/* 32bit address */
		count += rdlen;
	} else if (dpa->type == T_MX) {
		memcpy(dpa->rdata, buf, 2);
		if ((ui =
			 lbltoname(buf + 2, start_buf, dpa->rdata + 2,
					   rdlen - 2)) == -1) {
			error(err_str);
			err_ret(ERR_DNSMDD, -1);
		}
		if (rdlen != ui + 2) {
			debug(DBG_NORMAL,
				  "In d_a_u(): rdlen (%d) differs from readed bytes (%d).",
				  rdlen, ui + 2);
			err_ret(ERR_DNSMDD, -1);
		}
		count += 2 + ui;
	} else {
		if ((ui = lbltoname(buf, start_buf, dpa->rdata, rdlen)) == -1) {
			error(err_str);
			err_intret(ERR_DNSMDD);
		}
		if (rdlen != ui) {
			debug(DBG_NORMAL,
				  "In d_a_u(): rdlen (%d) differs from readed bytes (%d).",
				  rdlen, ui);
			err_ret(ERR_DNSMDD, -1);
		}
		count += ui;
	}
	return count;
}

/*
 * like d_qs_u. count is the number of section to read.
 * -1 on error.  Bytes readed otherwise.
 */
int
d_as_u(char *start_buf, char *buf, dns_pkt_a ** dpa, int limit_len,
	   int count)
{
	int offset = 0, res;
	int i;

	if (!count)
		return 0;
	for (i = 0; i < count; i++) {
		if ((res =
			 d_a_u(start_buf, buf + offset, dpa,
				   limit_len - offset)) == -1) {
			error(err_str);
			err_intret(ERR_DNSMDD);
		}
		offset += res;
	}
	return offset;
}

/*
 * This is a main function: takes the pkt-buf and translate
 * it in structured data.
 * It cares about dns_pkt allocations.
 *
 * Returns:
 * -1 on E_INTRPRT
 *  0 if pkt must be discarded.
 *  Number of bytes readed otherwise
 */
int
d_u(char *buf, int pktlen, dns_pkt ** dpp)
{
	dns_pkt *dp;
	int offset = 0, res;
	char *crow;

	crow = buf;
	/* Controls pkt consistency: we must at least read pkt headers */
	if (pktlen < DNS_HDR_SZ)
		err_ret(ERR_DNSMDP, 0);
	*dpp = dp = create_dns_pkt();

	/* Writes headers */
	offset += d_hdr_u(buf, &(dp->pkt_hdr));
	if (pktlen > DNS_MAX_SZ)	/* If pkt is too long: the headers are written,
								 * so we can reply with E_INTRPRT
								 */
		err_intret(ERR_DNSPLB);
	crow += offset;
	/* Writes qsts */
	if (dp->pkt_hdr.qdcount) {
		if ((res = d_qsts_u(buf, crow, dp, pktlen - offset)) == -1) {
			error(err_str);
			err_intret(ERR_DNSMDP);
		}
		offset += res;
		crow += res;
	}

	if (dp->pkt_hdr.ancount) {
		if ((res =
			 d_as_u(buf, crow, &(dp->pkt_answ), pktlen - offset,
					DP_ANCOUNT(dp))) == -1) {
			error(err_str);
			err_intret(ERR_DNSMDP);
		}
		offset += res;
	}
	/*crow+=res;
	   if ((res=dpkttoas(buf,crow,&(dp->pkt_auth),pktlen-offset,DP_NSCOUNT(dp)))==-1)
	   return -1;
	   offset+=res;
	   crow+=res;
	   if ((res=dpkttoas(buf,crow,&(dp->pkt_add),pktlen-offset,DP_ARCOUNT(dp)))==-1)
	   return -1; */
	return offset;
}

/*
 * This function is the d_hdr_u inverse.
 * Takes a dns_pkt struct and builds the
 * header pkt-buffer
 * Returns the number of bytes writed.
 */
int
d_hdr_p(dns_pkt * dp, char *buf)
{
	char *crow = buf;
	uint16_t u;
	dns_pkt_hdr *dph;

	dph = &(dp->pkt_hdr);
	u = htons(dph->id);
	memcpy(buf, &u, 2);
	buf += 2;

	if (dph->qr)
		*buf |= 0x80;
	*buf |= dph->opcode << 3;
	*buf |= dph->aa << 2;
	*buf |= dph->tc << 1;
	*buf |= dph->rd;

	buf++;
	*buf |= dph->ra << 7;
	*buf |= dph->z << 4;
	*buf |= dph->rcode;

	buf++;

	u = htons(dph->qdcount);
	memcpy(buf, &u, 2);
	buf += 2;
	u = htons(dph->ancount);
	memcpy(buf, &u, 2);
	buf += 2;
	u = htons(dph->nscount);
	memcpy(buf, &u, 2);
	buf += 2;
	u = htons(dph->arcount);
	memcpy(buf, &u, 2);
	buf += 2;
	return (int) (buf - crow);
}

/*
 * Translate a struct dns_pkt_qst in the dns-buffer buf.
 * Returns:
 *      -1 On error
 *      Bytes writed otherwise.
 */
int
d_qst_p(dns_pkt_qst * dpq, char *buf, int limitlen)
{
	int offset;
	uint16_t u;

	if ((offset = nametolbl(dpq->qname, buf)) == -1) {
		error(err_str);
		err_ret(ERR_DNSMDA, -1);
	}
	if (offset + 4 > limitlen)
		err_ret(ERR_DNSPLB, -1);
	buf += offset;
	u = htons(dpq->qtype);
	memcpy(buf, &u, 2);
	buf += 2;
	offset += 2;
	u = htons(dpq->qclass);
	memcpy(buf, &u, 2);
	buf += 2;
	offset += 2;
	return offset;
}

/*
 * Translates the question sections of a struct dns_pkt
 * into buf.
 * Returns:
 *      -1 on error.
 *      Number of bytes writed otherwise,
 */
int
d_qsts_p(dns_pkt * dp, char *buf, int limitlen)
{
	int offset = 0, res;
	int i;
	dns_pkt_qst *dpq;
	dpq = dp->pkt_qst;

	for (i = 0; dpq && i < DP_QDCOUNT(dp); i++) {
		if ((res = d_qst_p(dpq, buf + offset, limitlen - offset)) == -1) {
			error(err_str);
			err_ret(ERR_DNSMDA, -1);
		}
		offset += res;
		dpq = dpq->next;
	}
	return offset;
}

int
d_a_p(dns_pkt_a * dpa, char *buf, int limitlen)
{
	int offset, rdlen;
	uint16_t u;
	int i;

	if ((rdlen = nametolbl(dpa->name, buf)) == -1)
		return -1;
	offset = rdlen;
	if (offset + 10 > limitlen)
		err_intret(ERR_DNSPLB);
	buf += offset;
	u = htons(dpa->type);
	memcpy(buf, &u, 2);
	buf += 2;
	offset += 2;
	u = htons(dpa->cl);
	memcpy(buf, &u, 2);
	buf += 2;
	offset += 2;
	i = htonl(dpa->ttl);
	memcpy(buf, &i, 4);
	buf += 4;
	offset += 4;

	if (dpa->type == T_A) {
		if (offset + dpa->rdlength > limitlen)
			err_intret(ERR_DNSPLB);
		memcpy(buf + 2, dpa->rdata, dpa->rdlength);
		offset += dpa->rdlength;
	} else if (dpa->type == T_MX) {
		memcpy(buf + 2, dpa->rdata, 2);
		if ((rdlen = nametolbl(dpa->rdata + 2, buf + 4)) == -1) {
			error(err_str);
			err_ret(ERR_DNSMDA, -1);
		}
		offset += rdlen + 2;
		if (offset > limitlen)
			err_ret(ERR_DNSPLB, -1);
		dpa->rdlength = rdlen + 2;
	} else {
		if ((rdlen = nametolbl(dpa->rdata, buf + 2)) == -1) {
			error(err_str);
			err_ret(ERR_DNSMDA, -1);
		}
		offset += rdlen;
		if (offset > limitlen)
			err_ret(ERR_DNSPLB, -1);
		dpa->rdlength = rdlen;
	}
	u = htons(dpa->rdlength);
	memcpy(buf, &u, 2);
	offset += 2;
	return offset;
}

int
d_as_p(dns_pkt_a * dpa, char *buf, int limitlen, int count)
{
	int offset = 0, res;
	int i;
	for (i = 0; dpa && i < count; i++) {
		if ((res = d_a_p(dpa, buf + offset, limitlen - offset)) == -1) {
			error(err_str);
			err_ret(ERR_DNSMDA, -1);
		}
		offset += res;
		dpa = dpa->next;
	}
	return offset;
}

/*
 * Transform a dns_pkt structure in char stream.
 *
 * Returns:
 *      -1 on error
 *      len(stream) if OK
 *
 * The stream has at least the header section writed.
 * `buf' must be at least of DNS_MAX_SZ bytes.
 *
 * DANGER: This function realeses *ALWAYS* the dns_pkt *dp!!!!
 */
int
d_p(dns_pkt * dp, char *buf)
{
	int offset, res;

	memset(buf, 0, DNS_MAX_SZ);

	offset = d_hdr_p(dp, buf);
	buf += offset;
	if ((res = d_qsts_p(dp, buf, DNS_MAX_SZ - offset)) == -1)
		goto server_fail;
	offset += res;
	buf += res;
	if ((res =
		 d_as_p(dp->pkt_answ, buf, DNS_MAX_SZ - offset,
				DP_ANCOUNT(dp))) == -1)
		goto server_fail;
	offset += res;
	/*buf+=res;
	   if ( (res=astodpkt(dp->pkt_auth,buf,DNS_MAX_SZ-offset,DP_NSCOUNT(dp)))==-1)
	   goto server_fail;
	   offset+=res;
	   buf+=res; */
	/*if ( (res=astodpkt(dp->pkt_add,buf,DNS_MAX_SZ-offset,DP_ARCOUNT(dp)))==-1)
	   goto server_fail;
	   offset+=res; */
	destroy_dns_pkt(dp);
	return offset;
  server_fail:
	error(err_str);
	destroy_dns_pkt(dp);
	err_ret(ERR_DNSPDS, -1);
}


/* Memory Functions */

dns_pkt *
create_dns_pkt(void)
{
	dns_pkt *dp;
	dp = xmalloc(DNS_PKT_SZ);
	memset(dp, 0, DNS_PKT_SZ);
	dp->pkt_qst = NULL;
	dp->pkt_answ = NULL;
	dp->pkt_add = NULL;
	dp->pkt_auth = NULL;
	return dp;
}

dns_pkt_qst *
create_dns_pkt_qst(void)
{
	dns_pkt_qst *dpq;
	dpq = xmalloc(DNS_PKT_QST_SZ);
	dpq->next = NULL;
	memset(dpq->qname, 0, DNS_MAX_HNAME_LEN);
	return dpq;
}

dns_pkt_a *
create_dns_pkt_a(void)
{
	dns_pkt_a *dpa;
	dpa = xmalloc(DNS_PKT_A_SZ);
	memset(dpa->name, 0, DNS_MAX_HNAME_LEN);
	memset(dpa->rdata, 0, DNS_MAX_HNAME_LEN);
	dpa->next = NULL;
	return dpa;
}

dns_pkt_qst *
dns_add_qst(dns_pkt * dp)
{
	dns_pkt_qst *dpq, *temp;
	dpq = create_dns_pkt_qst();
	temp = dp->pkt_qst;
	if (!temp) {
		dp->pkt_qst = dpq;
		return dpq;
	}
	while (temp->next)
		temp = temp->next;
	temp->next = dpq;
	return dpq;
}

void
dns_del_last_qst(dns_pkt * dp)
{
	dns_pkt_qst *dpq = dp->pkt_qst;
	if (!dpq)
		return;
	if (!(dpq->next)) {
		xfree(dpq);
		dp->pkt_qst = NULL;
		return;
	}
	while ((dpq->next)->next);
	xfree(dpq->next);
	dpq->next = NULL;
	return;
}

dns_pkt_a *
dns_add_a(dns_pkt_a ** dpa)
{
	dns_pkt_a *dpa_add, *a;
	int count = 0;

	a = *dpa;
	dpa_add = create_dns_pkt_a();
	if (!a) {
		(*dpa) = dpa_add;
	} else {
		while (a->next) {
			a = a->next;
			count++;
		}
		a->next = dpa_add;
	}
	return dpa_add;
}

void
dns_a_default_fill(dns_pkt * dp, dns_pkt_a * dpa)
{
	strcpy(dpa->name, dp->pkt_qst->qname);
	dpa->cl = C_IN;
	dpa->ttl = DNS_TTL;
	dpa->type = dp->pkt_qst->qtype;
}

void
destroy_dns_pkt(dns_pkt * dp)
{
	dns_pkt_a *dpa, *dpa_t;
	dns_pkt_qst *dpq, *dpq_t;

	if (dp->pkt_qst) {
		dpq = dp->pkt_qst;
		while (dpq) {
			dpq_t = dpq->next;
			xfree(dpq);
			dpq = dpq_t;
		}
	}
	if (dp->pkt_answ) {
		dpa = dp->pkt_answ;
		while (dpa) {
			dpa_t = dpa->next;
			xfree(dpa);
			dpa = dpa_t;
		}
	}
	if (dp->pkt_add) {
		dpa = dp->pkt_add;
		while (dpa) {
			dpa_t = dpa->next;
			xfree(dpa);
			dpa = dpa_t;
		}
	}
	if (dp->pkt_auth) {
		dpa = dp->pkt_auth;
		while (dpa) {
			dpa_t = dpa->next;
			xfree(dpa);
			dpa = dpa_t;
		}
	}
	xfree(dp);
	return;
}