libaddns/dnsmarshall.c

説明を見る。

/*
  Linux DNS client library implementation
  Copyright (C) 2006 Gerald Carter <jerry@samba.org>

     ** NOTE! The following LGPL license applies to the libaddns
     ** library. This does NOT imply that all of Samba is released
     ** under the LGPL

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  
  02110-1301  USA
*/

#include "dns.h"
#include "assert.h"

struct dns_buffer *dns_create_buffer(TALLOC_CTX *mem_ctx)
{
        struct dns_buffer *result;

        if (!(result = talloc(mem_ctx, struct dns_buffer))) {
                return NULL;
        }

        result->offset = 0;
        result->error = ERROR_DNS_SUCCESS;
        
        /*
         * Small inital size to excercise the realloc code
         */
        result->size = 2;

        if (!(result->data = TALLOC_ARRAY(result, uint8, result->size))) {
                TALLOC_FREE(result);
                return NULL;
        }

        return result;
}

void dns_marshall_buffer(struct dns_buffer *buf, const uint8 *data,
                         size_t len)
{
        if (!ERR_DNS_IS_OK(buf->error)) return;

        if (buf->offset + len < buf->offset) {
                /*
                 * Wraparound!
                 */
                buf->error = ERROR_DNS_INVALID_PARAMETER;
                return;
        }

        if ((buf->offset + len) > 0xffff) {
                /*
                 * Only 64k possible
                 */
                buf->error = ERROR_DNS_INVALID_PARAMETER;
                return;
        }
                
        if (buf->offset + len > buf->size) {
                size_t new_size = buf->offset + len;
                uint8 *new_data;

                /*
                 * Don't do too many reallocs, round up to some multiple
                 */

                new_size += (64 - (new_size % 64));

                if (!(new_data = TALLOC_REALLOC_ARRAY(buf, buf->data, uint8,
                                                      new_size))) {
                        buf->error = ERROR_DNS_NO_MEMORY;
                        return;
                }

                buf->size = new_size;
                buf->data = new_data;
        }

        memcpy(buf->data + buf->offset, data, len);
        buf->offset += len;
        return;
}

void dns_marshall_uint16(struct dns_buffer *buf, uint16 val)
{
        uint16 n_val = htons(val);
        dns_marshall_buffer(buf, (uint8 *)&n_val, sizeof(n_val));
}

void dns_marshall_uint32(struct dns_buffer *buf, uint32 val)
{
        uint32 n_val = htonl(val);
        dns_marshall_buffer(buf, (uint8 *)&n_val, sizeof(n_val));
}

void dns_unmarshall_buffer(struct dns_buffer *buf, uint8 *data,
                           size_t len)
{
        if (!(ERR_DNS_IS_OK(buf->error))) return;

        if ((len > buf->size) || (buf->offset + len > buf->size)) {
                buf->error = ERROR_DNS_INVALID_MESSAGE;
                return;
        }

        memcpy((void *)data, (const void *)(buf->data + buf->offset), len);
        buf->offset += len;

        return;
}

void dns_unmarshall_uint16(struct dns_buffer *buf, uint16 *val)
{
        uint16 n_val;

        dns_unmarshall_buffer(buf, (uint8 *)&n_val, sizeof(n_val));
        if (!(ERR_DNS_IS_OK(buf->error))) return;

        *val = ntohs(n_val);
}

void dns_unmarshall_uint32(struct dns_buffer *buf, uint32 *val)
{
        uint32 n_val;

        dns_unmarshall_buffer(buf, (uint8 *)&n_val, sizeof(n_val));
        if (!(ERR_DNS_IS_OK(buf->error))) return;

        *val = ntohl(n_val);
}

