4 * conversion routines from the host to the wire format.
5 * This will usually just a re-ordering of the
6 * data (as we store it in network format)
8 * a Net::DNS like library for C
10 * (c) NLnet Labs, 2004-2006
12 * See the file LICENSE for the license
15 #include <ldns/config.h>
17 #include <ldns/ldns.h>
20 add a pointer to a 'possiblecompression' structure
21 to all the needed functions?
22 something like an array of name, pointer values?
23 every dname part could be added to it
27 ldns_dname2buffer_wire(ldns_buffer *buffer, const ldns_rdf *name)
29 if (ldns_buffer_reserve(buffer, ldns_rdf_size(name))) {
30 ldns_buffer_write(buffer, ldns_rdf_data(name), ldns_rdf_size(name));
32 return ldns_buffer_status(buffer);
36 ldns_rdf2buffer_wire(ldns_buffer *buffer, const ldns_rdf *rdf)
38 if (ldns_buffer_reserve(buffer, ldns_rdf_size(rdf))) {
39 ldns_buffer_write(buffer, ldns_rdf_data(rdf), ldns_rdf_size(rdf));
41 return ldns_buffer_status(buffer);
45 ldns_rdf2buffer_wire_canonical(ldns_buffer *buffer, const ldns_rdf *rdf)
50 if (ldns_rdf_get_type(rdf) == LDNS_RDF_TYPE_DNAME) {
51 if (ldns_buffer_reserve(buffer, ldns_rdf_size(rdf))) {
52 rdf_data = ldns_rdf_data(rdf);
53 for (i = 0; i < ldns_rdf_size(rdf); i++) {
54 ldns_buffer_write_u8(buffer,
55 (uint8_t) LDNS_DNAME_NORMALIZE((int)rdf_data[i]));
59 /* direct copy for all other types */
60 if (ldns_buffer_reserve(buffer, ldns_rdf_size(rdf))) {
61 ldns_buffer_write(buffer,
66 return ldns_buffer_status(buffer);
69 /* convert a rr list to wireformat */
71 ldns_rr_list2buffer_wire(ldns_buffer *buffer,const ldns_rr_list *rr_list)
76 rr_count = ldns_rr_list_rr_count(rr_list);
77 for(i = 0; i < rr_count; i++) {
78 (void)ldns_rr2buffer_wire(buffer, ldns_rr_list_rr(rr_list, i),
81 return ldns_buffer_status(buffer);
85 ldns_rr2buffer_wire_canonical(ldns_buffer *buffer,
91 bool pre_rfc3597 = false;
92 switch (ldns_rr_get_type(rr)) {
96 case LDNS_RR_TYPE_CNAME:
97 case LDNS_RR_TYPE_SOA:
100 case LDNS_RR_TYPE_MR:
101 case LDNS_RR_TYPE_PTR:
102 case LDNS_RR_TYPE_HINFO:
103 case LDNS_RR_TYPE_MINFO:
104 case LDNS_RR_TYPE_MX:
105 case LDNS_RR_TYPE_RP:
106 case LDNS_RR_TYPE_AFSDB:
107 case LDNS_RR_TYPE_RT:
108 case LDNS_RR_TYPE_SIG:
109 case LDNS_RR_TYPE_PX:
110 case LDNS_RR_TYPE_NXT:
111 case LDNS_RR_TYPE_NAPTR:
112 case LDNS_RR_TYPE_KX:
113 case LDNS_RR_TYPE_SRV:
114 case LDNS_RR_TYPE_DNAME:
115 case LDNS_RR_TYPE_A6:
122 if (ldns_rr_owner(rr)) {
123 (void) ldns_rdf2buffer_wire_canonical(buffer, ldns_rr_owner(rr));
126 if (ldns_buffer_reserve(buffer, 4)) {
127 (void) ldns_buffer_write_u16(buffer, ldns_rr_get_type(rr));
128 (void) ldns_buffer_write_u16(buffer, ldns_rr_get_class(rr));
131 if (section != LDNS_SECTION_QUESTION) {
132 if (ldns_buffer_reserve(buffer, 6)) {
133 ldns_buffer_write_u32(buffer, ldns_rr_ttl(rr));
134 /* remember pos for later */
135 rdl_pos = ldns_buffer_position(buffer);
136 ldns_buffer_write_u16(buffer, 0);
139 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
141 (void) ldns_rdf2buffer_wire_canonical(buffer,
144 (void) ldns_rdf2buffer_wire(buffer, ldns_rr_rdf(rr, i));
149 ldns_buffer_write_u16_at(buffer, rdl_pos,
150 ldns_buffer_position(buffer)
154 return ldns_buffer_status(buffer);
158 ldns_rr2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr, int section)
161 uint16_t rdl_pos = 0;
163 if (ldns_rr_owner(rr)) {
164 (void) ldns_dname2buffer_wire(buffer, ldns_rr_owner(rr));
167 if (ldns_buffer_reserve(buffer, 4)) {
168 (void) ldns_buffer_write_u16(buffer, ldns_rr_get_type(rr));
169 (void) ldns_buffer_write_u16(buffer, ldns_rr_get_class(rr));
172 if (section != LDNS_SECTION_QUESTION) {
173 if (ldns_buffer_reserve(buffer, 6)) {
174 ldns_buffer_write_u32(buffer, ldns_rr_ttl(rr));
175 /* remember pos for later */
176 rdl_pos = ldns_buffer_position(buffer);
177 ldns_buffer_write_u16(buffer, 0);
180 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
181 (void) ldns_rdf2buffer_wire(buffer, ldns_rr_rdf(rr, i));
185 ldns_buffer_write_u16_at(buffer, rdl_pos,
186 ldns_buffer_position(buffer)
190 return ldns_buffer_status(buffer);
194 ldns_rrsig2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr)
198 /* it must be a sig RR */
199 if (ldns_rr_get_type(rr) != LDNS_RR_TYPE_RRSIG) {
200 return LDNS_STATUS_ERR;
203 /* Convert all the rdfs, except the actual signature data
204 * rdf number 8 - the last, hence: -1 */
205 for (i = 0; i < ldns_rr_rd_count(rr) - 1; i++) {
206 if (ldns_rr_rdf(rr, i)) {
207 (void) ldns_rdf2buffer_wire(buffer, ldns_rr_rdf(rr, i));
211 return ldns_buffer_status(buffer);
215 ldns_rr_rdata2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr)
218 /* convert all the rdf's */
219 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
220 (void) ldns_rdf2buffer_wire(buffer, ldns_rr_rdf(rr, i));
223 return ldns_buffer_status(buffer);
227 * Copies the packet header data to the buffer in wire format
230 ldns_hdr2buffer_wire(ldns_buffer *buffer, const ldns_pkt *packet)
235 if (ldns_buffer_reserve(buffer, 12)) {
236 ldns_buffer_write_u16(buffer, ldns_pkt_id(packet));
238 flags = ldns_pkt_qr(packet) << 7
239 | ldns_pkt_get_opcode(packet) << 3
240 | ldns_pkt_aa(packet) << 2
241 | ldns_pkt_tc(packet) << 1 | ldns_pkt_rd(packet);
242 ldns_buffer_write_u8(buffer, flags);
244 flags = ldns_pkt_ra(packet) << 7
245 /*| ldns_pkt_z(packet) << 6*/
246 | ldns_pkt_ad(packet) << 5
247 | ldns_pkt_cd(packet) << 4 | ldns_pkt_get_rcode(packet);
248 ldns_buffer_write_u8(buffer, flags);
250 ldns_buffer_write_u16(buffer, ldns_pkt_qdcount(packet));
251 ldns_buffer_write_u16(buffer, ldns_pkt_ancount(packet));
252 ldns_buffer_write_u16(buffer, ldns_pkt_nscount(packet));
253 /* add EDNS0 and TSIG to additional if they are there */
254 arcount = ldns_pkt_arcount(packet);
255 if (ldns_pkt_tsig(packet)) {
258 if (ldns_pkt_edns(packet)) {
261 ldns_buffer_write_u16(buffer, arcount);
264 return ldns_buffer_status(buffer);
268 ldns_pkt2buffer_wire(ldns_buffer *buffer, const ldns_pkt *packet)
270 ldns_rr_list *rr_list;
277 (void) ldns_hdr2buffer_wire(buffer, packet);
279 rr_list = ldns_pkt_question(packet);
281 for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
282 (void) ldns_rr2buffer_wire(buffer,
283 ldns_rr_list_rr(rr_list, i), LDNS_SECTION_QUESTION);
286 rr_list = ldns_pkt_answer(packet);
288 for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
289 (void) ldns_rr2buffer_wire(buffer,
290 ldns_rr_list_rr(rr_list, i), LDNS_SECTION_ANSWER);
293 rr_list = ldns_pkt_authority(packet);
295 for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
296 (void) ldns_rr2buffer_wire(buffer,
297 ldns_rr_list_rr(rr_list, i), LDNS_SECTION_AUTHORITY);
300 rr_list = ldns_pkt_additional(packet);
302 for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
303 (void) ldns_rr2buffer_wire(buffer,
304 ldns_rr_list_rr(rr_list, i), LDNS_SECTION_ADDITIONAL);
308 /* add EDNS to additional if it is needed */
309 if (ldns_pkt_edns(packet)) {
310 edns_rr = ldns_rr_new();
311 if(!edns_rr) return LDNS_STATUS_MEM_ERR;
312 ldns_rr_set_owner(edns_rr,
313 ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, "."));
314 ldns_rr_set_type(edns_rr, LDNS_RR_TYPE_OPT);
315 ldns_rr_set_class(edns_rr, ldns_pkt_edns_udp_size(packet));
316 edata[0] = ldns_pkt_edns_extended_rcode(packet);
317 edata[1] = ldns_pkt_edns_version(packet);
318 ldns_write_uint16(&edata[2], ldns_pkt_edns_z(packet));
319 ldns_rr_set_ttl(edns_rr, ldns_read_uint32(edata));
320 /* don't forget to add the edns rdata (if any) */
321 if (packet->_edns_data)
322 ldns_rr_push_rdf (edns_rr, packet->_edns_data);
323 (void)ldns_rr2buffer_wire(buffer, edns_rr, LDNS_SECTION_ADDITIONAL);
324 /* take the edns rdata back out of the rr before we free rr */
325 if (packet->_edns_data)
326 (void)ldns_rr_pop_rdf (edns_rr);
327 ldns_rr_free(edns_rr);
330 /* add TSIG to additional if it is there */
331 if (ldns_pkt_tsig(packet)) {
332 (void) ldns_rr2buffer_wire(buffer,
333 ldns_pkt_tsig(packet), LDNS_SECTION_ADDITIONAL);
336 return LDNS_STATUS_OK;
340 ldns_rdf2wire(uint8_t **dest, const ldns_rdf *rdf, size_t *result_size)
342 ldns_buffer *buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
343 uint8_t *result = NULL;
347 if(!buffer) return LDNS_STATUS_MEM_ERR;
349 status = ldns_rdf2buffer_wire(buffer, rdf);
350 if (status == LDNS_STATUS_OK) {
351 *result_size = ldns_buffer_position(buffer);
352 result = (uint8_t *) ldns_buffer_export(buffer);
354 ldns_buffer_free(buffer);
359 *dest = LDNS_XMALLOC(uint8_t, ldns_buffer_position(buffer));
361 ldns_buffer_free(buffer);
362 return LDNS_STATUS_MEM_ERR;
364 memcpy(*dest, result, ldns_buffer_position(buffer));
367 ldns_buffer_free(buffer);
372 ldns_rr2wire(uint8_t **dest, const ldns_rr *rr, int section, size_t *result_size)
374 ldns_buffer *buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
375 uint8_t *result = NULL;
379 if(!buffer) return LDNS_STATUS_MEM_ERR;
381 status = ldns_rr2buffer_wire(buffer, rr, section);
382 if (status == LDNS_STATUS_OK) {
383 *result_size = ldns_buffer_position(buffer);
384 result = (uint8_t *) ldns_buffer_export(buffer);
386 ldns_buffer_free(buffer);
391 *dest = LDNS_XMALLOC(uint8_t, ldns_buffer_position(buffer));
393 ldns_buffer_free(buffer);
394 return LDNS_STATUS_MEM_ERR;
396 memcpy(*dest, result, ldns_buffer_position(buffer));
399 ldns_buffer_free(buffer);
404 ldns_pkt2wire(uint8_t **dest, const ldns_pkt *packet, size_t *result_size)
406 ldns_buffer *buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
407 uint8_t *result = NULL;
411 if(!buffer) return LDNS_STATUS_MEM_ERR;
413 status = ldns_pkt2buffer_wire(buffer, packet);
414 if (status == LDNS_STATUS_OK) {
415 *result_size = ldns_buffer_position(buffer);
416 result = (uint8_t *) ldns_buffer_export(buffer);
418 ldns_buffer_free(buffer);
423 *dest = LDNS_XMALLOC(uint8_t, ldns_buffer_position(buffer));
425 ldns_buffer_free(buffer);
426 return LDNS_STATUS_MEM_ERR;
428 memcpy(*dest, result, ldns_buffer_position(buffer));
431 ldns_buffer_free(buffer);