attempt fix #5578
[oweals/gnunet.git] / src / util / dnsparser.c
1 /*
2       This file is part of GNUnet
3       Copyright (C) 2010-2014, 2018 GNUnet e.V.
4
5       GNUnet is free software: you can redistribute it and/or modify it
6       under the terms of the GNU Affero General Public License as published
7       by the Free Software Foundation, either version 3 of the License,
8       or (at your option) any later version.
9
10       GNUnet is distributed in the hope that it will be useful, but
11       WITHOUT ANY WARRANTY; without even the implied warranty of
12       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13       Affero General Public License for more details.
14
15       You should have received a copy of the GNU Affero General Public License
16       along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
18      SPDX-License-Identifier: AGPL3.0-or-later
19  */
20
21 /**
22  * @file util/dnsparser.c
23  * @brief helper library to parse DNS packets.
24  * @author Philipp Toelke
25  * @author Christian Grothoff
26  */
27 #include "platform.h"
28 #if HAVE_LIBIDN2
29 #if HAVE_IDN2_H
30 #include <idn2.h>
31 #elif HAVE_IDN2_IDN2_H
32 #include <idn2/idn2.h>
33 #endif
34 #elif HAVE_LIBIDN
35 #if HAVE_IDNA_H
36 #include <idna.h>
37 #elif HAVE_IDN_IDNA_H
38 #include <idn/idna.h>
39 #endif
40 #endif
41 #if WINDOWS
42 #include <idn-free.h>
43 #endif
44 #include "gnunet_util_lib.h"
45
46
47 /**
48  * Check if a label in UTF-8 format can be coded into valid IDNA.
49  * This can fail if the ASCII-conversion becomes longer than 63 characters.
50  *
51  * @param label label to check (UTF-8 string)
52  * @return #GNUNET_OK if the label can be converted to IDNA,
53  *         #GNUNET_SYSERR if the label is not valid for DNS names
54  */
55 int
56 GNUNET_DNSPARSER_check_label (const char *label)
57 {
58   char *output;
59   size_t slen;
60
61   if (NULL != strchr (label, '.'))
62     return GNUNET_SYSERR; /* not a label! Did you mean GNUNET_DNSPARSER_check_name? */
63   if (IDNA_SUCCESS !=
64       idna_to_ascii_8z (label, &output, IDNA_ALLOW_UNASSIGNED))
65     return GNUNET_SYSERR;
66   slen = strlen (output);
67 #if WINDOWS
68   idn_free (output);
69 #else
70   free (output);
71 #endif
72   return (slen > 63) ? GNUNET_SYSERR : GNUNET_OK;
73 }
74
75
76 /**
77  * Check if a label in UTF-8 format can be coded into valid IDNA.
78  * This can fail if the ASCII-conversion becomes longer than 253 characters.
79  *
80  * @param name name to check (UTF-8 string)
81  * @return #GNUNET_OK if the label can be converted to IDNA,
82  *         #GNUNET_SYSERR if the label is not valid for DNS names
83  */
84 int
85 GNUNET_DNSPARSER_check_name (const char *name)
86 {
87   char *ldup;
88   char *output;
89   size_t slen;
90   char *tok;
91
92   ldup = GNUNET_strdup (name);
93   for (tok = strtok (ldup, "."); NULL != tok; tok = strtok (NULL, "."))
94     if (GNUNET_OK !=
95         GNUNET_DNSPARSER_check_label (tok))
96     {
97       GNUNET_free (ldup);
98       return GNUNET_SYSERR;
99     }
100   GNUNET_free (ldup);
101   if (IDNA_SUCCESS !=
102       idna_to_ascii_8z (name, &output, IDNA_ALLOW_UNASSIGNED))
103     return GNUNET_SYSERR;
104   slen = strlen (output);
105 #if WINDOWS
106   idn_free (output);
107 #else
108   free (output);
109 #endif
110   return (slen > 253) ? GNUNET_SYSERR : GNUNET_OK;
111 }
112
113
114 /**
115  * Free SOA information record.
116  *
117  * @param soa record to free
118  */
119 void
120 GNUNET_DNSPARSER_free_soa (struct GNUNET_DNSPARSER_SoaRecord *soa)
121 {
122   if (NULL == soa)
123     return;
124   GNUNET_free_non_null (soa->mname);
125   GNUNET_free_non_null (soa->rname);
126   GNUNET_free (soa);
127 }
128
129
130 /**
131  * Free CERT information record.
132  *
133  * @param cert record to free
134  */
135 void
136 GNUNET_DNSPARSER_free_cert (struct GNUNET_DNSPARSER_CertRecord *cert)
137 {
138   if (NULL == cert)
139     return;
140   GNUNET_free_non_null (cert->certificate_data);
141   GNUNET_free (cert);
142 }
143
144
145 /**
146  * Free SRV information record.
147  *
148  * @param srv record to free
149  */
150 void
151 GNUNET_DNSPARSER_free_srv (struct GNUNET_DNSPARSER_SrvRecord *srv)
152 {
153   if (NULL == srv)
154     return;
155   GNUNET_free_non_null (srv->target);
156   GNUNET_free (srv);
157 }
158
159
160 /**
161  * Free MX information record.
162  *
163  * @param mx record to free
164  */
165 void
166 GNUNET_DNSPARSER_free_mx (struct GNUNET_DNSPARSER_MxRecord *mx)
167 {
168   if (NULL == mx)
169     return;
170   GNUNET_free_non_null (mx->mxhost);
171   GNUNET_free (mx);
172 }
173
174
175 /**
176  * Free the given DNS record.
177  *
178  * @param r record to free
179  */
180 void
181 GNUNET_DNSPARSER_free_record (struct GNUNET_DNSPARSER_Record *r)
182 {
183   GNUNET_free_non_null (r->name);
184   switch (r->type)
185   {
186   case GNUNET_DNSPARSER_TYPE_MX:
187     GNUNET_DNSPARSER_free_mx (r->data.mx);
188     break;
189   case GNUNET_DNSPARSER_TYPE_SOA:
190     GNUNET_DNSPARSER_free_soa (r->data.soa);
191     break;
192   case GNUNET_DNSPARSER_TYPE_SRV:
193     GNUNET_DNSPARSER_free_srv (r->data.srv);
194     break;
195   case GNUNET_DNSPARSER_TYPE_CERT:
196     GNUNET_DNSPARSER_free_cert (r->data.cert);
197     break;
198   case GNUNET_DNSPARSER_TYPE_NS:
199   case GNUNET_DNSPARSER_TYPE_CNAME:
200   case GNUNET_DNSPARSER_TYPE_PTR:
201     GNUNET_free_non_null (r->data.hostname);
202     break;
203   default:
204     GNUNET_free_non_null (r->data.raw.data);
205     break;
206   }
207 }
208
209
210 /**
211  * Parse name inside of a DNS query or record.
212  *
213  * @param udp_payload entire UDP payload
214  * @param udp_payload_length length of @a udp_payload
215  * @param off pointer to the offset of the name to parse in the udp_payload (to be
216  *                    incremented by the size of the name)
217  * @param depth current depth of our recursion (to prevent stack overflow)
218  * @return name as 0-terminated C string on success, NULL if the payload is malformed
219  */
220 static char *
221 parse_name (const char *udp_payload,
222             size_t udp_payload_length,
223             size_t *off,
224             unsigned int depth)
225 {
226   const uint8_t *input = (const uint8_t *) udp_payload;
227   char *ret;
228   char *tmp;
229   char *xstr;
230   uint8_t len;
231   size_t xoff;
232   char *utf8;
233   Idna_rc rc;
234
235   ret = GNUNET_strdup ("");
236   while (1)
237   {
238     if (*off >= udp_payload_length)
239     {
240       GNUNET_break_op (0);
241       goto error;
242     }
243     len = input[*off];
244     if (0 == len)
245     {
246       (*off)++;
247       break;
248     }
249     if (len < 64)
250     {
251       if (*off + 1 + len > udp_payload_length)
252       {
253         GNUNET_break_op (0);
254         goto error;
255       }
256       GNUNET_asprintf (&tmp,
257                        "%.*s",
258                        (int) len,
259                        &udp_payload[*off + 1]);
260       if (IDNA_SUCCESS !=
261           (rc = idna_to_unicode_8z8z (tmp, &utf8, IDNA_ALLOW_UNASSIGNED)))
262       {
263         GNUNET_log (GNUNET_ERROR_TYPE_INFO,
264                     _("Failed to convert DNS IDNA name `%s' to UTF-8: %s\n"),
265                     tmp,
266                     idna_strerror (rc));
267         GNUNET_free (tmp);
268         GNUNET_asprintf (&tmp,
269                          "%s%.*s.",
270                          ret,
271                          (int) len,
272                          &udp_payload[*off + 1]);
273       }
274       else
275       {
276         GNUNET_free (tmp);
277         GNUNET_asprintf (&tmp,
278                          "%s%s.",
279                          ret,
280                          utf8);
281 #if WINDOWS
282         idn_free (utf8);
283 #else
284         free (utf8);
285 #endif
286       }
287       GNUNET_free (ret);
288       ret = tmp;
289       *off += 1 + len;
290     }
291     else if ((64 | 128) == (len & (64 | 128)) )
292     {
293       if (depth > 32)
294       {
295         GNUNET_break_op (0);
296         goto error; /* hard bound on stack to prevent "infinite" recursion, disallow! */
297       }
298       /* pointer to string */
299       if (*off + 1 > udp_payload_length)
300       {
301         GNUNET_break_op (0);
302         goto error;
303       }
304       xoff = ((len - (64 | 128)) << 8) + input[*off+1];
305       xstr = parse_name (udp_payload,
306                          udp_payload_length,
307                          &xoff,
308                          depth + 1);
309       if (NULL == xstr)
310       {
311         GNUNET_break_op (0);
312         goto error;
313       }
314       GNUNET_asprintf (&tmp,
315                        "%s%s.",
316                        ret,
317                        xstr);
318       GNUNET_free (ret);
319       GNUNET_free (xstr);
320       ret = tmp;
321       if (strlen (ret) > udp_payload_length)
322       {
323         GNUNET_break_op (0);
324         goto error; /* we are looping (building an infinite string) */
325       }
326       *off += 2;
327       /* pointers always terminate names */
328       break;
329     }
330     else
331     {
332       /* neither pointer nor inline string, not supported... */
333       GNUNET_break_op (0);
334       goto error;
335     }
336   }
337   if (0 < strlen(ret))
338     ret[strlen(ret)-1] = '\0'; /* eat tailing '.' */
339   return ret;
340  error:
341   GNUNET_break_op (0);
342   GNUNET_free (ret);
343   return NULL;
344 }
345
346
347 /**
348  * Parse name inside of a DNS query or record.
349  *
350  * @param udp_payload entire UDP payload
351  * @param udp_payload_length length of @a udp_payload
352  * @param off pointer to the offset of the name to parse in the udp_payload (to be
353  *                    incremented by the size of the name)
354  * @return name as 0-terminated C string on success, NULL if the payload is malformed
355  */
356 char *
357 GNUNET_DNSPARSER_parse_name (const char *udp_payload,
358                              size_t udp_payload_length,
359                              size_t *off)
360 {
361   return parse_name (udp_payload, udp_payload_length, off, 0);
362 }
363
364
365 /**
366  * Parse a DNS query entry.
367  *
368  * @param udp_payload entire UDP payload
369  * @param udp_payload_length length of @a udp_payload
370  * @param off pointer to the offset of the query to parse in the udp_payload (to be
371  *                    incremented by the size of the query)
372  * @param q where to write the query information
373  * @return #GNUNET_OK on success, #GNUNET_SYSERR if the query is malformed
374  */
375 int
376 GNUNET_DNSPARSER_parse_query (const char *udp_payload,
377                               size_t udp_payload_length,
378                               size_t *off,
379                               struct GNUNET_DNSPARSER_Query *q)
380 {
381   char *name;
382   struct GNUNET_TUN_DnsQueryLine ql;
383
384   name = GNUNET_DNSPARSER_parse_name (udp_payload,
385                                       udp_payload_length,
386                                       off);
387   if (NULL == name)
388   {
389     GNUNET_break_op (0);
390     return GNUNET_SYSERR;
391   }
392   q->name = name;
393   if (*off + sizeof (struct GNUNET_TUN_DnsQueryLine) > udp_payload_length)
394   {
395     GNUNET_break_op (0);
396     return GNUNET_SYSERR;
397   }
398   GNUNET_memcpy (&ql, &udp_payload[*off], sizeof (ql));
399   *off += sizeof (ql);
400   q->type = ntohs (ql.type);
401   q->dns_traffic_class = ntohs (ql.dns_traffic_class);
402   return GNUNET_OK;
403 }
404
405
406 /**
407  * Parse a DNS SOA record.
408  *
409  * @param udp_payload reference to UDP packet
410  * @param udp_payload_length length of @a udp_payload
411  * @param off pointer to the offset of the query to parse in the SOA record (to be
412  *                    incremented by the size of the record), unchanged on error
413  * @return the parsed SOA record, NULL on error
414  */
415 struct GNUNET_DNSPARSER_SoaRecord *
416 GNUNET_DNSPARSER_parse_soa (const char *udp_payload,
417                             size_t udp_payload_length,
418                             size_t *off)
419 {
420   struct GNUNET_DNSPARSER_SoaRecord *soa;
421   struct GNUNET_TUN_DnsSoaRecord soa_bin;
422   size_t old_off;
423
424   old_off = *off;
425   soa = GNUNET_new (struct GNUNET_DNSPARSER_SoaRecord);
426   soa->mname = GNUNET_DNSPARSER_parse_name (udp_payload,
427                                             udp_payload_length,
428                                             off);
429   soa->rname = GNUNET_DNSPARSER_parse_name (udp_payload,
430                                             udp_payload_length,
431                                             off);
432   if ( (NULL == soa->mname) ||
433        (NULL == soa->rname) ||
434        (*off + sizeof (struct GNUNET_TUN_DnsSoaRecord) > udp_payload_length) )
435   {
436     GNUNET_break_op (0);
437     GNUNET_DNSPARSER_free_soa (soa);
438     *off = old_off;
439     return NULL;
440   }
441   GNUNET_memcpy (&soa_bin,
442           &udp_payload[*off],
443           sizeof (struct GNUNET_TUN_DnsSoaRecord));
444   soa->serial = ntohl (soa_bin.serial);
445   soa->refresh = ntohl (soa_bin.refresh);
446   soa->retry = ntohl (soa_bin.retry);
447   soa->expire = ntohl (soa_bin.expire);
448   soa->minimum_ttl = ntohl (soa_bin.minimum);
449   (*off) += sizeof (struct GNUNET_TUN_DnsSoaRecord);
450   return soa;
451 }
452
453
454 /**
455  * Parse a DNS MX record.
456  *
457  * @param udp_payload reference to UDP packet
458  * @param udp_payload_length length of @a udp_payload
459  * @param off pointer to the offset of the query to parse in the MX record (to be
460  *                    incremented by the size of the record), unchanged on error
461  * @return the parsed MX record, NULL on error
462  */
463 struct GNUNET_DNSPARSER_MxRecord *
464 GNUNET_DNSPARSER_parse_mx (const char *udp_payload,
465                            size_t udp_payload_length,
466                            size_t *off)
467 {
468   struct GNUNET_DNSPARSER_MxRecord *mx;
469   uint16_t mxpref;
470   size_t old_off;
471
472   old_off = *off;
473   if (*off + sizeof (uint16_t) > udp_payload_length)
474   {
475     GNUNET_break_op (0);
476     return NULL;
477   }
478   GNUNET_memcpy (&mxpref, &udp_payload[*off], sizeof (uint16_t));
479   (*off) += sizeof (uint16_t);
480   mx = GNUNET_new (struct GNUNET_DNSPARSER_MxRecord);
481   mx->preference = ntohs (mxpref);
482   mx->mxhost = GNUNET_DNSPARSER_parse_name (udp_payload,
483                                             udp_payload_length,
484                                             off);
485   if (NULL == mx->mxhost)
486   {
487     GNUNET_break_op (0);
488     GNUNET_DNSPARSER_free_mx (mx);
489     *off = old_off;
490     return NULL;
491   }
492   return mx;
493 }
494
495
496 /**
497  * Parse a DNS SRV record.
498  *
499  * @param udp_payload reference to UDP packet
500  * @param udp_payload_length length of @a udp_payload
501  * @param off pointer to the offset of the query to parse in the SRV record (to be
502  *                    incremented by the size of the record), unchanged on error
503  * @return the parsed SRV record, NULL on error
504  */
505 struct GNUNET_DNSPARSER_SrvRecord *
506 GNUNET_DNSPARSER_parse_srv (const char *udp_payload,
507                             size_t udp_payload_length,
508                             size_t *off)
509 {
510   struct GNUNET_DNSPARSER_SrvRecord *srv;
511   struct GNUNET_TUN_DnsSrvRecord srv_bin;
512   size_t old_off;
513
514   old_off = *off;
515   if (*off + sizeof (struct GNUNET_TUN_DnsSrvRecord) > udp_payload_length)
516     return NULL;
517   GNUNET_memcpy (&srv_bin,
518           &udp_payload[*off],
519           sizeof (struct GNUNET_TUN_DnsSrvRecord));
520   (*off) += sizeof (struct GNUNET_TUN_DnsSrvRecord);
521   srv = GNUNET_new (struct GNUNET_DNSPARSER_SrvRecord);
522   srv->priority = ntohs (srv_bin.prio);
523   srv->weight = ntohs (srv_bin.weight);
524   srv->port = ntohs (srv_bin.port);
525   srv->target = GNUNET_DNSPARSER_parse_name (udp_payload,
526                                              udp_payload_length,
527                                              off);
528   if (NULL == srv->target)
529   {
530     GNUNET_DNSPARSER_free_srv (srv);
531     *off = old_off;
532     return NULL;
533   }
534   return srv;
535 }
536
537
538 /**
539  * Parse a DNS CERT record.
540  *
541  * @param udp_payload reference to UDP packet
542  * @param udp_payload_length length of @a udp_payload
543  * @param off pointer to the offset of the query to parse in the CERT record (to be
544  *                    incremented by the size of the record), unchanged on error
545  * @return the parsed CERT record, NULL on error
546  */
547 struct GNUNET_DNSPARSER_CertRecord *
548 GNUNET_DNSPARSER_parse_cert (const char *udp_payload,
549                              size_t udp_payload_length,
550                              size_t *off)
551 {
552   struct GNUNET_DNSPARSER_CertRecord *cert;
553   struct GNUNET_TUN_DnsCertRecord dcert;
554
555   if (*off + sizeof (struct GNUNET_TUN_DnsCertRecord) >= udp_payload_length)
556   {
557     GNUNET_break_op (0);
558     return NULL;
559   }
560   GNUNET_memcpy (&dcert,
561                  &udp_payload[*off],
562                  sizeof (struct GNUNET_TUN_DnsCertRecord));
563   (*off) += sizeof (struct GNUNET_TUN_DnsCertRecord);
564   cert = GNUNET_new (struct GNUNET_DNSPARSER_CertRecord);
565   cert->cert_type = ntohs (dcert.cert_type);
566   cert->cert_tag = ntohs (dcert.cert_tag);
567   cert->algorithm = dcert.algorithm;
568   cert->certificate_size = udp_payload_length - (*off);
569   cert->certificate_data = GNUNET_malloc (cert->certificate_size);
570   GNUNET_memcpy (cert->certificate_data,
571                  &udp_payload[*off],
572                  cert->certificate_size);
573   (*off) += cert->certificate_size;
574   return cert;
575 }
576
577
578 /**
579  * Parse a DNS record entry.
580  *
581  * @param udp_payload entire UDP payload
582  * @param udp_payload_length length of @a udp_payload
583  * @param off pointer to the offset of the record to parse in the udp_payload (to be
584  *                    incremented by the size of the record)
585  * @param r where to write the record information
586  * @return #GNUNET_OK on success, #GNUNET_SYSERR if the record is malformed
587  */
588 int
589 GNUNET_DNSPARSER_parse_record (const char *udp_payload,
590                                size_t udp_payload_length,
591                                size_t *off,
592                                struct GNUNET_DNSPARSER_Record *r)
593 {
594   char *name;
595   struct GNUNET_TUN_DnsRecordLine rl;
596   size_t old_off;
597   uint16_t data_len;
598
599   name = GNUNET_DNSPARSER_parse_name (udp_payload,
600                                       udp_payload_length,
601                                       off);
602   if (NULL == name)
603   {
604     GNUNET_break_op (0);
605     return GNUNET_SYSERR;
606   }
607   r->name = name;
608   if (*off + sizeof (struct GNUNET_TUN_DnsRecordLine) > udp_payload_length)
609   {
610     GNUNET_break_op (0);
611     return GNUNET_SYSERR;
612   }
613   GNUNET_memcpy (&rl, &udp_payload[*off], sizeof (rl));
614   (*off) += sizeof (rl);
615   r->type = ntohs (rl.type);
616   r->dns_traffic_class = ntohs (rl.dns_traffic_class);
617   r->expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
618                                                                                         ntohl (rl.ttl)));
619   data_len = ntohs (rl.data_len);
620   if (*off + data_len > udp_payload_length)
621   {
622     GNUNET_break_op (0);
623     return GNUNET_SYSERR;
624   }
625   old_off = *off;
626   switch (r->type)
627   {
628   case GNUNET_DNSPARSER_TYPE_NS:
629   case GNUNET_DNSPARSER_TYPE_CNAME:
630   case GNUNET_DNSPARSER_TYPE_DNAME:
631   case GNUNET_DNSPARSER_TYPE_PTR:
632     r->data.hostname = GNUNET_DNSPARSER_parse_name (udp_payload,
633                                                     udp_payload_length,
634                                                     off);
635     if ( (NULL == r->data.hostname) ||
636          (old_off + data_len != *off) )
637       return GNUNET_SYSERR;
638     return GNUNET_OK;
639   case GNUNET_DNSPARSER_TYPE_SOA:
640     r->data.soa = GNUNET_DNSPARSER_parse_soa (udp_payload,
641                                               udp_payload_length,
642                                               off);
643     if ( (NULL == r->data.soa) ||
644          (old_off + data_len != *off) )
645     {
646       GNUNET_break_op (0);
647       return GNUNET_SYSERR;
648     }
649     return GNUNET_OK;
650   case GNUNET_DNSPARSER_TYPE_MX:
651     r->data.mx = GNUNET_DNSPARSER_parse_mx (udp_payload,
652                                             udp_payload_length,
653                                             off);
654     if ( (NULL == r->data.mx) ||
655          (old_off + data_len != *off) )
656     {
657       GNUNET_break_op (0);
658       return GNUNET_SYSERR;
659     }
660     return GNUNET_OK;
661   case GNUNET_DNSPARSER_TYPE_SRV:
662     r->data.srv = GNUNET_DNSPARSER_parse_srv (udp_payload,
663                                               udp_payload_length,
664                                               off);
665     if ( (NULL == r->data.srv) ||
666          (old_off + data_len != *off) )
667     {
668       GNUNET_break_op (0);
669       return GNUNET_SYSERR;
670     }
671     return GNUNET_OK;
672   default:
673     r->data.raw.data = GNUNET_malloc (data_len);
674     r->data.raw.data_len = data_len;
675     GNUNET_memcpy (r->data.raw.data,
676                    &udp_payload[*off],
677                    data_len);
678     break;
679   }
680   (*off) += data_len;
681   return GNUNET_OK;
682 }
683
684
685 /**
686  * Parse a UDP payload of a DNS packet in to a nice struct for further
687  * processing and manipulation.
688  *
689  * @param udp_payload wire-format of the DNS packet
690  * @param udp_payload_length number of bytes in @a udp_payload
691  * @return NULL on error, otherwise the parsed packet
692  */
693 struct GNUNET_DNSPARSER_Packet *
694 GNUNET_DNSPARSER_parse (const char *udp_payload,
695                         size_t udp_payload_length)
696 {
697   struct GNUNET_DNSPARSER_Packet *p;
698   const struct GNUNET_TUN_DnsHeader *dns;
699   size_t off;
700   unsigned int n;
701
702   if (udp_payload_length < sizeof (struct GNUNET_TUN_DnsHeader))
703     return NULL;
704   dns = (const struct GNUNET_TUN_DnsHeader *) udp_payload;
705   off = sizeof (struct GNUNET_TUN_DnsHeader);
706   p = GNUNET_new (struct GNUNET_DNSPARSER_Packet);
707   p->flags = dns->flags;
708   p->id = dns->id;
709   n = ntohs (dns->query_count);
710   if (n > 0)
711   {
712     p->queries = GNUNET_new_array (n,
713                                    struct GNUNET_DNSPARSER_Query);
714     p->num_queries = n;
715     for (unsigned int i=0;i<n;i++)
716       if (GNUNET_OK !=
717           GNUNET_DNSPARSER_parse_query (udp_payload,
718                                         udp_payload_length,
719                                         &off,
720                                         &p->queries[i]))
721         goto error;
722   }
723   n = ntohs (dns->answer_rcount);
724   if (n > 0)
725   {
726     p->answers = GNUNET_new_array (n,
727                                    struct GNUNET_DNSPARSER_Record);
728     p->num_answers = n;
729     for (unsigned int i=0;i<n;i++)
730       if (GNUNET_OK !=
731           GNUNET_DNSPARSER_parse_record (udp_payload,
732                                          udp_payload_length,
733                                          &off,
734                                          &p->answers[i]))
735         goto error;
736   }
737   n = ntohs (dns->authority_rcount);
738   if (n > 0)
739   {
740     p->authority_records = GNUNET_new_array (n,
741                                              struct GNUNET_DNSPARSER_Record);
742     p->num_authority_records = n;
743     for (unsigned int i=0;i<n;i++)
744       if (GNUNET_OK !=
745           GNUNET_DNSPARSER_parse_record (udp_payload,
746                                          udp_payload_length,
747                                          &off,
748                                          &p->authority_records[i]))
749         goto error;
750   }
751   n = ntohs (dns->additional_rcount);
752   if (n > 0)
753   {
754     p->additional_records = GNUNET_new_array (n,
755                                               struct GNUNET_DNSPARSER_Record);
756     p->num_additional_records = n;
757     for (unsigned int i=0;i<n;i++)
758     {
759       if (GNUNET_OK !=
760           GNUNET_DNSPARSER_parse_record (udp_payload,
761                                          udp_payload_length,
762                                          &off,
763                                          &p->additional_records[i]))
764         goto error;
765     }
766   }
767   return p;
768  error:
769   GNUNET_break_op (0);
770   GNUNET_DNSPARSER_free_packet (p);
771   return NULL;
772 }
773
774
775 /**
776  * Duplicate (deep-copy) the given DNS record
777  *
778  * @param r the record
779  * @return the newly allocated record
780  */
781 struct GNUNET_DNSPARSER_Record *
782 GNUNET_DNSPARSER_duplicate_record (const struct GNUNET_DNSPARSER_Record *r)
783 {
784   struct GNUNET_DNSPARSER_Record *dup = GNUNET_memdup (r, sizeof (*r));
785
786   dup->name = GNUNET_strdup (r->name);
787   switch (r->type)
788   {
789     case GNUNET_DNSPARSER_TYPE_NS:
790     case GNUNET_DNSPARSER_TYPE_CNAME:
791     case GNUNET_DNSPARSER_TYPE_PTR:
792     {
793       dup->data.hostname = GNUNET_strdup (r->data.hostname);
794       break;
795     }
796     case GNUNET_DNSPARSER_TYPE_SOA:
797     {
798       dup->data.soa = GNUNET_DNSPARSER_duplicate_soa_record (r->data.soa);
799       break;
800     }
801     case GNUNET_DNSPARSER_TYPE_CERT:
802     {
803       dup->data.cert = GNUNET_DNSPARSER_duplicate_cert_record (r->data.cert);
804       break;
805     }
806     case GNUNET_DNSPARSER_TYPE_MX:
807     {
808       dup->data.mx = GNUNET_DNSPARSER_duplicate_mx_record (r->data.mx);
809       break;
810     }
811     case GNUNET_DNSPARSER_TYPE_SRV:
812     {
813       dup->data.srv = GNUNET_DNSPARSER_duplicate_srv_record (r->data.srv);
814       break;
815     }
816     default:
817     {
818       dup->data.raw.data = GNUNET_memdup (r->data.raw.data,
819                                           r->data.raw.data_len);
820     }
821   }
822   return dup;
823 }
824
825
826 /**
827  * Duplicate (deep-copy) the given DNS record
828  *
829  * @param r the record
830  * @return the newly allocated record
831  */
832 struct GNUNET_DNSPARSER_SoaRecord *
833 GNUNET_DNSPARSER_duplicate_soa_record (const struct GNUNET_DNSPARSER_SoaRecord *r)
834 {
835   struct GNUNET_DNSPARSER_SoaRecord *dup = GNUNET_memdup (r, sizeof (*r));
836
837   dup->mname = GNUNET_strdup (r->mname);
838   dup->rname = GNUNET_strdup (r->rname);
839   return dup;
840 }
841
842
843 /**
844  * Duplicate (deep-copy) the given DNS record
845  *
846  * @param r the record
847  * @return the newly allocated record
848  */
849 struct GNUNET_DNSPARSER_CertRecord *
850 GNUNET_DNSPARSER_duplicate_cert_record (const struct GNUNET_DNSPARSER_CertRecord *r)
851 {
852   struct GNUNET_DNSPARSER_CertRecord *dup = GNUNET_memdup (r, sizeof (*r));
853
854   dup->certificate_data = GNUNET_strdup (r->certificate_data);
855   return dup;
856 }
857
858
859 /**
860  * Duplicate (deep-copy) the given DNS record
861  *
862  * @param r the record
863  * @return the newly allocated record
864  */
865 struct GNUNET_DNSPARSER_MxRecord *
866 GNUNET_DNSPARSER_duplicate_mx_record (const struct GNUNET_DNSPARSER_MxRecord *r)
867 {
868   struct GNUNET_DNSPARSER_MxRecord *dup = GNUNET_memdup (r, sizeof (*r));
869
870   dup->mxhost = GNUNET_strdup (r->mxhost);
871   return dup;
872 }
873
874
875 /**
876  * Duplicate (deep-copy) the given DNS record
877  *
878  * @param r the record
879  * @return the newly allocated record
880  */
881 struct GNUNET_DNSPARSER_SrvRecord *
882 GNUNET_DNSPARSER_duplicate_srv_record (const struct GNUNET_DNSPARSER_SrvRecord *r)
883 {
884   struct GNUNET_DNSPARSER_SrvRecord *dup = GNUNET_memdup (r, sizeof (*r));
885
886   dup->target = GNUNET_strdup (r->target);
887   return dup;
888 }
889
890
891 /**
892  * Free memory taken by a packet.
893  *
894  * @param p packet to free
895  */
896 void
897 GNUNET_DNSPARSER_free_packet (struct GNUNET_DNSPARSER_Packet *p)
898 {
899   for (unsigned int i=0;i<p->num_queries;i++)
900     GNUNET_free_non_null (p->queries[i].name);
901   GNUNET_free_non_null (p->queries);
902   for (unsigned int i=0;i<p->num_answers;i++)
903     GNUNET_DNSPARSER_free_record (&p->answers[i]);
904   GNUNET_free_non_null (p->answers);
905   for (unsigned int i=0;i<p->num_authority_records;i++)
906     GNUNET_DNSPARSER_free_record (&p->authority_records[i]);
907   GNUNET_free_non_null (p->authority_records);
908   for (unsigned int i=0;i<p->num_additional_records;i++)
909     GNUNET_DNSPARSER_free_record (&p->additional_records[i]);
910   GNUNET_free_non_null (p->additional_records);
911   GNUNET_free (p);
912 }
913
914
915 /* ********************** DNS packet assembly code **************** */
916
917
918 /**
919  * Add a DNS name to the UDP packet at the given location, converting
920  * the name to IDNA notation as necessary.
921  *
922  * @param dst where to write the name (UDP packet)
923  * @param dst_len number of bytes in @a dst
924  * @param off pointer to offset where to write the name (increment by bytes used)
925  *            must not be changed if there is an error
926  * @param name name to write
927  * @return #GNUNET_SYSERR if @a name is invalid
928  *         #GNUNET_NO if @a name did not fit
929  *         #GNUNET_OK if @a name was added to @a dst
930  */
931 int
932 GNUNET_DNSPARSER_builder_add_name (char *dst,
933                                    size_t dst_len,
934                                    size_t *off,
935                                    const char *name)
936 {
937   const char *dot;
938   const char *idna_name;
939   char *idna_start;
940   size_t start;
941   size_t pos;
942   size_t len;
943   Idna_rc rc;
944
945   if (NULL == name)
946     return GNUNET_SYSERR;
947
948   if (IDNA_SUCCESS !=
949       (rc = idna_to_ascii_8z (name,
950                               &idna_start,
951                               IDNA_ALLOW_UNASSIGNED)))
952   {
953     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
954                 _("Failed to convert UTF-8 name `%s' to DNS IDNA format: %s\n"),
955                 name,
956                 idna_strerror (rc));
957     return GNUNET_NO;
958   }
959   idna_name = idna_start;
960   start = *off;
961   if (start + strlen (idna_name) + 2 > dst_len)
962     goto fail;
963   pos = start;
964   do
965   {
966     dot = strchr (idna_name, '.');
967     if (NULL == dot)
968       len = strlen (idna_name);
969     else
970       len = dot - idna_name;
971     if ( (len >= 64) || (0 == len) )
972     {
973       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
974                   "Invalid DNS name `%s': label with %u characters encountered\n",
975                   name,
976                   (unsigned int) len);
977       goto fail; /* label too long or empty */
978     }
979     dst[pos++] = (char) (uint8_t) len;
980     GNUNET_memcpy (&dst[pos],
981                    idna_name,
982                    len);
983     pos += len;
984     idna_name += len + 1; /* also skip dot */
985   }
986   while (NULL != dot);
987   dst[pos++] = '\0'; /* terminator */
988   *off = pos;
989 #if WINDOWS
990   idn_free (idna_start);
991 #else
992   free (idna_start);
993 #endif
994   return GNUNET_OK;
995  fail:
996 #if WINDOWS
997   idn_free (idna_start);
998 #else
999   free (idna_start);
1000 #endif
1001   return GNUNET_NO;
1002 }
1003
1004
1005 /**
1006  * Add a DNS query to the UDP packet at the given location.
1007  *
1008  * @param dst where to write the query
1009  * @param dst_len number of bytes in @a dst
1010  * @param off pointer to offset where to write the query (increment by bytes used)
1011  *            must not be changed if there is an error
1012  * @param query query to write
1013  * @return #GNUNET_SYSERR if @a query is invalid
1014  *         #GNUNET_NO if @a query did not fit
1015  *         #GNUNET_OK if @a query was added to @a dst
1016  */
1017 int
1018 GNUNET_DNSPARSER_builder_add_query (char *dst,
1019                                     size_t dst_len,
1020                                     size_t *off,
1021                                     const struct GNUNET_DNSPARSER_Query *query)
1022 {
1023   int ret;
1024   struct GNUNET_TUN_DnsQueryLine ql;
1025
1026   ret = GNUNET_DNSPARSER_builder_add_name (dst, dst_len - sizeof (struct GNUNET_TUN_DnsQueryLine), off, query->name);
1027   if (ret != GNUNET_OK)
1028     return ret;
1029   ql.type = htons (query->type);
1030   ql.dns_traffic_class = htons (query->dns_traffic_class);
1031   GNUNET_memcpy (&dst[*off], &ql, sizeof (ql));
1032   (*off) += sizeof (ql);
1033   return GNUNET_OK;
1034 }
1035
1036
1037 /**
1038  * Add an MX record to the UDP packet at the given location.
1039  *
1040  * @param dst where to write the mx record
1041  * @param dst_len number of bytes in @a dst
1042  * @param off pointer to offset where to write the mx information (increment by bytes used);
1043  *            can also change if there was an error
1044  * @param mx mx information to write
1045  * @return #GNUNET_SYSERR if @a mx is invalid
1046  *         #GNUNET_NO if @a mx did not fit
1047  *         #GNUNET_OK if @a mx was added to @a dst
1048  */
1049 int
1050 GNUNET_DNSPARSER_builder_add_mx (char *dst,
1051                                  size_t dst_len,
1052                                  size_t *off,
1053                                  const struct GNUNET_DNSPARSER_MxRecord *mx)
1054 {
1055   uint16_t mxpref;
1056
1057   if (*off + sizeof (uint16_t) > dst_len)
1058     return GNUNET_NO;
1059   mxpref = htons (mx->preference);
1060   GNUNET_memcpy (&dst[*off],
1061                  &mxpref,
1062                  sizeof (mxpref));
1063   (*off) += sizeof (mxpref);
1064   return GNUNET_DNSPARSER_builder_add_name (dst,
1065                                             dst_len,
1066                                             off,
1067                                             mx->mxhost);
1068 }
1069
1070
1071 /**
1072  * Add a CERT record to the UDP packet at the given location.
1073  *
1074  * @param dst where to write the CERT record
1075  * @param dst_len number of bytes in @a dst
1076  * @param off pointer to offset where to write the CERT information (increment by bytes used);
1077  *            can also change if there was an error
1078  * @param cert CERT information to write
1079  * @return #GNUNET_SYSERR if @a cert is invalid
1080  *         #GNUNET_NO if @a cert did not fit
1081  *         #GNUNET_OK if @a cert was added to @a dst
1082  */
1083 int
1084 GNUNET_DNSPARSER_builder_add_cert (char *dst,
1085                                    size_t dst_len,
1086                                    size_t *off,
1087                                    const struct GNUNET_DNSPARSER_CertRecord *cert)
1088 {
1089   struct GNUNET_TUN_DnsCertRecord dcert;
1090
1091 #ifdef __clang__
1092 #pragma clang diagnostic push
1093 #pragma clang diagnostic ignored "-Wtautological-constant-out-of-range-compare"
1094 #endif
1095   if ( (cert->cert_type > UINT16_MAX) ||
1096        (cert->algorithm > UINT8_MAX) )
1097   {
1098     GNUNET_break (0);
1099     return GNUNET_SYSERR;
1100   }
1101 #ifdef __clang__
1102 #pragma clang diagnostic pop
1103 #endif
1104   if (*off + sizeof (struct GNUNET_TUN_DnsCertRecord) + cert->certificate_size > dst_len)
1105     return GNUNET_NO;
1106   dcert.cert_type = htons ((uint16_t) cert->cert_type);
1107   dcert.cert_tag = htons ((uint16_t) cert->cert_tag);
1108   dcert.algorithm = (uint8_t) cert->algorithm;
1109   GNUNET_memcpy (&dst[*off], &dcert, sizeof (dcert));
1110   (*off) += sizeof (dcert);
1111   GNUNET_memcpy (&dst[*off], cert->certificate_data, cert->certificate_size);
1112   (*off) += cert->certificate_size;
1113   return GNUNET_OK;
1114 }
1115
1116
1117 /**
1118  * Add an SOA record to the UDP packet at the given location.
1119  *
1120  * @param dst where to write the SOA record
1121  * @param dst_len number of bytes in @a dst
1122  * @param off pointer to offset where to write the SOA information (increment by bytes used)
1123  *            can also change if there was an error
1124  * @param soa SOA information to write
1125  * @return #GNUNET_SYSERR if @a soa is invalid
1126  *         #GNUNET_NO if @a soa did not fit
1127  *         #GNUNET_OK if @a soa was added to @a dst
1128  */
1129 int
1130 GNUNET_DNSPARSER_builder_add_soa (char *dst,
1131                                   size_t dst_len,
1132                                   size_t *off,
1133                                   const struct GNUNET_DNSPARSER_SoaRecord *soa)
1134 {
1135   struct GNUNET_TUN_DnsSoaRecord sd;
1136   int ret;
1137
1138   if ( (GNUNET_OK != (ret = GNUNET_DNSPARSER_builder_add_name (dst,
1139                                                                dst_len,
1140                                                                off,
1141                                                                soa->mname))) ||
1142        (GNUNET_OK != (ret = GNUNET_DNSPARSER_builder_add_name (dst,
1143                                                                dst_len,
1144                                                                off,
1145                                                                soa->rname)) ) )
1146     return ret;
1147   if (*off + sizeof (struct GNUNET_TUN_DnsSoaRecord) > dst_len)
1148     return GNUNET_NO;
1149   sd.serial = htonl (soa->serial);
1150   sd.refresh = htonl (soa->refresh);
1151   sd.retry = htonl (soa->retry);
1152   sd.expire = htonl (soa->expire);
1153   sd.minimum = htonl (soa->minimum_ttl);
1154   GNUNET_memcpy (&dst[*off], &sd, sizeof (sd));
1155   (*off) += sizeof (sd);
1156   return GNUNET_OK;
1157 }
1158
1159
1160 /**
1161  * Add an SRV record to the UDP packet at the given location.
1162  *
1163  * @param dst where to write the SRV record
1164  * @param dst_len number of bytes in @a dst
1165  * @param off pointer to offset where to write the SRV information (increment by bytes used)
1166  *            can also change if there was an error
1167  * @param srv SRV information to write
1168  * @return #GNUNET_SYSERR if @a srv is invalid
1169  *         #GNUNET_NO if @a srv did not fit
1170  *         #GNUNET_OK if @a srv was added to @a dst
1171  */
1172 int
1173 GNUNET_DNSPARSER_builder_add_srv (char *dst,
1174                                   size_t dst_len,
1175                                   size_t *off,
1176                                   const struct GNUNET_DNSPARSER_SrvRecord *srv)
1177 {
1178   struct GNUNET_TUN_DnsSrvRecord sd;
1179   int ret;
1180
1181   if (*off + sizeof (struct GNUNET_TUN_DnsSrvRecord) > dst_len)
1182     return GNUNET_NO;
1183   sd.prio = htons (srv->priority);
1184   sd.weight = htons (srv->weight);
1185   sd.port = htons (srv->port);
1186   GNUNET_memcpy (&dst[*off],
1187                  &sd,
1188                  sizeof (sd));
1189   (*off) += sizeof (sd);
1190   if (GNUNET_OK != (ret = GNUNET_DNSPARSER_builder_add_name (dst,
1191                                                              dst_len,
1192                                                              off,
1193                                                              srv->target)))
1194     return ret;
1195   return GNUNET_OK;
1196 }
1197
1198
1199 /**
1200  * Add a DNS record to the UDP packet at the given location.
1201  *
1202  * @param dst where to write the query
1203  * @param dst_len number of bytes in @a dst
1204  * @param off pointer to offset where to write the query (increment by bytes used)
1205  *            must not be changed if there is an error
1206  * @param record record to write
1207  * @return #GNUNET_SYSERR if @a record is invalid
1208  *         #GNUNET_NO if @a record did not fit
1209  *         #GNUNET_OK if @a record was added to @a dst
1210  */
1211 static int
1212 add_record (char *dst,
1213             size_t dst_len,
1214             size_t *off,
1215             const struct GNUNET_DNSPARSER_Record *record)
1216 {
1217   int ret;
1218   size_t start;
1219   size_t pos;
1220   struct GNUNET_TUN_DnsRecordLine rl;
1221
1222   start = *off;
1223   ret = GNUNET_DNSPARSER_builder_add_name (dst,
1224                                            dst_len - sizeof (struct GNUNET_TUN_DnsRecordLine),
1225                                            off,
1226                                            record->name);
1227   if (GNUNET_OK != ret)
1228     return ret;
1229   /* '*off' is now the position where we will need to write the record line */
1230
1231   pos = *off + sizeof (struct GNUNET_TUN_DnsRecordLine);
1232   switch (record->type)
1233   {
1234   case GNUNET_DNSPARSER_TYPE_MX:
1235     ret = GNUNET_DNSPARSER_builder_add_mx (dst,
1236                                            dst_len,
1237                                            &pos,
1238                                            record->data.mx);
1239     break;
1240   case GNUNET_DNSPARSER_TYPE_CERT:
1241     ret = GNUNET_DNSPARSER_builder_add_cert (dst,
1242                                              dst_len,
1243                                              &pos,
1244                                              record->data.cert);
1245     break;
1246   case GNUNET_DNSPARSER_TYPE_SOA:
1247     ret = GNUNET_DNSPARSER_builder_add_soa (dst,
1248                                             dst_len,
1249                                             &pos,
1250                                             record->data.soa);
1251     break;
1252   case GNUNET_DNSPARSER_TYPE_NS:
1253   case GNUNET_DNSPARSER_TYPE_CNAME:
1254   case GNUNET_DNSPARSER_TYPE_PTR:
1255     ret = GNUNET_DNSPARSER_builder_add_name (dst,
1256                                              dst_len,
1257                                              &pos,
1258                                              record->data.hostname);
1259     break;
1260   case GNUNET_DNSPARSER_TYPE_SRV:
1261     ret = GNUNET_DNSPARSER_builder_add_srv (dst,
1262                                             dst_len,
1263                                             &pos,
1264                                             record->data.srv);
1265     break;
1266   default:
1267     if (pos + record->data.raw.data_len > dst_len)
1268     {
1269       ret = GNUNET_NO;
1270       break;
1271     }
1272     GNUNET_memcpy (&dst[pos],
1273                    record->data.raw.data,
1274                    record->data.raw.data_len);
1275     pos += record->data.raw.data_len;
1276     ret = GNUNET_OK;
1277     break;
1278   }
1279   if (GNUNET_OK != ret)
1280   {
1281     *off = start;
1282     return GNUNET_NO;
1283   }
1284
1285   if (pos - (*off + sizeof (struct GNUNET_TUN_DnsRecordLine)) > UINT16_MAX)
1286   {
1287     /* record data too long */
1288     *off = start;
1289     return GNUNET_NO;
1290   }
1291   rl.type = htons (record->type);
1292   rl.dns_traffic_class = htons (record->dns_traffic_class);
1293   rl.ttl = htonl (GNUNET_TIME_absolute_get_remaining (record->expiration_time).rel_value_us / 1000LL / 1000LL); /* in seconds */
1294   rl.data_len = htons ((uint16_t) (pos - (*off + sizeof (struct GNUNET_TUN_DnsRecordLine))));
1295   GNUNET_memcpy (&dst[*off],
1296                  &rl,
1297                  sizeof (struct GNUNET_TUN_DnsRecordLine));
1298   *off = pos;
1299   return GNUNET_OK;
1300 }
1301
1302
1303 /**
1304  * Given a DNS packet @a p, generate the corresponding UDP payload.
1305  * Note that we do not attempt to pack the strings with pointers
1306  * as this would complicate the code and this is about being
1307  * simple and secure, not fast, fancy and broken like bind.
1308  *
1309  * @param p packet to pack
1310  * @param max maximum allowed size for the resulting UDP payload
1311  * @param buf set to a buffer with the packed message
1312  * @param buf_length set to the length of @a buf
1313  * @return #GNUNET_SYSERR if @a p is invalid
1314  *         #GNUNET_NO if @a p was truncated (but there is still a result in @a buf)
1315  *         #GNUNET_OK if @a p was packed completely into @a buf
1316  */
1317 int
1318 GNUNET_DNSPARSER_pack (const struct GNUNET_DNSPARSER_Packet *p,
1319                        uint16_t max,
1320                        char **buf,
1321                        size_t *buf_length)
1322 {
1323   struct GNUNET_TUN_DnsHeader dns;
1324   size_t off;
1325   char tmp[max];
1326   int ret;
1327   int trc;
1328
1329   if ( (p->num_queries > UINT16_MAX) ||
1330        (p->num_answers > UINT16_MAX) ||
1331        (p->num_authority_records > UINT16_MAX) ||
1332        (p->num_additional_records > UINT16_MAX) )
1333     return GNUNET_SYSERR;
1334   dns.id = p->id;
1335   dns.flags = p->flags;
1336   dns.query_count = htons (p->num_queries);
1337   dns.answer_rcount = htons (p->num_answers);
1338   dns.authority_rcount = htons (p->num_authority_records);
1339   dns.additional_rcount = htons (p->num_additional_records);
1340
1341   off = sizeof (struct GNUNET_TUN_DnsHeader);
1342   trc = GNUNET_NO;
1343   for (unsigned int i=0;i<p->num_queries;i++)
1344   {
1345     ret = GNUNET_DNSPARSER_builder_add_query (tmp,
1346                                               sizeof (tmp),
1347                                               &off,
1348                                               &p->queries[i]);
1349     if (GNUNET_SYSERR == ret)
1350       return GNUNET_SYSERR;
1351     if (GNUNET_NO == ret)
1352     {
1353       dns.query_count = htons ((uint16_t) (i-1));
1354       trc = GNUNET_YES;
1355       break;
1356     }
1357   }
1358   for (unsigned int i=0;i<p->num_answers;i++)
1359   {
1360     ret = add_record (tmp,
1361                       sizeof (tmp),
1362                       &off,
1363                       &p->answers[i]);
1364     if (GNUNET_SYSERR == ret)
1365       return GNUNET_SYSERR;
1366     if (GNUNET_NO == ret)
1367     {
1368       dns.answer_rcount = htons ((uint16_t) (i-1));
1369       trc = GNUNET_YES;
1370       break;
1371     }
1372   }
1373   for (unsigned int i=0;i<p->num_authority_records;i++)
1374   {
1375     ret = add_record (tmp,
1376                       sizeof (tmp),
1377                       &off,
1378                       &p->authority_records[i]);
1379     if (GNUNET_SYSERR == ret)
1380       return GNUNET_SYSERR;
1381     if (GNUNET_NO == ret)
1382     {
1383       dns.authority_rcount = htons ((uint16_t) (i-1));
1384       trc = GNUNET_YES;
1385       break;
1386     }
1387   }
1388   for (unsigned int i=0;i<p->num_additional_records;i++)
1389   {
1390     ret = add_record (tmp,
1391                       sizeof (tmp),
1392                       &off,
1393                       &p->additional_records[i]);
1394     if (GNUNET_SYSERR == ret)
1395       return GNUNET_SYSERR;
1396     if (GNUNET_NO == ret)
1397     {
1398       dns.additional_rcount = htons (i-1);
1399       trc = GNUNET_YES;
1400       break;
1401     }
1402   }
1403
1404   if (GNUNET_YES == trc)
1405     dns.flags.message_truncated = 1;
1406   GNUNET_memcpy (tmp,
1407                  &dns,
1408                  sizeof (struct GNUNET_TUN_DnsHeader));
1409
1410   *buf = GNUNET_malloc (off);
1411   *buf_length = off;
1412   GNUNET_memcpy (*buf,
1413                  tmp,
1414                  off);
1415   if (GNUNET_YES == trc)
1416     return GNUNET_NO;
1417   return GNUNET_OK;
1418 }
1419
1420
1421 /**
1422  * Convert a block of binary data to HEX.
1423  *
1424  * @param data binary data to convert
1425  * @param data_size number of bytes in @a data
1426  * @return HEX string (lower case)
1427  */
1428 char *
1429 GNUNET_DNSPARSER_bin_to_hex (const void *data,
1430                              size_t data_size)
1431 {
1432   char *ret;
1433   size_t off;
1434   const uint8_t *idata;
1435
1436   idata = data;
1437   ret = GNUNET_malloc (data_size * 2 + 1);
1438   for (off = 0; off < data_size; off++)
1439     sprintf (&ret[off * 2],
1440              "%02x",
1441              idata[off]);
1442   return ret;
1443 }
1444
1445
1446 /**
1447  * Convert a HEX string to block of binary data.
1448  *
1449  * @param hex HEX string to convert (may contain mixed case)
1450  * @param data where to write result, must be
1451  *             at least `strlen(hex)/2` bytes long
1452  * @return number of bytes written to data
1453  */
1454 size_t
1455 GNUNET_DNSPARSER_hex_to_bin (const char *hex,
1456                              void *data)
1457 {
1458   size_t data_size;
1459   size_t off;
1460   uint8_t *idata;
1461   unsigned int h;
1462   char in[3];
1463
1464   data_size = strlen (hex) / 2;
1465   idata = data;
1466   in[2] = '\0';
1467   for (off = 0; off < data_size; off++)
1468   {
1469     in[0] = tolower ((unsigned char) hex[off * 2]);
1470     in[1] = tolower ((unsigned char) hex[off * 2 + 1]);
1471     if (1 != sscanf (in, "%x", &h))
1472       return off;
1473     idata[off] = (uint8_t) h;
1474   }
1475   return off;
1476 }
1477
1478
1479 /* end of dnsparser.c */