void dns_marshall_domain_name(struct dns_buffer *buf,
                              const struct dns_domain_name *name)
{
        struct dns_domain_label *label;
        char end_char = '\0';

        /*
         * TODO: Implement DNS compression
         */

        for (label = name->pLabelList; label != NULL; label = label->next) {
                uint8 len = label->len;

                dns_marshall_buffer(buf, (uint8 *)&len, sizeof(len));
                if (!ERR_DNS_IS_OK(buf->error)) return;

                dns_marshall_buffer(buf, (uint8 *)label->label, len);
                if (!ERR_DNS_IS_OK(buf->error)) return;
        }

        dns_marshall_buffer(buf, (uint8 *)&end_char, 1);
}

static void dns_unmarshall_label(TALLOC_CTX *mem_ctx,
                                 int level,
                                 struct dns_buffer *buf,
                                 struct dns_domain_label **plabel)
{
        struct dns_domain_label *label;
        uint8 len;

        if (!ERR_DNS_IS_OK(buf->error)) return;

        if (level > 128) {
                /*
                 * Protect against recursion
                 */
                buf->error = ERROR_DNS_INVALID_MESSAGE;
                return;
        }

        dns_unmarshall_buffer(buf, &len, sizeof(len));
        if (!ERR_DNS_IS_OK(buf->error)) return;

        if (len == 0) {
                *plabel = NULL;
                return;
        }

        if ((len & 0xc0) == 0xc0) {
                /*
                 * We've got a compressed name. Build up a new "fake" buffer
                 * and using the calculated offset.
                 */
                struct dns_buffer new_buf;
                uint8 low;

                dns_unmarshall_buffer(buf, &low, sizeof(low));
                if (!ERR_DNS_IS_OK(buf->error)) return;

                new_buf = *buf;
                new_buf.offset = len & 0x3f;
                new_buf.offset <<= 8;
                new_buf.offset |= low;

                dns_unmarshall_label(mem_ctx, level+1, &new_buf, plabel);
                buf->error = new_buf.error;
                return;
        }

        if ((len & 0xc0) != 0) {
                buf->error = ERROR_DNS_INVALID_NAME;
                return;
        }

        if (!(label = talloc(mem_ctx, struct dns_domain_label))) {
                buf->error = ERROR_DNS_NO_MEMORY;
                return;
        }

        label->len = len;

        if (!(label->label = TALLOC_ARRAY(label, char, len+1))) {
                buf->error = ERROR_DNS_NO_MEMORY;
                goto error;
        }

        dns_unmarshall_buffer(buf, (uint8 *)label->label, len);
        if (!ERR_DNS_IS_OK(buf->error)) goto error;

        dns_unmarshall_label(label, level+1, buf, &label->next);
        if (!ERR_DNS_IS_OK(buf->error)) goto error;

        *plabel = label;
        return;

 error:
        TALLOC_FREE(label);
        return;
}

void dns_unmarshall_domain_name(TALLOC_CTX *mem_ctx,
                                struct dns_buffer *buf,
                                struct dns_domain_name **pname)
{
        struct dns_domain_name *name;

        if (!ERR_DNS_IS_OK(buf->error)) return;

        if (!(name = talloc(mem_ctx, struct dns_domain_name))) {
                buf->error = ERROR_DNS_NO_MEMORY;
        }

        dns_unmarshall_label(name, 0, buf, &name->pLabelList);

        if (!ERR_DNS_IS_OK(buf->error)) {
                return;
        }

        *pname = name;
        return;
}

static void dns_marshall_question(struct dns_buffer *buf,
                                  const struct dns_question *q)
{
        dns_marshall_domain_name(buf, q->name);
        dns_marshall_uint16(buf, q->q_type);
        dns_marshall_uint16(buf, q->q_class);
}

static void dns_unmarshall_question(TALLOC_CTX *mem_ctx,
                                    struct dns_buffer *buf,
                                    struct dns_question **pq)
{
        struct dns_question *q;

        if (!(ERR_DNS_IS_OK(buf->error))) return;

        if (!(q = talloc(mem_ctx, struct dns_question))) {
                buf->error = ERROR_DNS_NO_MEMORY;
                return;
        }

