/* 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, see <http://www.gnu.org/licenses/>. */ #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; return; } 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; }