/*
 * 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>

#include <arpa/nameser.h>

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

#include <port_after.h>

static int      rdcpy(ns_newmsg *, ns_type, const u_char *, size_t);

/* Initialize a "newmsg" object to empty.
 */
int
ns_newmsg_init(u_char *buffer, size_t bufsiz, ns_newmsg *handle) {
        ns_msg *msg = &handle->msg;

        memset(handle, 0, sizeof *handle);
        msg->_msg = buffer;
        msg->_eom = buffer + bufsiz;
        msg->_sect = ns_s_qd;
        msg->_rrnum = 0;
        msg->_msg_ptr = buffer + NS_HFIXEDSZ;
        handle->dnptrs[0] = msg->_msg;
        handle->dnptrs[1] = NULL;
        handle->lastdnptr = &handle->dnptrs[sizeof handle->dnptrs /
                                            sizeof handle->dnptrs[0] - 1];
        return (0);
}

/* Initialize a "newmsg" object by copying an existing parsed message.
 */
int
ns_newmsg_copy(ns_newmsg *handle, ns_msg *msg) {
        ns_flag flag;
        ns_sect sect;

        ns_newmsg_id(handle, ns_msg_id(*msg));
        for (flag = ns_f_qr; flag < ns_f_max; flag++)
                ns_newmsg_flag(handle, flag, ns_msg_getflag(*msg, flag));
        for (sect = ns_s_qd; sect < ns_s_max; sect++) {
                int i, count;

                count = ns_msg_count(*msg, sect);
                for (i = 0; i < count; i++) {
                        ns_rr2 rr;
                        int x;

                        if (ns_parserr2(msg, sect, i, &rr) < 0)
                                return (-1);
                        if (sect == ns_s_qd)
                                x = ns_newmsg_q(handle,
                                                ns_rr_nname(rr),
                                                ns_rr_type(rr),
                                                ns_rr_class(rr));
                        else
                                x = ns_newmsg_rr(handle, sect,
                                                 ns_rr_nname(rr),
                                                 ns_rr_type(rr),
                                                 ns_rr_class(rr),
                                                 ns_rr_ttl(rr),
                                                 ns_rr_rdlen(rr),
                                                 ns_rr_rdata(rr));
                        if (x < 0)
                                return (-1);
                }
        }
        return (0);
}

/* Set the message-ID in a "newmsg" object.
 */
void
ns_newmsg_id(ns_newmsg *handle, u_int16_t id) {
        ns_msg *msg = &handle->msg;

        msg->_id = id;
}

/* Set a flag (including rcode or opcode) in a "newmsg" object.
 */
void
ns_newmsg_flag(ns_newmsg *handle, ns_flag flag, u_int value) {
        extern struct _ns_flagdata _ns_flagdata[16];
        struct _ns_flagdata *fd = &_ns_flagdata[flag];
        ns_msg *msg = &handle->msg;

        assert(flag < ns_f_max);
        msg->_flags &= (~fd->mask);
        msg->_flags |= (value << fd->shift);
}

/* Add a question (or zone, if it's an update) to a "newmsg" object.
 */
int
ns_newmsg_q(ns_newmsg *handle, ns_nname_ct qname,
            ns_type qtype, ns_class qclass)
{
        ns_msg *msg = &handle->msg;
        u_char *t;
        int n;

        if (msg->_sect != ns_s_qd) {
                errno = ENODEV;
                return (-1);
        }
        t = (u_char *) (unsigned long) msg->_msg_ptr;
        if (msg->_rrnum == 0)
                msg->_sections[ns_s_qd] = t;
        n = ns_name_pack(qname, t, msg->_eom - t,
                         handle->dnptrs, handle->lastdnptr);
        if (n < 0)
                return (-1);
        t += n;
        if (t + QFIXEDSZ >= msg->_eom) {
                errno = EMSGSIZE;
                return (-1);
        }
        NS_PUT16(qtype, t);
        NS_PUT16(qclass, t);
        msg->_msg_ptr = t;
        msg->_counts[ns_s_qd] = ++msg->_rrnum;
        return (0);
}

