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