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