        dns_unmarshall_domain_name(q, buf, &q->name);
        dns_unmarshall_uint16(buf, &q->q_type);
        dns_unmarshall_uint16(buf, &q->q_class);

        if (!(ERR_DNS_IS_OK(buf->error))) return;

        *pq = q;
}

static void dns_marshall_rr(struct dns_buffer *buf,
                            const struct dns_rrec *r)
{
        dns_marshall_domain_name(buf, r->name);
        dns_marshall_uint16(buf, r->type);
        dns_marshall_uint16(buf, r->r_class);
        dns_marshall_uint32(buf, r->ttl);
        dns_marshall_uint16(buf, r->data_length);
        dns_marshall_buffer(buf, r->data, r->data_length);
}

static void dns_unmarshall_rr(TALLOC_CTX *mem_ctx,
                              struct dns_buffer *buf,
                              struct dns_rrec **pr)
{
        struct dns_rrec *r;

        if (!(ERR_DNS_IS_OK(buf->error))) return;

        if (!(r = talloc(mem_ctx, struct dns_rrec))) {
                buf->error = ERROR_DNS_NO_MEMORY;
                return;
        }

        dns_unmarshall_domain_name(r, buf, &r->name);
        dns_unmarshall_uint16(buf, &r->type);
        dns_unmarshall_uint16(buf, &r->r_class);
        dns_unmarshall_uint32(buf, &r->ttl);
        dns_unmarshall_uint16(buf, &r->data_length);
        r->data = NULL;

        if (!(ERR_DNS_IS_OK(buf->error))) return;

        if (r->data_length != 0) {
                if (!(r->data = TALLOC_ARRAY(r, uint8, r->data_length))) {
                        buf->error = ERROR_DNS_NO_MEMORY;
                        return;
                }
                dns_unmarshall_buffer(buf, r->data, r->data_length);
        }

        if (!(ERR_DNS_IS_OK(buf->error))) return;

        *pr = r;
}

DNS_ERROR dns_marshall_request(TALLOC_CTX *mem_ctx,
                               const struct dns_request *req,
                               struct dns_buffer **pbuf)
{
        struct dns_buffer *buf;
        uint16 i;

        if (!(buf = dns_create_buffer(mem_ctx))) {
                return ERROR_DNS_NO_MEMORY;
        }

        dns_marshall_uint16(buf, req->id);
        dns_marshall_uint16(buf, req->flags);
        dns_marshall_uint16(buf, req->num_questions);
        dns_marshall_uint16(buf, req->num_answers);
        dns_marshall_uint16(buf, req->num_auths);
        dns_marshall_uint16(buf, req->num_additionals);

        for (i=0; i<req->num_questions; i++) {
                dns_marshall_question(buf, req->questions[i]);
        }
        for (i=0; i<req->num_answers; i++) {
                dns_marshall_rr(buf, req->answers[i]);
        }
        for (i=0; i<req->num_auths; i++) {
                dns_marshall_rr(buf, req->auths[i]);
        }
        for (i=0; i<req->num_additionals; i++) {
                dns_marshall_rr(buf, req->additionals[i]);
        }

        if (!ERR_DNS_IS_OK(buf->error)) {
                DNS_ERROR err = buf->error;
                TALLOC_FREE(buf);
                return err;
        }

        *pbuf = buf;
        return ERROR_DNS_SUCCESS;
}

DNS_ERROR dns_unmarshall_request(TALLOC_CTX *mem_ctx,
                                 struct dns_buffer *buf,
                                 struct dns_request **preq)
{
        struct dns_request *req;
        uint16 i;
        DNS_ERROR err;

        if (!(req = TALLOC_ZERO_P(mem_ctx, struct dns_request))) {
                return ERROR_DNS_NO_MEMORY;
        }

        dns_unmarshall_uint16(buf, &req->id);
        dns_unmarshall_uint16(buf, &req->flags);
        dns_unmarshall_uint16(buf, &req->num_questions);
        dns_unmarshall_uint16(buf, &req->num_answers);
        dns_unmarshall_uint16(buf, &req->num_auths);
        dns_unmarshall_uint16(buf, &req->num_additionals);

