libaddns/dnsmarshall.c

ソースコードを見る。

関数
dns_buffer *	dns_create_buffer (TALLOC_CTX *mem_ctx)
void	dns_marshall_buffer (struct dns_buffer *buf, const uint8 *data, size_t len)
void	dns_marshall_uint16 (struct dns_buffer *buf, uint16 val)
void	dns_marshall_uint32 (struct dns_buffer *buf, uint32 val)
void	dns_unmarshall_buffer (struct dns_buffer *buf, uint8 *data, size_t len)
void	dns_unmarshall_uint16 (struct dns_buffer *buf, uint16 *val)
void	dns_unmarshall_uint32 (struct dns_buffer *buf, uint32 *val)
void	dns_marshall_domain_name (struct dns_buffer *buf, const struct dns_domain_name *name)
static void	dns_unmarshall_label (TALLOC_CTX *mem_ctx, int level, struct dns_buffer *buf, struct dns_domain_label **plabel)
void	dns_unmarshall_domain_name (TALLOC_CTX *mem_ctx, struct dns_buffer *buf, struct dns_domain_name **pname)
static void	dns_marshall_question (struct dns_buffer *buf, const struct dns_question *q)
static void	dns_unmarshall_question (TALLOC_CTX *mem_ctx, struct dns_buffer *buf, struct dns_question **pq)
static void	dns_marshall_rr (struct dns_buffer *buf, const struct dns_rrec *r)
static void	dns_unmarshall_rr (TALLOC_CTX *mem_ctx, struct dns_buffer *buf, struct dns_rrec **pr)
DNS_ERROR	dns_marshall_request (TALLOC_CTX *mem_ctx, const struct dns_request *req, struct dns_buffer **pbuf)
DNS_ERROR	dns_unmarshall_request (TALLOC_CTX *mem_ctx, struct dns_buffer *buf, struct dns_request **preq)
dns_request *	dns_update2request (struct dns_update_request *update)
dns_update_request *	dns_request2update (struct dns_request *request)
DNS_ERROR	dns_marshall_update_request (TALLOC_CTX *mem_ctx, struct dns_update_request *update, struct dns_buffer **pbuf)
DNS_ERROR	dns_unmarshall_update_request (TALLOC_CTX *mem_ctx, struct dns_buffer *buf, struct dns_update_request **pupreq)
uint16	dns_response_code (uint16 flags)

---

関数

struct dns_buffer* dns_create_buffer

(

TALLOC_CTX *

mem_ctx

)

dnsmarshall.c の 28 行で定義されています。

参照先 result.

参照元 dns_create_tkey_record()・dns_create_tsig_record()・dns_marshall_request().

{
        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
	)

dnsmarshall.c の 52 行で定義されています。

参照先 buf・dns_buffer::offset.

参照元 dns_create_tkey_record()・dns_create_tsig_record()・dns_marshall_domain_name()・dns_marshall_rr()・dns_marshall_uint16()・dns_marshall_uint32().

{
        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
	)

dnsmarshall.c の 98 行で定義されています。

参照先 buf・dns_marshall_buffer().

参照元 dns_create_tkey_record()・dns_create_tsig_record()・dns_marshall_question()・dns_marshall_request()・dns_marshall_rr()・dns_sign_update().

{
        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
	)

dnsmarshall.c の 104 行で定義されています。

参照先 buf・dns_marshall_buffer().

参照元 dns_create_tkey_record()・dns_create_tsig_record()・dns_marshall_rr()・dns_sign_update().

{
        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
	)

dnsmarshall.c の 110 行で定義されています。

参照先 buf.

参照元 dns_unmarshall_label()・dns_unmarshall_rr()・dns_unmarshall_tkey_record()・dns_unmarshall_uint16()・dns_unmarshall_uint32().

{
        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
	)

dnsmarshall.c の 126 行で定義されています。

参照先 buf・dns_unmarshall_buffer().

参照元 dns_unmarshall_question()・dns_unmarshall_request()・dns_unmarshall_rr()・dns_unmarshall_tkey_record().

{
        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
	)

dnsmarshall.c の 136 行で定義されています。

参照先 buf・dns_unmarshall_buffer().

参照元 dns_unmarshall_rr()・dns_unmarshall_tkey_record().

{
        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
	)

dnsmarshall.c の 146 行で定義されています。

参照先 buf・dns_marshall_buffer()・dns_domain_label::label・len・name.