/* Add an RR to a "newmsg" object.
 */
int
ns_newmsg_rr(ns_newmsg *handle, ns_sect sect,
             ns_nname_ct name, ns_type type,
             ns_class rr_class, u_int32_t ttl,
             u_int16_t rdlen, const u_char *rdata)
{
        ns_msg *msg = &handle->msg;
        u_char *t;
        int n;

        if (sect < msg->_sect) {
                errno = ENODEV;
                return (-1);
        }
        t = (u_char *) (unsigned long) msg->_msg_ptr;
        if (sect > msg->_sect) {
                msg->_sect = sect;
                msg->_sections[sect] = t;
                msg->_rrnum = 0;
        }
        n = ns_name_pack(name, t, msg->_eom - t,
                         handle->dnptrs, handle->lastdnptr);
        if (n < 0)
                return (-1);
        t += n;
        if (t + RRFIXEDSZ + rdlen >= msg->_eom) {
                errno = EMSGSIZE;
                return (-1);
        }
        NS_PUT16(type, t);
        NS_PUT16(rr_class, t);
        NS_PUT32(ttl, t);
        msg->_msg_ptr = t;
        if (rdcpy(handle, type, rdata, rdlen) < 0)
                return (-1);
        msg->_counts[sect] = ++msg->_rrnum;
        return (0);
}

/* Complete a "newmsg" object and return its size for use in write().
 * (Note: the "newmsg" object is also made ready for ns_parserr() etc.)
 */
size_t
ns_newmsg_done(ns_newmsg *handle) {
        ns_msg *msg = &handle->msg;
        ns_sect sect;
        u_char *t;

        t = (u_char *) (unsigned long) msg->_msg;
        NS_PUT16(msg->_id, t);
        NS_PUT16(msg->_flags, t);
        for (sect = 0; sect < ns_s_max; sect++)
                NS_PUT16(msg->_counts[sect], t);
        msg->_eom = msg->_msg_ptr;
        msg->_sect = ns_s_max;
        msg->_rrnum = -1;
        msg->_msg_ptr = NULL;
        return (msg->_eom - msg->_msg);
}

/* Private. */

/* Copy an RDATA, using compression pointers where RFC1035 permits.
 */
static int
rdcpy(ns_newmsg *handle, ns_type type, const u_char *rdata, size_t rdlen) {
        ns_msg *msg = &handle->msg;
        u_char *p = (u_char *) (unsigned long) msg->_msg_ptr;
        u_char *t = p + NS_INT16SZ;
        u_char *s = t;
        int n;

        switch (type) {
        case ns_t_soa:
                /* MNAME. */
                n = ns_name_pack(rdata, t, msg->_eom - t,
                                 handle->dnptrs, handle->lastdnptr);
                if (n < 0)
                        return (-1);
                t += n;
                if (ns_name_skip(&rdata, msg->_eom) < 0)
                        return (-1);

                /* ANAME. */
                n = ns_name_pack(rdata, t, msg->_eom - t,
                                 handle->dnptrs, handle->lastdnptr);
                if (n < 0)
                        return (-1);
                t += n;
                if (ns_name_skip(&rdata, msg->_eom) < 0)
                        return (-1);

                /* Serial, Refresh, Retry, Expiry, and Minimum. */
                if ((msg->_eom - t) < (NS_INT32SZ * 5)) {
                        errno = EMSGSIZE;
                        return (-1);
                }
                memcpy(t, rdata, NS_INT32SZ * 5);
                t += (NS_INT32SZ * 5);
                break;
        case ns_t_ptr:
        case ns_t_cname:
        case ns_t_ns:
                /* PTRDNAME, CNAME, or NSDNAME. */
                n = ns_name_pack(rdata, t, msg->_eom - t,
                                 handle->dnptrs, handle->lastdnptr);
                if (n < 0)
                        return (-1);
                t += n;
                break;
        default:
                memcpy(t, rdata, rdlen);
                t += rdlen;
        }
        NS_PUT16(t - s, p);
        msg->_msg_ptr = t;
        return (0);
}