        if (!ERR_DNS_IS_OK(buf->error)) goto error;

        err = ERROR_DNS_NO_MEMORY;

        if ((req->num_questions != 0) &&
            !(req->questions = TALLOC_ARRAY(req, struct dns_question *,
                                            req->num_questions))) {
                goto error;
        }
        if ((req->num_answers != 0) &&
            !(req->answers = TALLOC_ARRAY(req, struct dns_rrec *,
                                          req->num_answers))) {
                goto error;
        }
        if ((req->num_auths != 0) &&
            !(req->auths = TALLOC_ARRAY(req, struct dns_rrec *,
                                        req->num_auths))) {
                goto error;
        }
        if ((req->num_additionals != 0) &&
            !(req->additionals = TALLOC_ARRAY(req, struct dns_rrec *,
                                              req->num_additionals))) {
                goto error;
        }

        for (i=0; i<req->num_questions; i++) {
                dns_unmarshall_question(req->questions, buf,
                                        &req->questions[i]);
        }
        for (i=0; i<req->num_answers; i++) {
                dns_unmarshall_rr(req->answers, buf,
                                  &req->answers[i]);
        }
        for (i=0; i<req->num_auths; i++) {
                dns_unmarshall_rr(req->auths, buf,
                                  &req->auths[i]);
        }
        for (i=0; i<req->num_additionals; i++) {
                dns_unmarshall_rr(req->additionals, buf,
                                  &req->additionals[i]);
        }

        if (!ERR_DNS_IS_OK(buf->error)) {
                err = buf->error;
                goto error;
        }

        *preq = req;
        return ERROR_DNS_SUCCESS;

 error:
        err = buf->error;
        TALLOC_FREE(req);
        return err;
}

struct dns_request *dns_update2request(struct dns_update_request *update)
{
        struct dns_request *req;

        /*
         * This is a non-specified construct that happens to work on Linux/gcc
         * and I would expect it to work everywhere else. dns_request and
         * dns_update_request are essentially the same structures with
         * different names, so any difference would mean that the compiler
         * applied two different variations of padding given the same types in
         * the structures.
         */

        req = (struct dns_request *)(void *)update;

        /*
         * The assert statement here looks like we could do the equivalent
         * assignments to get portable, but it would mean that we have to
         * allocate the dns_question record for the dns_zone records. We
         * assume that if this assert works then the same holds true for
         * dns_zone<>dns_question as well.
         */

#ifdef DEVELOPER
        assert((req->id == update->id) && (req->flags == update->flags) &&
               (req->num_questions == update->num_zones) &&
               (req->num_answers == update->num_preqs) &&
               (req->num_auths == update->num_updates) &&
               (req->num_additionals == update->num_additionals) &&
               (req->questions ==
                (struct dns_question **)(void *)update->zones) &&
               (req->answers == update->preqs) &&
               (req->auths == update->updates) &&
               (req->additionals == update->additionals));
#endif

        return req;
}

struct dns_update_request *dns_request2update(struct dns_request *request)
{
        /*
         * For portability concerns see dns_update2request;
         */
        return (struct dns_update_request *)(void *)request;
}

DNS_ERROR dns_marshall_update_request(TALLOC_CTX *mem_ctx,
                                      struct dns_update_request *update,
                                      struct dns_buffer **pbuf)
{
        return dns_marshall_request(mem_ctx, dns_update2request(update), pbuf);
}

DNS_ERROR dns_unmarshall_update_request(TALLOC_CTX *mem_ctx,
                                        struct dns_buffer *buf,
                                        struct dns_update_request **pupreq)
{
        /*
         * See comments above about portability. If the above works, this will
         * as well.
         */

        return dns_unmarshall_request(mem_ctx, buf,
                                      (struct dns_request **)(void *)pupreq);
}

uint16 dns_response_code(uint16 flags)
{
        return flags & 0xF;
}

---