ldns  1.7.0
wire2host.c
Go to the documentation of this file.
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! */
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) {
69  }
70  if (*pos >= max) {
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) {
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) {
93  } else if (pointer_target >= max) {
95  } else if (pointer_count > LDNS_MAX_POINTERS) {
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) {
105  }
106  if (*pos + 1 + label_size > max) {
108  }
109 
110  /* check space for labelcount itself */
111  if (dname_pos + 1 > LDNS_MAX_DOMAINLEN) {
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) {
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) {
140  }
141 
142  tmp_dname[dname_pos] = 0;
143  dname_pos++;
144 
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 
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) {
176  }
177 
178  rd_length = ldns_read_uint16(&wire[*pos]);
179  *pos = *pos + 2;
180 
181  if (*pos + rd_length > max) {
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:
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:
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:
220  cur_rdf_length = LDNS_RDF_SIZE_DOUBLEWORD;
221  break;
223  case LDNS_RDF_TYPE_EUI48:
224  cur_rdf_length = LDNS_RDF_SIZE_6BYTES;
225  break;
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:
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 
244  if (*pos + 2 > end) {
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) {
253  }
254  cur_rdf_length =
255  (size_t) wire[*pos] +
256  (size_t) ldns_read_uint16(&wire[*pos + 2]) + 4;
257  break;
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:
269  case LDNS_RDF_TYPE_LOC:
270  case LDNS_RDF_TYPE_WKS:
271  case LDNS_RDF_TYPE_NSAP:
272  case LDNS_RDF_TYPE_ATMA:
275  case LDNS_RDF_TYPE_NONE:
276  /*
277  * Read to end of rr rdata
278  */
279  cur_rdf_length = end - *pos;
280  break;
281  }
282 
283  /* fixed length rdata */
284  if (cur_rdf_length > 0) {
285  if (cur_rdf_length + *pos > end) {
287  }
288  data = LDNS_XMALLOC(uint8_t, rd_length);
289  if (!data) {
290  return LDNS_STATUS_MEM_ERR;
291  }
292  memcpy(data, &wire[*pos], cur_rdf_length);
293 
294  cur_rdf = ldns_rdf_new(cur_rdf_type,
295  cur_rdf_length, data);
296  *pos = *pos + cur_rdf_length;
297  }
298 
299  if (cur_rdf) {
300  ldns_rr_push_rdf(rr, cur_rdf);
301  cur_rdf = NULL;
302  }
303 
304  rdf_index++;
305 
306  } /* while (rdf_index < ldns_rr_descriptor_maximum(descriptor)) */
307 
308 
309  return LDNS_STATUS_OK;
310 }
311 
312 
313 /* TODO:
314  can *pos be incremented at READ_INT? or maybe use something like
315  RR_CLASS(wire)?
316  uhhm Jelte??
317 */
319 ldns_wire2rr(ldns_rr **rr_p, const uint8_t *wire, size_t max,
320  size_t *pos, ldns_pkt_section section)
321 {
322  ldns_rdf *owner = NULL;
323  ldns_rr *rr = ldns_rr_new();
324  ldns_status status;
325 
326  status = ldns_wire2dname(&owner, wire, max, pos);
327  LDNS_STATUS_CHECK_GOTO(status, status_error);
328 
329  ldns_rr_set_owner(rr, owner);
330 
331  if (*pos + 4 > max) {
333  goto status_error;
334  }
335 
336  ldns_rr_set_type(rr, ldns_read_uint16(&wire[*pos]));
337  *pos = *pos + 2;
338 
339  ldns_rr_set_class(rr, ldns_read_uint16(&wire[*pos]));
340  *pos = *pos + 2;
341 
342  if (section != LDNS_SECTION_QUESTION) {
343  if (*pos + 4 > max) {
345  goto status_error;
346  }
347  ldns_rr_set_ttl(rr, ldns_read_uint32(&wire[*pos]));
348 
349  *pos = *pos + 4;
350  status = ldns_wire2rdf(rr, wire, max, pos);
351 
352  LDNS_STATUS_CHECK_GOTO(status, status_error);
353  ldns_rr_set_question(rr, false);
354  } else {
355  ldns_rr_set_question(rr, true);
356  }
357 
358  *rr_p = rr;
359  return LDNS_STATUS_OK;
360 
361 status_error:
362  ldns_rr_free(rr);
363  return status;
364 }
365 
366 static ldns_status
367 ldns_wire2pkt_hdr(ldns_pkt *packet, const uint8_t *wire, size_t max, size_t *pos)
368 {
369  if (*pos + LDNS_HEADER_SIZE > max) {
371  } else {
372  ldns_pkt_set_id(packet, LDNS_ID_WIRE(wire));
373  ldns_pkt_set_qr(packet, LDNS_QR_WIRE(wire));
374  ldns_pkt_set_opcode(packet, LDNS_OPCODE_WIRE(wire));
375  ldns_pkt_set_aa(packet, LDNS_AA_WIRE(wire));
376  ldns_pkt_set_tc(packet, LDNS_TC_WIRE(wire));
377  ldns_pkt_set_rd(packet, LDNS_RD_WIRE(wire));
378  ldns_pkt_set_ra(packet, LDNS_RA_WIRE(wire));
379  ldns_pkt_set_ad(packet, LDNS_AD_WIRE(wire));
380  ldns_pkt_set_cd(packet, LDNS_CD_WIRE(wire));
381  ldns_pkt_set_rcode(packet, LDNS_RCODE_WIRE(wire));
382 
383  ldns_pkt_set_qdcount(packet, LDNS_QDCOUNT(wire));
384  ldns_pkt_set_ancount(packet, LDNS_ANCOUNT(wire));
385  ldns_pkt_set_nscount(packet, LDNS_NSCOUNT(wire));
386  ldns_pkt_set_arcount(packet, LDNS_ARCOUNT(wire));
387 
388  *pos += LDNS_HEADER_SIZE;
389 
390  return LDNS_STATUS_OK;
391  }
392 }
393 
395 ldns_buffer2pkt_wire(ldns_pkt **packet, const ldns_buffer *buffer)
396 {
397  /* lazy */
398  return ldns_wire2pkt(packet, ldns_buffer_begin(buffer),
399  ldns_buffer_limit(buffer));
400 
401 }
402 
404 ldns_wire2pkt(ldns_pkt **packet_p, const uint8_t *wire, size_t max)
405 {
406  size_t pos = 0;
407  uint16_t i;
408  ldns_rr *rr;
409  ldns_pkt *packet = ldns_pkt_new();
410  ldns_status status = LDNS_STATUS_OK;
411  uint8_t have_edns = 0;
412 
413  uint8_t data[4];
414 
415  status = ldns_wire2pkt_hdr(packet, wire, max, &pos);
416  LDNS_STATUS_CHECK_GOTO(status, status_error);
417 
418  for (i = 0; i < ldns_pkt_qdcount(packet); i++) {
419 
420  status = ldns_wire2rr(&rr, wire, max, &pos, LDNS_SECTION_QUESTION);
421  if (status == LDNS_STATUS_PACKET_OVERFLOW) {
423  }
424  LDNS_STATUS_CHECK_GOTO(status, status_error);
425  if (!ldns_rr_list_push_rr(ldns_pkt_question(packet), rr)) {
426  ldns_pkt_free(packet);
428  }
429  }
430  for (i = 0; i < ldns_pkt_ancount(packet); i++) {
431  status = ldns_wire2rr(&rr, wire, max, &pos, LDNS_SECTION_ANSWER);
432  if (status == LDNS_STATUS_PACKET_OVERFLOW) {
434  }
435  LDNS_STATUS_CHECK_GOTO(status, status_error);
436  if (!ldns_rr_list_push_rr(ldns_pkt_answer(packet), rr)) {
437  ldns_pkt_free(packet);
439  }
440  }
441  for (i = 0; i < ldns_pkt_nscount(packet); i++) {
442  status = ldns_wire2rr(&rr, wire, max, &pos, LDNS_SECTION_AUTHORITY);
443  if (status == LDNS_STATUS_PACKET_OVERFLOW) {
445  }
446  LDNS_STATUS_CHECK_GOTO(status, status_error);
447  if (!ldns_rr_list_push_rr(ldns_pkt_authority(packet), rr)) {
448  ldns_pkt_free(packet);
450  }
451  }
452  for (i = 0; i < ldns_pkt_arcount(packet); i++) {
453  status = ldns_wire2rr(&rr, wire, max, &pos, LDNS_SECTION_ADDITIONAL);
454  if (status == LDNS_STATUS_PACKET_OVERFLOW) {
456  }
457  LDNS_STATUS_CHECK_GOTO(status, status_error);
458 
459  if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_OPT) {
461  ldns_write_uint32(data, ldns_rr_ttl(rr));
462  ldns_pkt_set_edns_extended_rcode(packet, data[0]);
463  ldns_pkt_set_edns_version(packet, data[1]);
464  ldns_pkt_set_edns_z(packet, ldns_read_uint16(&data[2]));
465  /* edns might not have rdfs */
466  if (ldns_rr_rdf(rr, 0)) {
468  }
469  ldns_rr_free(rr);
470  have_edns += 1;
471  } else if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_TSIG) {
472  ldns_pkt_set_tsig(packet, rr);
473  ldns_pkt_set_arcount(packet, ldns_pkt_arcount(packet) - 1);
474  } else if (!ldns_rr_list_push_rr(ldns_pkt_additional(packet), rr)) {
475  ldns_pkt_free(packet);
477  }
478  }
479  ldns_pkt_set_size(packet, max);
480  if(have_edns)
481  ldns_pkt_set_arcount(packet, ldns_pkt_arcount(packet)
482  - have_edns);
483  packet->_edns_present = have_edns;
484 
485  *packet_p = packet;
486  return status;
487 
488 status_error:
489  ldns_pkt_free(packet);
490  return status;
491 }
void ldns_pkt_set_ancount(ldns_pkt *packet, uint16_t ancount)
Set the packet&#39;s an count.
Definition: packet.c:554
ldns_rdf * ldns_rr_rdf(const ldns_rr *rr, size_t nr)
returns the rdata field member counter.
Definition: rr.c:895
implementation of buffers to ease operations
Definition: buffer.h:50
#define LDNS_AD_WIRE(wirebuf)
Definition: wire2host.h:80
time (32 bits)
Definition: rdata.h:84
ldns_pkt * ldns_pkt_new(void)
allocates and initializes a ldns_pkt structure.
Definition: packet.c:739
uint16_t ldns_pkt_arcount(const ldns_pkt *packet)
Return the packet&#39;s ar count.
Definition: packet.c:117
void ldns_rr_set_type(ldns_rr *rr, ldns_rr_type rr_type)
sets the type in the rr.
Definition: rr.c:814
void ldns_pkt_set_ad(ldns_pkt *packet, bool ad)
Definition: packet.c:530
b64 string
Definition: rdata.h:68
void ldns_pkt_set_tc(ldns_pkt *packet, bool tc)
Definition: packet.c:482
ldns_rr_list * ldns_pkt_question(const ldns_pkt *packet)
Return the packet&#39;s question section.
Definition: packet.c:123
#define LDNS_RD_WIRE(wirebuf)
Definition: wire2host.h:37
Pseudo OPT record...
Definition: rr.h:163
bool ldns_rr_list_push_rr(ldns_rr_list *rr_list, const ldns_rr *rr)
pushes an rr to an rrlist.
Definition: rr.c:1118
void ldns_pkt_set_qdcount(ldns_pkt *packet, uint16_t qdcount)
Set the packet&#39;s qd count.
Definition: packet.c:548
unknown types
Definition: rdata.h:82
uint16_t ldns_pkt_qdcount(const ldns_pkt *packet)
Return the packet&#39;s qd count.
Definition: packet.c:99
ldns_rdf_type ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor, size_t index)
returns the rdf type for the given rdata field number of the rr type for the given descriptor...
Definition: rr.c:2613
a RR type
Definition: rdata.h:74
#define LDNS_XMALLOC(type, count)
Definition: util.h:51
#define LDNS_HEADER_SIZE
Definition: wire2host.h:32
void ldns_pkt_set_ra(ldns_pkt *packet, bool ra)
Definition: packet.c:524
#define LDNS_RDF_SIZE_DOUBLEWORD
Definition: rdata.h:35
#define LDNS_TC_WIRE(wirebuf)
Definition: wire2host.h:43
ldns_rdf * ldns_rdf_clone(const ldns_rdf *rd)
clones a rdf structure.
Definition: rdata.c:222
a class
Definition: rdata.h:76
#define LDNS_RDF_SIZE_6BYTES
Definition: rdata.h:36
#define LDNS_QDCOUNT(wirebuf)
Definition: wire2host.h:102
void ldns_rr_free(ldns_rr *rr)
frees an RR structure
Definition: rr.c:75
void ldns_pkt_set_qr(ldns_pkt *packet, bool qr)
Definition: packet.c:470
IPSECKEY.
Definition: rdata.h:107
#define LDNS_AA_WIRE(wirebuf)
Definition: wire2host.h:49
void ldns_pkt_set_edns_udp_size(ldns_pkt *packet, uint16_t s)
Set the packet&#39;s edns udp size.
Definition: packet.c:597
#define LDNS_RDF_SIZE_BYTE
Definition: rdata.h:33
#define LDNS_NSCOUNT(wirebuf)
Definition: wire2host.h:110
void ldns_pkt_set_tsig(ldns_pkt *pkt, ldns_rr *rr)
Set the packet&#39;s tsig rr.
Definition: packet.c:648
const ldns_rr_descriptor * ldns_rr_descript(uint16_t type)
returns the resource record descriptor for the given rr type.
Definition: rr.c:2569
protocol and port bitmaps
Definition: rdata.h:97
A non-zero sequence of US-ASCII letters and numbers in lower case.
Definition: rdata.h:126
void ldns_pkt_set_rcode(ldns_pkt *packet, uint8_t rcode)
Set the packet&#39;s respons code.
Definition: packet.c:542
A <character-string> encoding of the value field as specified [RFC1035], Section 5.1., encoded as remaining rdata.
Definition: rdata.h:132
apl data
Definition: rdata.h:64
Resource Record.
Definition: rr.h:302
void ldns_pkt_set_size(ldns_pkt *packet, size_t s)
Set the packet&#39;s size.
Definition: packet.c:591
void ldns_pkt_set_arcount(ldns_pkt *packet, uint16_t arcount)
Set the packet&#39;s arcount.
Definition: packet.c:566
Including this file will include all ldns files, and define some lookup tables.
certificate algorithm
Definition: rdata.h:78
#define LDNS_RDF_SIZE_16BYTES
Definition: rdata.h:38
uint16_t ldns_pkt_nscount(const ldns_pkt *packet)
Return the packet&#39;s ns count.
Definition: packet.c:111
ldns_status ldns_wire2dname(ldns_rdf **dname, const uint8_t *wire, size_t max, size_t *pos)
converts the data on the uint8_t bytearray (in wire format) to a DNS dname rdata field.
Definition: wire2host.c:56
void ldns_rr_set_class(ldns_rr *rr, ldns_rr_class rr_class)
sets the class in the rr.
Definition: rr.c:820
enum ldns_enum_rdf_type ldns_rdf_type
Definition: rdata.h:145
16 bits
Definition: rdata.h:54
#define LDNS_STATUS_CHECK_RETURN(st)
Definition: wire2host.c:154
Since RFC7218 TLSA records can be given with mnemonics, hence these rdata field types.
Definition: rdata.h:138
void ldns_rr_set_question(ldns_rr *rr, bool question)
Definition: rr.c:796
#define LDNS_MAX_DOMAINLEN
Maximum length of a complete dname.
Definition: rr.h:33
ldns_status ldns_wire2pkt(ldns_pkt **packet_p, const uint8_t *wire, size_t max)
converts the data on the uint8_t bytearray (in wire format) to a DNS packet.
Definition: wire2host.c:404
void ldns_pkt_set_edns_z(ldns_pkt *packet, uint16_t z)
Set the packet&#39;s edns z value.
Definition: packet.c:615
uint16_t ldns_pkt_ancount(const ldns_pkt *packet)
Return the packet&#39;s an count.
Definition: packet.c:105
void ldns_pkt_set_edns_version(ldns_pkt *packet, uint8_t v)
Set the packet&#39;s edns version.
Definition: packet.c:609
variable length any type rdata where the length is specified by the first 2 bytes ...
Definition: rdata.h:95
a key algorithm
Definition: rdata.h:80
b32 string
Definition: rdata.h:66
A record.
Definition: rdata.h:58
ldns_status ldns_buffer2pkt_wire(ldns_pkt **packet, const ldns_buffer *buffer)
converts the data in the ldns_buffer (in wire format) to a DNS packet.
Definition: wire2host.c:395
nsec type codes
Definition: rdata.h:72
#define LDNS_QR_WIRE(wirebuf)
Definition: wire2host.h:61
void ldns_pkt_set_nscount(ldns_pkt *packet, uint16_t nscount)
Set the packet&#39;s ns count.
Definition: packet.c:560
#define LDNS_CD_WIRE(wirebuf)
Definition: wire2host.h:74
void ldns_pkt_set_edns_data(ldns_pkt *packet, ldns_rdf *data)
Set the packet&#39;s edns data.
Definition: packet.c:621
size_t ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor)
returns the maximum number of rdata fields of the rr type this descriptor describes.
Definition: rr.c:2598
AAAA record.
Definition: rdata.h:60
#define LDNS_MAX_LABELLEN
Maximum length of a dname label.
Definition: rr.h:31
32 bits
Definition: rdata.h:56
void ldns_pkt_set_id(ldns_pkt *packet, uint16_t id)
Set the packet&#39;s id.
Definition: packet.c:456
Contains all information about resource record types.
Definition: rr.h:343
hex string
Definition: rdata.h:70
void ldns_pkt_set_opcode(ldns_pkt *packet, ldns_pkt_opcode opcode)
Set the packet&#39;s opcode.
Definition: packet.c:536
DNS packet.
Definition: packet.h:233
void ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *owner)
sets the owner in the rr structure.
Definition: rr.c:790
txt string
Definition: rdata.h:62
ldns_rr_type ldns_rr_get_type(const ldns_rr *rr)
returns the type of the rr.
Definition: rr.c:929
void ldns_pkt_set_edns_extended_rcode(ldns_pkt *packet, uint8_t c)
Set the packet&#39;s edns extended rcode.
Definition: packet.c:603
tsig time 48 bits
Definition: rdata.h:88
void ldns_pkt_set_rd(ldns_pkt *packet, bool rd)
Definition: packet.c:488
nsec3 base32 string (with length byte on wire
Definition: rdata.h:111
void ldns_rr_set_ttl(ldns_rr *rr, uint32_t ttl)
sets the ttl in the rr structure.
Definition: rr.c:802
enum ldns_enum_status ldns_status
Definition: error.h:134
ldns_rdf * ldns_rdf_new_frm_data(ldns_rdf_type type, size_t size, const void *data)
allocates a new rdf structure and fills it.
Definition: rdata.c:193
void ldns_pkt_set_cd(ldns_pkt *packet, bool cd)
Definition: packet.c:518
ldns_rdf * ldns_rdf_new(ldns_rdf_type type, size_t size, void *data)
allocates a new rdf structure and fills it.
Definition: rdata.c:179
#define LDNS_RDF_SIZE_WORD
Definition: rdata.h:34
#define LDNS_RDF_SIZE_8BYTES
Definition: rdata.h:37
4 shorts represented as 4 * 16 bit hex numbers separated by colons.
Definition: rdata.h:116
bool ldns_rr_push_rdf(ldns_rr *rr, const ldns_rdf *f)
sets rd_field member, it will be placed in the next available spot.
Definition: rr.c:843
Resource record data field.
Definition: rdata.h:174
Represents the Public Key Algorithm, HIT and Public Key fields for the HIP RR types.
Definition: rdata.h:92
#define LDNS_OPCODE_WIRE(wirebuf)
Definition: wire2host.h:55
nsec3 hash salt
Definition: rdata.h:109
8 bits
Definition: rdata.h:52
#define LDNS_ID_WIRE(wirebuf)
Definition: wire2host.h:97
ldns_rr * ldns_rr_new(void)
creates a new rr structure.
Definition: rr.c:24
ldns_rr_list * ldns_pkt_authority(const ldns_pkt *packet)
Return the packet&#39;s authority section.
Definition: packet.c:135
#define LDNS_RA_WIRE(wirebuf)
Definition: wire2host.h:92
void ldns_pkt_set_aa(ldns_pkt *packet, bool aa)
Definition: packet.c:476
uint32_t ldns_rr_ttl(const ldns_rr *rr)
returns the ttl of an rr structure.
Definition: rr.c:917
#define LDNS_MAX_POINTERS
Maximum number of pointers in 1 dname.
Definition: rr.h:35
uint8_t _edns_present
Definition: packet.h:255
ldns_rr_class ldns_rr_get_class(const ldns_rr *rr)
returns the class of the rr.
Definition: rr.c:935
#define LDNS_ANCOUNT(wirebuf)
Definition: wire2host.h:106
#define LDNS_ARCOUNT(wirebuf)
Definition: wire2host.h:114
enum ldns_enum_pkt_section ldns_pkt_section
Definition: packet.h:284
domain name
Definition: rdata.h:50
location data
Definition: rdata.h:99
ldns_rr_list * ldns_pkt_additional(const ldns_pkt *packet)
Return the packet&#39;s additional section.
Definition: packet.c:141
ldns_rr_list * ldns_pkt_answer(const ldns_pkt *packet)
Return the packet&#39;s answer section.
Definition: packet.c:129
8 * 8 bit hex numbers separated by dashes.
Definition: rdata.h:121
6 * 8 bit hex numbers separated by dashes.
Definition: rdata.h:119
void ldns_pkt_free(ldns_pkt *packet)
frees the packet structure and all data that it contains.
Definition: packet.c:792
well known services
Definition: rdata.h:101
#define LDNS_RCODE_WIRE(wirebuf)
Definition: wire2host.h:68
ldns_status ldns_wire2rr(ldns_rr **rr_p, const uint8_t *wire, size_t max, size_t *pos, ldns_pkt_section section)
converts the data on the uint8_t bytearray (in wire format) to a DNS resource record.
Definition: wire2host.c:319
ldns_status ldns_wire2rdf(ldns_rr *rr, const uint8_t *wire, size_t max, size_t *pos)
converts the data on the uint8_t bytearray (in wire format) to DNS rdata fields, and adds them to the...
Definition: wire2host.c:158
#define LDNS_STATUS_CHECK_GOTO(st, label)
Definition: wire2host.c:155