1 /*
2 * wire2host.c
3 *
4 * conversion routines from the wire to the host
5 * format.
6 * This will usually just a re-ordering of the
7 * data (as we store it in network format)
8 *
9 * a Net::DNS like library for C
10 *
11 * (c) NLnet Labs, 2004-2006
12 *
13 * See the file LICENSE for the license
14 */
15
16
17 #include <ldns/config.h>
18
19 #include <ldns/ldns.h>
20 /*#include <ldns/wire2host.h>*/
21
22 #include <strings.h>
23 #include <limits.h>
24
25
26
27 /*
28 * Set of macro's to deal with the dns message header as specified
29 * in RFC1035 in portable way.
30 *
31 */
32
33 /*
34 *
35 * 1 1 1 1 1 1
36 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
37 * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
38 * | ID |
39 * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
40 * |QR| Opcode |AA|TC|RD|RA| Z|AD|CD| RCODE |
41 * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
42 * | QDCOUNT |
43 * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
44 * | ANCOUNT |
45 * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
46 * | NSCOUNT |
47 * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
48 * | ARCOUNT |
49 * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
50 *
51 */
52
53
54 /* allocates memory to *dname! */
55 ldns_status
ldns_wire2dname(ldns_rdf ** dname,const uint8_t * wire,size_t max,size_t * pos)56 ldns_wire2dname(ldns_rdf **dname, const uint8_t *wire, size_t max, size_t *pos)
57 {
58 uint8_t label_size;
59 uint16_t pointer_target;
60 uint8_t pointer_target_buf[2];
61 size_t dname_pos = 0;
62 size_t uncompressed_length = 0;
63 size_t compression_pos = 0;
64 uint8_t tmp_dname[LDNS_MAX_DOMAINLEN];
65 unsigned int pointer_count = 0;
66
67 if (pos == NULL) {
68 return LDNS_STATUS_WIRE_RDATA_ERR;
69 }
70 if (*pos >= max) {
71 return LDNS_STATUS_PACKET_OVERFLOW;
72 }
73 label_size = wire[*pos];
74 while (label_size > 0) {
75 /* compression */
76 while (label_size >= 192) {
77 if (compression_pos == 0) {
78 compression_pos = *pos + 2;
79 }
80
81 pointer_count++;
82
83 /* remove first two bits */
84 if (*pos + 2 > max) {
85 return LDNS_STATUS_PACKET_OVERFLOW;
86 }
87 pointer_target_buf[0] = wire[*pos] & 63;
88 pointer_target_buf[1] = wire[*pos + 1];
89 pointer_target = ldns_read_uint16(pointer_target_buf);
90
91 if (pointer_target == 0) {
92 return LDNS_STATUS_INVALID_POINTER;
93 } else if (pointer_target >= max) {
94 return LDNS_STATUS_INVALID_POINTER;
95 } else if (pointer_count > LDNS_MAX_POINTERS) {
96 return LDNS_STATUS_INVALID_POINTER;
97 }
98 *pos = pointer_target;
99 label_size = wire[*pos];
100 }
101 if(label_size == 0)
102 break; /* break from pointer to 0 byte */
103 if (label_size > LDNS_MAX_LABELLEN) {
104 return LDNS_STATUS_LABEL_OVERFLOW;
105 }
106 if (*pos + 1 + label_size > max) {
107 return LDNS_STATUS_LABEL_OVERFLOW;
108 }
109
110 /* check space for labelcount itself */
111 if (dname_pos + 1 > LDNS_MAX_DOMAINLEN) {
112 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
113 }
114 tmp_dname[dname_pos] = label_size;
115 if (label_size > 0) {
116 dname_pos++;
117 }
118 *pos = *pos + 1;
119 if (dname_pos + label_size > LDNS_MAX_DOMAINLEN) {
120 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
121 }
122 memcpy(&tmp_dname[dname_pos], &wire[*pos], label_size);
123 uncompressed_length += label_size + 1;
124 dname_pos += label_size;
125 *pos = *pos + label_size;
126
127 if (*pos < max) {
128 label_size = wire[*pos];
129 }
130 }
131
132 if (compression_pos > 0) {
133 *pos = compression_pos;
134 } else {
135 *pos = *pos + 1;
136 }
137
138 if (dname_pos >= LDNS_MAX_DOMAINLEN) {
139 return LDNS_STATUS_DOMAINNAME_OVERFLOW;
140 }
141
142 tmp_dname[dname_pos] = 0;
143 dname_pos++;
144
145 *dname = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_DNAME,
146 (uint16_t) dname_pos, tmp_dname);
147 if (!*dname) {
148 return LDNS_STATUS_MEM_ERR;
149 }
150 return LDNS_STATUS_OK;
151 }
152
153 /* maybe make this a goto error so data can be freed or something/ */
154 #define LDNS_STATUS_CHECK_RETURN(st) {if (st != LDNS_STATUS_OK) { return st; }}
155 #define LDNS_STATUS_CHECK_GOTO(st, label) {if (st != LDNS_STATUS_OK) { /*printf("STG %s:%d: status code %d\n", __FILE__, __LINE__, st);*/ goto label; }}
156
157 ldns_status
ldns_wire2rdf(ldns_rr * rr,const uint8_t * wire,size_t max,size_t * pos)158 ldns_wire2rdf(ldns_rr *rr, const uint8_t *wire, size_t max, size_t *pos)
159 {
160 size_t end;
161 size_t cur_rdf_length;
162 uint8_t rdf_index;
163 uint8_t *data;
164 uint16_t rd_length;
165 ldns_rdf *cur_rdf = NULL;
166 ldns_rdf_type cur_rdf_type;
167 const ldns_rr_descriptor *descriptor;
168 ldns_status status;
169
170 assert(rr != NULL);
171
172 descriptor = ldns_rr_descript(ldns_rr_get_type(rr));
173
174 if (*pos + 2 > max) {
175 return LDNS_STATUS_PACKET_OVERFLOW;
176 }
177
178 rd_length = ldns_read_uint16(&wire[*pos]);
179 *pos = *pos + 2;
180
181 if (*pos + rd_length > max) {
182 return LDNS_STATUS_PACKET_OVERFLOW;
183 }
184
185 end = *pos + (size_t) rd_length;
186
187 rdf_index = 0;
188 while (*pos < end &&
189 rdf_index < ldns_rr_descriptor_maximum(descriptor)) {
190
191 cur_rdf_length = 0;
192
193 cur_rdf_type = ldns_rr_descriptor_field_type(
194 descriptor, rdf_index);
195
196 /* handle special cases immediately, set length
197 for fixed length rdata and do them below */
198 switch (cur_rdf_type) {
199 case LDNS_RDF_TYPE_DNAME:
200 status = ldns_wire2dname(&cur_rdf, wire, max, pos);
201 LDNS_STATUS_CHECK_RETURN(status);
202 break;
203 case LDNS_RDF_TYPE_CLASS:
204 case LDNS_RDF_TYPE_ALG:
205 case LDNS_RDF_TYPE_CERTIFICATE_USAGE:
206 case LDNS_RDF_TYPE_SELECTOR:
207 case LDNS_RDF_TYPE_MATCHING_TYPE:
208 case LDNS_RDF_TYPE_INT8:
209 cur_rdf_length = LDNS_RDF_SIZE_BYTE;
210 break;
211 case LDNS_RDF_TYPE_TYPE:
212 case LDNS_RDF_TYPE_INT16:
213 case LDNS_RDF_TYPE_CERT_ALG:
214 cur_rdf_length = LDNS_RDF_SIZE_WORD;
215 break;
216 case LDNS_RDF_TYPE_TIME:
217 case LDNS_RDF_TYPE_INT32:
218 case LDNS_RDF_TYPE_A:
219 case LDNS_RDF_TYPE_PERIOD:
220 cur_rdf_length = LDNS_RDF_SIZE_DOUBLEWORD;
221 break;
222 case LDNS_RDF_TYPE_TSIGTIME:
223 case LDNS_RDF_TYPE_EUI48:
224 cur_rdf_length = LDNS_RDF_SIZE_6BYTES;
225 break;
226 case LDNS_RDF_TYPE_ILNP64:
227 case LDNS_RDF_TYPE_EUI64:
228 cur_rdf_length = LDNS_RDF_SIZE_8BYTES;
229 break;
230 case LDNS_RDF_TYPE_AAAA:
231 cur_rdf_length = LDNS_RDF_SIZE_16BYTES;
232 break;
233 case LDNS_RDF_TYPE_STR:
234 case LDNS_RDF_TYPE_NSEC3_SALT:
235 case LDNS_RDF_TYPE_TAG:
236 /* len is stored in first byte
237 * it should be in the rdf too, so just
238 * copy len+1 from this position
239 */
240 cur_rdf_length = ((size_t) wire[*pos]) + 1;
241 break;
242
243 case LDNS_RDF_TYPE_INT16_DATA:
244 if (*pos + 2 > end) {
245 return LDNS_STATUS_PACKET_OVERFLOW;
246 }
247 cur_rdf_length =
248 (size_t) ldns_read_uint16(&wire[*pos]) + 2;
249 break;
250 case LDNS_RDF_TYPE_HIP:
251 if (*pos + 4 > end) {
252 return LDNS_STATUS_PACKET_OVERFLOW;
253 }
254 cur_rdf_length =
255 (size_t) wire[*pos] +
256 (size_t) ldns_read_uint16(&wire[*pos + 2]) + 4;
257 break;
258 case LDNS_RDF_TYPE_B32_EXT:
259 case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
260 /* length is stored in first byte */
261 cur_rdf_length = ((size_t) wire[*pos]) + 1;
262 break;
263 case LDNS_RDF_TYPE_APL:
264 case LDNS_RDF_TYPE_B64:
265 case LDNS_RDF_TYPE_HEX:
266 case LDNS_RDF_TYPE_NSEC:
267 case LDNS_RDF_TYPE_UNKNOWN:
268 case LDNS_RDF_TYPE_SERVICE:
269 case LDNS_RDF_TYPE_LOC:
270 case LDNS_RDF_TYPE_WKS:
271 case LDNS_RDF_TYPE_NSAP:
272 case LDNS_RDF_TYPE_ATMA:
273 case LDNS_RDF_TYPE_IPSECKEY:
274 case LDNS_RDF_TYPE_LONG_STR:
275 case LDNS_RDF_TYPE_AMTRELAY:
276 case LDNS_RDF_TYPE_SVCPARAMS:
277 case LDNS_RDF_TYPE_NONE:
278 /*
279 * Read to end of rr rdata
280 */
281 cur_rdf_length = end - *pos;
282 break;
283 }
284
285 /* fixed length rdata */
286 if (cur_rdf_length > 0) {
287 if (cur_rdf_length + *pos > end) {
288 return LDNS_STATUS_PACKET_OVERFLOW;
289 }
290 data = LDNS_XMALLOC(uint8_t, rd_length);
291 if (!data) {
292 return LDNS_STATUS_MEM_ERR;
293 }
294 memcpy(data, &wire[*pos], cur_rdf_length);
295
296 cur_rdf = ldns_rdf_new(cur_rdf_type,
297 cur_rdf_length, data);
298 *pos = *pos + cur_rdf_length;
299 }
300
301 if (cur_rdf) {
302 ldns_rr_push_rdf(rr, cur_rdf);
303 cur_rdf = NULL;
304 }
305
306 rdf_index++;
307
308 } /* while (rdf_index < ldns_rr_descriptor_maximum(descriptor)) */
309
310
311 return LDNS_STATUS_OK;
312 }
313
314
315 /* TODO:
316 can *pos be incremented at READ_INT? or maybe use something like
317 RR_CLASS(wire)?
318 uhhm Jelte??
319 */
320 ldns_status
ldns_wire2rr(ldns_rr ** rr_p,const uint8_t * wire,size_t max,size_t * pos,ldns_pkt_section section)321 ldns_wire2rr(ldns_rr **rr_p, const uint8_t *wire, size_t max,
322 size_t *pos, ldns_pkt_section section)
323 {
324 ldns_rdf *owner = NULL;
325 ldns_rr *rr = ldns_rr_new();
326 ldns_status status;
327
328 status = ldns_wire2dname(&owner, wire, max, pos);
329 LDNS_STATUS_CHECK_GOTO(status, status_error);
330
331 ldns_rr_set_owner(rr, owner);
332
333 if (*pos + 4 > max) {
334 status = LDNS_STATUS_PACKET_OVERFLOW;
335 goto status_error;
336 }
337
338 ldns_rr_set_type(rr, ldns_read_uint16(&wire[*pos]));
339 *pos = *pos + 2;
340
341 ldns_rr_set_class(rr, ldns_read_uint16(&wire[*pos]));
342 *pos = *pos + 2;
343
344 if (section != LDNS_SECTION_QUESTION) {
345 if (*pos + 4 > max) {
346 status = LDNS_STATUS_PACKET_OVERFLOW;
347 goto status_error;
348 }
349 ldns_rr_set_ttl(rr, ldns_read_uint32(&wire[*pos]));
350
351 *pos = *pos + 4;
352 status = ldns_wire2rdf(rr, wire, max, pos);
353
354 LDNS_STATUS_CHECK_GOTO(status, status_error);
355 ldns_rr_set_question(rr, false);
356 } else {
357 ldns_rr_set_question(rr, true);
358 }
359
360 *rr_p = rr;
361 return LDNS_STATUS_OK;
362
363 status_error:
364 ldns_rr_free(rr);
365 return status;
366 }
367
368 static ldns_status
ldns_wire2pkt_hdr(ldns_pkt * packet,const uint8_t * wire,size_t max,size_t * pos)369 ldns_wire2pkt_hdr(ldns_pkt *packet, const uint8_t *wire, size_t max, size_t *pos)
370 {
371 if (*pos + LDNS_HEADER_SIZE > max) {
372 return LDNS_STATUS_WIRE_INCOMPLETE_HEADER;
373 } else {
374 ldns_pkt_set_id(packet, LDNS_ID_WIRE(wire));
375 ldns_pkt_set_qr(packet, LDNS_QR_WIRE(wire));
376 ldns_pkt_set_opcode(packet, LDNS_OPCODE_WIRE(wire));
377 ldns_pkt_set_aa(packet, LDNS_AA_WIRE(wire));
378 ldns_pkt_set_tc(packet, LDNS_TC_WIRE(wire));
379 ldns_pkt_set_rd(packet, LDNS_RD_WIRE(wire));
380 ldns_pkt_set_ra(packet, LDNS_RA_WIRE(wire));
381 ldns_pkt_set_ad(packet, LDNS_AD_WIRE(wire));
382 ldns_pkt_set_cd(packet, LDNS_CD_WIRE(wire));
383 ldns_pkt_set_rcode(packet, LDNS_RCODE_WIRE(wire));
384
385 ldns_pkt_set_qdcount(packet, LDNS_QDCOUNT(wire));
386 ldns_pkt_set_ancount(packet, LDNS_ANCOUNT(wire));
387 ldns_pkt_set_nscount(packet, LDNS_NSCOUNT(wire));
388 ldns_pkt_set_arcount(packet, LDNS_ARCOUNT(wire));
389
390 *pos += LDNS_HEADER_SIZE;
391
392 return LDNS_STATUS_OK;
393 }
394 }
395
396 ldns_status
ldns_buffer2pkt_wire(ldns_pkt ** packet,const ldns_buffer * buffer)397 ldns_buffer2pkt_wire(ldns_pkt **packet, const ldns_buffer *buffer)
398 {
399 /* lazy */
400 return ldns_wire2pkt(packet, ldns_buffer_begin(buffer),
401 ldns_buffer_limit(buffer));
402
403 }
404
405 ldns_status
ldns_wire2pkt(ldns_pkt ** packet_p,const uint8_t * wire,size_t max)406 ldns_wire2pkt(ldns_pkt **packet_p, const uint8_t *wire, size_t max)
407 {
408 size_t pos = 0;
409 uint16_t i;
410 ldns_rr *rr;
411 ldns_pkt *packet = ldns_pkt_new();
412 ldns_status status = LDNS_STATUS_OK;
413 uint8_t have_edns = 0;
414
415 uint8_t data[4];
416
417 if (!packet) {
418 return LDNS_STATUS_MEM_ERR;
419 }
420
421 status = ldns_wire2pkt_hdr(packet, wire, max, &pos);
422 LDNS_STATUS_CHECK_GOTO(status, status_error);
423
424 for (i = 0; i < ldns_pkt_qdcount(packet); i++) {
425
426 status = ldns_wire2rr(&rr, wire, max, &pos, LDNS_SECTION_QUESTION);
427 if (status == LDNS_STATUS_PACKET_OVERFLOW) {
428 status = LDNS_STATUS_WIRE_INCOMPLETE_QUESTION;
429 }
430 LDNS_STATUS_CHECK_GOTO(status, status_error);
431 if (!ldns_rr_list_push_rr(ldns_pkt_question(packet), rr)) {
432 ldns_pkt_free(packet);
433 return LDNS_STATUS_INTERNAL_ERR;
434 }
435 }
436 for (i = 0; i < ldns_pkt_ancount(packet); i++) {
437 status = ldns_wire2rr(&rr, wire, max, &pos, LDNS_SECTION_ANSWER);
438 if (status == LDNS_STATUS_PACKET_OVERFLOW) {
439 status = LDNS_STATUS_WIRE_INCOMPLETE_ANSWER;
440 }
441 LDNS_STATUS_CHECK_GOTO(status, status_error);
442 if (!ldns_rr_list_push_rr(ldns_pkt_answer(packet), rr)) {
443 ldns_pkt_free(packet);
444 return LDNS_STATUS_INTERNAL_ERR;
445 }
446 }
447 for (i = 0; i < ldns_pkt_nscount(packet); i++) {
448 status = ldns_wire2rr(&rr, wire, max, &pos, LDNS_SECTION_AUTHORITY);
449 if (status == LDNS_STATUS_PACKET_OVERFLOW) {
450 status = LDNS_STATUS_WIRE_INCOMPLETE_AUTHORITY;
451 }
452 LDNS_STATUS_CHECK_GOTO(status, status_error);
453 if (!ldns_rr_list_push_rr(ldns_pkt_authority(packet), rr)) {
454 ldns_pkt_free(packet);
455 return LDNS_STATUS_INTERNAL_ERR;
456 }
457 }
458 for (i = 0; i < ldns_pkt_arcount(packet); i++) {
459 status = ldns_wire2rr(&rr, wire, max, &pos, LDNS_SECTION_ADDITIONAL);
460 if (status == LDNS_STATUS_PACKET_OVERFLOW) {
461 status = LDNS_STATUS_WIRE_INCOMPLETE_ADDITIONAL;
462 }
463 LDNS_STATUS_CHECK_GOTO(status, status_error);
464
465 if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_OPT) {
466 ldns_pkt_set_edns_udp_size(packet, ldns_rr_get_class(rr));
467 ldns_write_uint32(data, ldns_rr_ttl(rr));
468 ldns_pkt_set_edns_extended_rcode(packet, data[0]);
469 ldns_pkt_set_edns_version(packet, data[1]);
470 ldns_pkt_set_edns_z(packet, ldns_read_uint16(&data[2]));
471 /* edns might not have rdfs */
472 if (ldns_rr_rdf(rr, 0)) {
473 ldns_rdf_deep_free(ldns_pkt_edns_data(packet));
474 ldns_pkt_set_edns_data(packet, ldns_rdf_clone(ldns_rr_rdf(rr, 0)));
475 }
476 ldns_rr_free(rr);
477 have_edns += 1;
478 } else if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_TSIG) {
479 ldns_pkt_set_tsig(packet, rr);
480 ldns_pkt_set_arcount(packet, ldns_pkt_arcount(packet) - 1);
481 } else if (!ldns_rr_list_push_rr(ldns_pkt_additional(packet), rr)) {
482 ldns_pkt_free(packet);
483 return LDNS_STATUS_INTERNAL_ERR;
484 }
485 }
486 ldns_pkt_set_size(packet, max);
487 if(have_edns)
488 ldns_pkt_set_arcount(packet, ldns_pkt_arcount(packet)
489 - have_edns);
490 packet->_edns_present = have_edns;
491
492 *packet_p = packet;
493 return status;
494
495 status_error:
496 ldns_pkt_free(packet);
497 return status;
498 }
499