Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 :
4 : manipulate dns name structures
5 :
6 : Copyright (C) 2010 Kai Blin <kai@samba.org>
7 :
8 : Heavily based on nbtname.c which is:
9 :
10 : Copyright (C) Andrew Tridgell 2005
11 :
12 : This program is free software; you can redistribute it and/or modify
13 : it under the terms of the GNU General Public License as published by
14 : the Free Software Foundation; either version 3 of the License, or
15 : (at your option) any later version.
16 :
17 : This program is distributed in the hope that it will be useful,
18 : but WITHOUT ANY WARRANTY; without even the implied warranty of
19 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 : GNU General Public License for more details.
21 :
22 : You should have received a copy of the GNU General Public License
23 : along with this program. If not, see <http://www.gnu.org/licenses/>.
24 : */
25 :
26 : /*
27 : see rfc1002 for the detailed format of compressed names
28 : */
29 :
30 : #include "includes.h"
31 : #include "librpc/gen_ndr/ndr_dns.h"
32 : #include "librpc/gen_ndr/ndr_misc.h"
33 : #include "librpc/gen_ndr/ndr_dnsp.h"
34 : #include "system/locale.h"
35 : #include "lib/util/util_net.h"
36 : #include "ndr_dns_utils.h"
37 :
38 : /* don't allow an unlimited number of name components */
39 : #define MAX_COMPONENTS 128
40 :
41 : /**
42 : print a dns string
43 : */
44 6 : _PUBLIC_ void ndr_print_dns_string(struct ndr_print *ndr,
45 : const char *name,
46 : const char *s)
47 : {
48 6 : ndr_print_string(ndr, name, s);
49 6 : }
50 :
51 : /*
52 : pull one component of a dns_string
53 : */
54 202344 : static enum ndr_err_code ndr_pull_component(struct ndr_pull *ndr,
55 : uint8_t **component,
56 : uint32_t *offset,
57 : uint32_t *max_offset)
58 : {
59 276 : uint8_t len;
60 202344 : unsigned int loops = 0;
61 222290 : while (loops < 5) {
62 222290 : if (*offset >= ndr->data_size) {
63 0 : return ndr_pull_error(ndr, NDR_ERR_STRING,
64 : "BAD DNS NAME component, bad offset");
65 : }
66 222290 : len = ndr->data[*offset];
67 222290 : if (len == 0) {
68 34496 : *offset += 1;
69 34496 : *max_offset = MAX(*max_offset, *offset);
70 34496 : *component = NULL;
71 34496 : return NDR_ERR_SUCCESS;
72 : }
73 187794 : if ((len & 0xC0) == 0xC0) {
74 : /* its a label pointer */
75 19946 : if (1 + *offset >= ndr->data_size) {
76 0 : return ndr_pull_error(ndr, NDR_ERR_STRING,
77 : "BAD DNS NAME component, " \
78 : "bad label offset");
79 : }
80 19946 : *max_offset = MAX(*max_offset, *offset + 2);
81 19946 : *offset = ((len&0x3F)<<8) | ndr->data[1 + *offset];
82 19946 : *max_offset = MAX(*max_offset, *offset);
83 19946 : loops++;
84 19946 : continue;
85 : }
86 167848 : if ((len & 0xC0) != 0) {
87 : /* its a reserved length field */
88 0 : return ndr_pull_error(ndr, NDR_ERR_STRING,
89 : "BAD DNS NAME component, " \
90 : "reserved length field: 0x%02"PRIx8,
91 : (len &0xC));
92 : }
93 167848 : if (*offset + len + 1 > ndr->data_size) {
94 0 : return ndr_pull_error(ndr, NDR_ERR_STRING,
95 : "BAD DNS NAME component, "\
96 : "length too long");
97 : }
98 335696 : *component = (uint8_t*)talloc_strndup(ndr,
99 167848 : (const char *)&ndr->data[1 + *offset], len);
100 167848 : NDR_ERR_HAVE_NO_MEMORY(*component);
101 167848 : *offset += len + 1;
102 167848 : *max_offset = MAX(*max_offset, *offset);
103 167848 : return NDR_ERR_SUCCESS;
104 : }
105 :
106 : /* too many pointers */
107 0 : return ndr_pull_error(ndr, NDR_ERR_STRING,
108 : "BAD DNS NAME component, too many pointers");
109 : }
110 :
111 : /**
112 : pull a dns_string from the wire
113 : */
114 34496 : _PUBLIC_ enum ndr_err_code ndr_pull_dns_string(struct ndr_pull *ndr,
115 : ndr_flags_type ndr_flags,
116 : const char **s)
117 : {
118 34496 : uint32_t offset = ndr->offset;
119 34496 : uint32_t max_offset = offset;
120 8 : unsigned num_components;
121 8 : char *name;
122 :
123 34496 : if (!(ndr_flags & NDR_SCALARS)) {
124 0 : return NDR_ERR_SUCCESS;
125 : }
126 :
127 34496 : name = talloc_strdup(ndr->current_mem_ctx, "");
128 :
129 : /* break up name into a list of components */
130 202352 : for (num_components=0; num_components<MAX_COMPONENTS;
131 167848 : num_components++) {
132 202344 : uint8_t *component = NULL;
133 202344 : NDR_CHECK(ndr_pull_component(ndr, &component, &offset,
134 : &max_offset));
135 202344 : if (component == NULL) break;
136 167848 : if (num_components > 0) {
137 133388 : name = talloc_asprintf_append_buffer(name, ".%s",
138 : component);
139 : } else {
140 34460 : name = talloc_asprintf_append_buffer(name, "%s",
141 : component);
142 : }
143 167848 : NDR_ERR_HAVE_NO_MEMORY(name);
144 : }
145 34496 : if (num_components == MAX_COMPONENTS) {
146 0 : return ndr_pull_error(ndr, NDR_ERR_STRING,
147 : "BAD DNS NAME too many components");
148 : }
149 :
150 34496 : (*s) = name;
151 34496 : ndr->offset = max_offset;
152 :
153 34496 : return NDR_ERR_SUCCESS;
154 : }
155 :
156 : /**
157 : push a dns string to the wire
158 : */
159 39398 : _PUBLIC_ enum ndr_err_code ndr_push_dns_string(struct ndr_push *ndr,
160 : ndr_flags_type ndr_flags,
161 : const char *s)
162 : {
163 39398 : return ndr_push_dns_string_list(ndr,
164 : &ndr->dns_string_list,
165 : ndr_flags,
166 : s,
167 : false);
168 : }
169 :
170 1872 : _PUBLIC_ enum ndr_err_code ndr_pull_dns_txt_record(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dns_txt_record *r)
171 : {
172 1872 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
173 1872 : if (ndr_flags & NDR_SCALARS) {
174 0 : enum ndr_err_code ndr_err;
175 1872 : uint32_t data_size = ndr->data_size;
176 1872 : uint32_t record_size = 0;
177 1872 : ndr_err = ndr_token_retrieve(&ndr->array_size_list, r,
178 : &record_size);
179 1872 : if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
180 1872 : NDR_PULL_NEED_BYTES(ndr, record_size);
181 1872 : ndr->data_size = ndr->offset + record_size;
182 : }
183 1872 : NDR_CHECK(ndr_pull_align(ndr, 1));
184 1872 : NDR_CHECK(ndr_pull_dnsp_string_list(ndr, NDR_SCALARS, &r->txt));
185 1872 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
186 1872 : ndr->data_size = data_size;
187 : }
188 1872 : if (ndr_flags & NDR_BUFFERS) {
189 0 : }
190 1872 : return NDR_ERR_SUCCESS;
191 : }
192 :
193 25972 : _PUBLIC_ enum ndr_err_code ndr_push_dns_res_rec(struct ndr_push *ndr,
194 : ndr_flags_type ndr_flags,
195 : const struct dns_res_rec *r)
196 : {
197 25972 : libndr_flags _flags_save_STRUCT = ndr->flags;
198 0 : uint32_t _saved_offset1, _saved_offset2;
199 0 : uint16_t length;
200 25972 : ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX |
201 : LIBNDR_FLAG_NOALIGN);
202 25972 : if (ndr_flags & NDR_SCALARS) {
203 13020 : libndr_flags _flags_save_name = ndr->flags;
204 :
205 13020 : NDR_CHECK(ndr_push_align(ndr, 4));
206 :
207 13020 : switch (r->rr_type) {
208 384 : case DNS_QTYPE_TKEY:
209 : case DNS_QTYPE_TSIG:
210 384 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NO_COMPRESSION);
211 384 : break;
212 12636 : default:
213 12636 : break;
214 : }
215 13020 : NDR_CHECK(ndr_push_dns_string(ndr, NDR_SCALARS, r->name));
216 13020 : ndr->flags = _flags_save_name;
217 :
218 13020 : NDR_CHECK(ndr_push_dns_qtype(ndr, NDR_SCALARS, r->rr_type));
219 13020 : NDR_CHECK(ndr_push_dns_qclass(ndr, NDR_SCALARS, r->rr_class));
220 13020 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ttl));
221 13020 : _saved_offset1 = ndr->offset;
222 13020 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
223 13020 : if (r->length > 0) {
224 0 : uint32_t _saved_offset3;
225 :
226 12820 : NDR_CHECK(ndr_push_set_switch_value(ndr, &r->rdata,
227 : r->rr_type));
228 12820 : _saved_offset3 = ndr->offset;
229 12820 : NDR_CHECK(ndr_push_dns_rdata(ndr, NDR_SCALARS,
230 : &r->rdata));
231 12820 : if ((ndr->offset != _saved_offset3) &&
232 12807 : (r->unexpected.length > 0)) {
233 : /*
234 : * ndr_push_dns_rdata pushed a known
235 : * record, but we have something
236 : * unexpected. That's invalid.
237 : */
238 0 : return ndr_push_error(ndr,
239 : NDR_ERR_LENGTH,
240 : "Invalid...Unexpected " \
241 : "blob length is too " \
242 : "large");
243 : }
244 : }
245 13020 : if (r->unexpected.length > UINT16_MAX) {
246 0 : return ndr_push_error(ndr, NDR_ERR_LENGTH,
247 : "Unexpected blob length "\
248 : "is too large");
249 : }
250 :
251 13020 : NDR_CHECK(ndr_push_bytes(ndr, r->unexpected.data,
252 : r->unexpected.length));
253 13020 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
254 13020 : length = ndr->offset - (_saved_offset1 + 2);
255 13020 : _saved_offset2 = ndr->offset;
256 13020 : ndr->offset = _saved_offset1;
257 13020 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, length));
258 13020 : ndr->offset = _saved_offset2;
259 : }
260 25972 : if (ndr_flags & NDR_BUFFERS) {
261 13020 : NDR_CHECK(ndr_push_dns_rdata(ndr, NDR_BUFFERS,
262 : &r->rdata));
263 : }
264 25972 : ndr->flags = _flags_save_STRUCT;
265 25972 : return NDR_ERR_SUCCESS;
266 : }
267 :
268 22432 : _PUBLIC_ enum ndr_err_code ndr_pull_dns_res_rec(struct ndr_pull *ndr,
269 : ndr_flags_type ndr_flags,
270 : struct dns_res_rec *r)
271 : {
272 22432 : libndr_flags _flags_save_STRUCT = ndr->flags;
273 4 : uint32_t _saved_offset1;
274 4 : uint32_t pad, length;
275 :
276 22432 : ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX |
277 : LIBNDR_FLAG_NOALIGN);
278 22432 : if (ndr_flags & NDR_SCALARS) {
279 11216 : NDR_CHECK(ndr_pull_align(ndr, 4));
280 11216 : NDR_CHECK(ndr_pull_dns_string(ndr, NDR_SCALARS, &r->name));
281 11216 : NDR_CHECK(ndr_pull_dns_qtype(ndr, NDR_SCALARS, &r->rr_type));
282 11216 : NDR_CHECK(ndr_pull_dns_qclass(ndr, NDR_SCALARS, &r->rr_class));
283 11216 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ttl));
284 11216 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
285 11216 : _saved_offset1 = ndr->offset;
286 11216 : if (r->length > 0) {
287 10937 : NDR_CHECK(ndr_token_store(ndr, &ndr->array_size_list,
288 : &r->rdata,
289 : r->length));
290 10937 : NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->rdata,
291 : r->rr_type));
292 10937 : NDR_CHECK(ndr_pull_dns_rdata(ndr, NDR_SCALARS,
293 : &r->rdata));
294 : } else {
295 279 : ZERO_STRUCT(r->rdata);
296 : }
297 11216 : length = ndr->offset - _saved_offset1;
298 11216 : if (length > r->length) {
299 0 : return ndr_pull_error(ndr, NDR_ERR_LENGTH, "TODO");
300 : }
301 :
302 11216 : r->unexpected = data_blob_null;
303 11216 : pad = r->length - length;
304 11216 : if (pad > 0) {
305 2 : NDR_PULL_NEED_BYTES(ndr, pad);
306 2 : r->unexpected = data_blob_talloc(ndr->current_mem_ctx,
307 : ndr->data +
308 : ndr->offset,
309 : pad);
310 2 : if (r->unexpected.data == NULL) {
311 0 : return ndr_pull_error(ndr,
312 : NDR_ERR_ALLOC,
313 : "Failed to allocate a " \
314 : "data blob");
315 : }
316 2 : ndr->offset += pad;
317 : }
318 :
319 :
320 11216 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
321 : }
322 22432 : if (ndr_flags & NDR_BUFFERS) {
323 11216 : NDR_CHECK(ndr_pull_dns_rdata(ndr, NDR_BUFFERS, &r->rdata));
324 : }
325 22432 : ndr->flags = _flags_save_STRUCT;
326 22432 : return NDR_ERR_SUCCESS;
327 : }
|