参照元 dns_create_tkey_record()・dns_create_tsig_record()・dns_marshall_question()・dns_marshall_rr()・dns_sign_update().

{
        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
	)			[static]

dnsmarshall.c の 169 行で定義されています。

参照先 buf・dns_unmarshall_buffer()・error・dns_buffer::error・dns_domain_label::label・dns_domain_label::len・len・dns_domain_label::next・dns_buffer::offset.

参照元 dns_unmarshall_domain_name().

{
        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
	)

dnsmarshall.c の 247 行で定義されています。

参照先 buf・dns_unmarshall_label()・name.

参照元 dns_unmarshall_question()・dns_unmarshall_rr()・dns_unmarshall_tkey_record().

{
        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
	)			[static]

dnsmarshall.c の 269 行で定義されています。

参照先 buf・dns_marshall_domain_name()・dns_marshall_uint16()・dns_question::name・dns_question::q_class・dns_question::q_type.

参照元 dns_marshall_request().

{
        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
	)			[static]

dnsmarshall.c の 277 行で定義されています。

参照先 buf・dns_unmarshall_domain_name()・dns_unmarshall_uint16()・dns_question::name・dns_question::q_class・dns_question::q_type.

参照元 dns_unmarshall_request().

{
        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
	)			[static]

dnsmarshall.c の 299 行で定義されています。

参照先 buf・dns_rrec::data・dns_rrec::data_length・dns_marshall_buffer()・dns_marshall_domain_name()・dns_marshall_uint16()・dns_marshall_uint32()・dns_rrec::name・dns_rrec::r_class・dns_rrec::ttl・dns_rrec::type.

参照元 dns_marshall_request().

{
        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
	)			[static]

dnsmarshall.c の 310 行で定義されています。

参照先 buf・dns_rrec::data・dns_rrec::data_length・dns_unmarshall_buffer()・dns_unmarshall_domain_name()・dns_unmarshall_uint16()・dns_unmarshall_uint32()・dns_rrec::name・dns_rrec::r_class・dns_rrec::ttl・dns_rrec::type.

参照元 dns_unmarshall_request().

{
        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
	)

dnsmarshall.c の 345 行で定義されています。

参照先 dns_request::additionals・dns_request::answers・dns_request::auths・buf・dns_create_buffer()・dns_marshall_question()・dns_marshall_rr()・dns_marshall_uint16()・err・dns_request::flags・dns_request::id・dns_request::num_additionals・dns_request::num_answers・dns_request::num_auths・dns_request::num_questions・dns_request::questions.

参照元 dns_marshall_update_request()・dns_negotiate_gss_ctx_int()・dns_transaction().

{
        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
	)

dnsmarshall.c の 386 行で定義されています。

参照先 dns_request::additionals・dns_request::answers・dns_request::auths・buf・dns_unmarshall_question()・dns_unmarshall_rr()・dns_unmarshall_uint16()・err・error・dns_request::flags・dns_request::id・dns_request::num_additionals・dns_request::num_answers・dns_request::num_auths・dns_request::num_questions・dns_request::questions.

参照元 dns_negotiate_gss_ctx_int()・dns_transaction()・dns_unmarshall_update_request().

{
        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

)

dnsmarshall.c の 461 行で定義されています。

参照先 dns_update_request::additionals・dns_request::additionals・dns_request::answers・dns_request::auths・dns_update_request::flags・dns_request::flags・dns_update_request::id・dns_request::id・dns_update_request::num_additionals・dns_request::num_additionals・dns_request::num_answers・dns_request::num_auths・dns_update_request::num_preqs・dns_request::num_questions・dns_update_request::num_updates・dns_update_request::num_zones・dns_update_request::preqs・dns_request::questions・dns_update_request::updates・dns_update_request::zones.

参照元 dns_marshall_update_request()・dns_update_transaction().

{
        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

)

dnsmarshall.c の 500 行で定義されています。

参照元 dns_update_transaction().

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

dnsmarshall.c の 508 行で定義されています。

参照先 dns_marshall_request()・dns_update2request().

参照元 dns_sign_update().

{
        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
	)

dnsmarshall.c の 515 行で定義されています。

参照先 buf・dns_unmarshall_request().

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

)

dnsmarshall.c の 528 行で定義されています。

参照元 DoDNSUpdate().

{
        return flags & 0xF;
}

---