aboutsummaryrefslogtreecommitdiff
path: root/src/dns/gnunet-zonewalk.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/dns/gnunet-zonewalk.c')
-rw-r--r--src/dns/gnunet-zonewalk.c593
1 files changed, 301 insertions, 292 deletions
diff --git a/src/dns/gnunet-zonewalk.c b/src/dns/gnunet-zonewalk.c
index 19fc5b78d..2968d0209 100644
--- a/src/dns/gnunet-zonewalk.c
+++ b/src/dns/gnunet-zonewalk.c
@@ -11,12 +11,12 @@
11 WITHOUT ANY WARRANTY; without even the implied warranty of 11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details. 13 Affero General Public License for more details.
14 14
15 You should have received a copy of the GNU Affero General Public License 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/>. 16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 17
18 SPDX-License-Identifier: AGPL3.0-or-later 18 SPDX-License-Identifier: AGPL3.0-or-later
19*/ 19 */
20 20
21/** 21/**
22 * @file src/dns/gnunet-zoneimport.c 22 * @file src/dns/gnunet-zoneimport.c
@@ -31,8 +31,7 @@
31/** 31/**
32 * Request we should make. 32 * Request we should make.
33 */ 33 */
34struct Request 34struct Request {
35{
36 /** 35 /**
37 * Requests are kept in a DLL. 36 * Requests are kept in a DLL.
38 */ 37 */
@@ -144,145 +143,155 @@ static struct GNUNET_SCHEDULER_Task *t;
144 * @param rec response 143 * @param rec response
145 */ 144 */
146static void 145static void
147process_record (struct Request *req, 146process_record(struct Request *req,
148 struct GNUNET_DNSPARSER_Record *rec) 147 struct GNUNET_DNSPARSER_Record *rec)
149{ 148{
150 char buf[INET6_ADDRSTRLEN]; 149 char buf[INET6_ADDRSTRLEN];
151 150
152 records++; 151 records++;
153 switch (rec->type) 152 switch (rec->type)
154 { 153 {
155 case GNUNET_DNSPARSER_TYPE_A: 154 case GNUNET_DNSPARSER_TYPE_A:
156 fprintf (stdout, 155 fprintf(stdout,
157 "%s A %s\n", 156 "%s A %s\n",
158 req->hostname, 157 req->hostname,
159 inet_ntop (AF_INET, 158 inet_ntop(AF_INET,
160 rec->data.raw.data, 159 rec->data.raw.data,
161 buf, 160 buf,
162 sizeof (buf))); 161 sizeof(buf)));
163 break; 162 break;
164 case GNUNET_DNSPARSER_TYPE_AAAA: 163
165 fprintf (stdout, 164 case GNUNET_DNSPARSER_TYPE_AAAA:
166 "%s AAAA %s\n", 165 fprintf(stdout,
167 req->hostname, 166 "%s AAAA %s\n",
168 inet_ntop (AF_INET6, 167 req->hostname,
168 inet_ntop(AF_INET6,
169 rec->data.raw.data, 169 rec->data.raw.data,
170 buf, 170 buf,
171 sizeof (buf))); 171 sizeof(buf)));
172 break; 172 break;
173 case GNUNET_DNSPARSER_TYPE_NS: 173
174 fprintf (stdout, 174 case GNUNET_DNSPARSER_TYPE_NS:
175 "%s NS %s\n", 175 fprintf(stdout,
176 req->hostname, 176 "%s NS %s\n",
177 rec->data.hostname); 177 req->hostname,
178 break; 178 rec->data.hostname);
179 case GNUNET_DNSPARSER_TYPE_CNAME: 179 break;
180 fprintf (stdout, 180
181 "%s CNAME %s\n", 181 case GNUNET_DNSPARSER_TYPE_CNAME:
182 req->hostname, 182 fprintf(stdout,
183 rec->data.hostname); 183 "%s CNAME %s\n",
184 break; 184 req->hostname,
185 case GNUNET_DNSPARSER_TYPE_MX: 185 rec->data.hostname);
186 fprintf (stdout, 186 break;
187 "%s MX %u %s\n", 187
188 req->hostname, 188 case GNUNET_DNSPARSER_TYPE_MX:
189 (unsigned int) rec->data.mx->preference, 189 fprintf(stdout,
190 rec->data.mx->mxhost); 190 "%s MX %u %s\n",
191 break; 191 req->hostname,
192 case GNUNET_DNSPARSER_TYPE_SOA: 192 (unsigned int)rec->data.mx->preference,
193 fprintf (stdout, 193 rec->data.mx->mxhost);
194 "%s SOA %s %s %u %u %u %u %u\n", 194 break;
195 req->hostname, 195
196 rec->data.soa->mname, 196 case GNUNET_DNSPARSER_TYPE_SOA:
197 rec->data.soa->rname, 197 fprintf(stdout,
198 (unsigned int) rec->data.soa->serial, 198 "%s SOA %s %s %u %u %u %u %u\n",
199 (unsigned int) rec->data.soa->refresh, 199 req->hostname,
200 (unsigned int) rec->data.soa->retry, 200 rec->data.soa->mname,
201 (unsigned int) rec->data.soa->expire, 201 rec->data.soa->rname,
202 (unsigned int) rec->data.soa->minimum_ttl); 202 (unsigned int)rec->data.soa->serial,
203 break; 203 (unsigned int)rec->data.soa->refresh,
204 case GNUNET_DNSPARSER_TYPE_SRV: 204 (unsigned int)rec->data.soa->retry,
205 fprintf (stdout, 205 (unsigned int)rec->data.soa->expire,
206 "%s SRV %s %u %u %u\n", 206 (unsigned int)rec->data.soa->minimum_ttl);
207 req->hostname, 207 break;
208 rec->data.srv->target, 208
209 rec->data.srv->priority, 209 case GNUNET_DNSPARSER_TYPE_SRV:
210 rec->data.srv->weight, 210 fprintf(stdout,
211 rec->data.srv->port); 211 "%s SRV %s %u %u %u\n",
212 break; 212 req->hostname,
213 case GNUNET_DNSPARSER_TYPE_PTR: 213 rec->data.srv->target,
214 fprintf (stdout, 214 rec->data.srv->priority,
215 "%s PTR %s\n", 215 rec->data.srv->weight,
216 req->hostname, 216 rec->data.srv->port);
217 rec->data.hostname); 217 break;
218 break; 218
219 case GNUNET_DNSPARSER_TYPE_TXT: 219 case GNUNET_DNSPARSER_TYPE_PTR:
220 fprintf (stdout, 220 fprintf(stdout,
221 "%s TXT %.*s\n", 221 "%s PTR %s\n",
222 req->hostname, 222 req->hostname,
223 (int) rec->data.raw.data_len, 223 rec->data.hostname);
224 (char *) rec->data.raw.data); 224 break;
225 break; 225
226 case GNUNET_DNSPARSER_TYPE_DNAME: 226 case GNUNET_DNSPARSER_TYPE_TXT:
227 fprintf (stdout, 227 fprintf(stdout,
228 "%s DNAME %s\n", 228 "%s TXT %.*s\n",
229 req->hostname, 229 req->hostname,
230 rec->data.hostname); 230 (int)rec->data.raw.data_len,
231 break; 231 (char *)rec->data.raw.data);
232 break;
233
234 case GNUNET_DNSPARSER_TYPE_DNAME:
235 fprintf(stdout,
236 "%s DNAME %s\n",
237 req->hostname,
238 rec->data.hostname);
239 break;
232 240
233 /* obscure records */ 241 /* obscure records */
234 case GNUNET_DNSPARSER_TYPE_AFSDB: 242 case GNUNET_DNSPARSER_TYPE_AFSDB:
235 case GNUNET_DNSPARSER_TYPE_NAPTR: 243 case GNUNET_DNSPARSER_TYPE_NAPTR:
236 case GNUNET_DNSPARSER_TYPE_APL: 244 case GNUNET_DNSPARSER_TYPE_APL:
237 case GNUNET_DNSPARSER_TYPE_DHCID: 245 case GNUNET_DNSPARSER_TYPE_DHCID:
238 case GNUNET_DNSPARSER_TYPE_HIP: 246 case GNUNET_DNSPARSER_TYPE_HIP:
239 case GNUNET_DNSPARSER_TYPE_LOC: 247 case GNUNET_DNSPARSER_TYPE_LOC:
240 case GNUNET_DNSPARSER_TYPE_RP: 248 case GNUNET_DNSPARSER_TYPE_RP:
241 case GNUNET_DNSPARSER_TYPE_TKEY: 249 case GNUNET_DNSPARSER_TYPE_TKEY:
242 case GNUNET_DNSPARSER_TYPE_TSIG: 250 case GNUNET_DNSPARSER_TYPE_TSIG:
243 case GNUNET_DNSPARSER_TYPE_URI: 251 case GNUNET_DNSPARSER_TYPE_URI:
244 case GNUNET_DNSPARSER_TYPE_TA: 252 case GNUNET_DNSPARSER_TYPE_TA:
245 253
246 /* DNSSEC */ 254 /* DNSSEC */
247 case GNUNET_DNSPARSER_TYPE_DS: 255 case GNUNET_DNSPARSER_TYPE_DS:
248 case GNUNET_DNSPARSER_TYPE_RRSIG: 256 case GNUNET_DNSPARSER_TYPE_RRSIG:
249 case GNUNET_DNSPARSER_TYPE_NSEC: 257 case GNUNET_DNSPARSER_TYPE_NSEC:
250 case GNUNET_DNSPARSER_TYPE_DNSKEY: 258 case GNUNET_DNSPARSER_TYPE_DNSKEY:
251 case GNUNET_DNSPARSER_TYPE_NSEC3: 259 case GNUNET_DNSPARSER_TYPE_NSEC3:
252 case GNUNET_DNSPARSER_TYPE_NSEC3PARAM: 260 case GNUNET_DNSPARSER_TYPE_NSEC3PARAM:
253 case GNUNET_DNSPARSER_TYPE_CDS: 261 case GNUNET_DNSPARSER_TYPE_CDS:
254 case GNUNET_DNSPARSER_TYPE_CDNSKEY: 262 case GNUNET_DNSPARSER_TYPE_CDNSKEY:
255 263
256 /* DNSSEC payload */ 264 /* DNSSEC payload */
257 case GNUNET_DNSPARSER_TYPE_CERT: 265 case GNUNET_DNSPARSER_TYPE_CERT:
258 case GNUNET_DNSPARSER_TYPE_SSHFP: 266 case GNUNET_DNSPARSER_TYPE_SSHFP:
259 case GNUNET_DNSPARSER_TYPE_IPSECKEY: 267 case GNUNET_DNSPARSER_TYPE_IPSECKEY:
260 case GNUNET_DNSPARSER_TYPE_TLSA: 268 case GNUNET_DNSPARSER_TYPE_TLSA:
261 case GNUNET_DNSPARSER_TYPE_OPENPGPKEY: 269 case GNUNET_DNSPARSER_TYPE_OPENPGPKEY:
262 270
263 /* obsolete records */ 271 /* obsolete records */
264 case GNUNET_DNSPARSER_TYPE_SIG: 272 case GNUNET_DNSPARSER_TYPE_SIG:
265 case GNUNET_DNSPARSER_TYPE_KEY: 273 case GNUNET_DNSPARSER_TYPE_KEY:
266 case GNUNET_DNSPARSER_TYPE_KX: 274 case GNUNET_DNSPARSER_TYPE_KX:
267 { 275 {
268 char *base32; 276 char *base32;
269 277
270 base32 = GNUNET_STRINGS_data_to_string_alloc (rec->data.raw.data, 278 base32 = GNUNET_STRINGS_data_to_string_alloc(rec->data.raw.data,
271 rec->data.raw.data_len); 279 rec->data.raw.data_len);
272 fprintf (stdout, 280 fprintf(stdout,
273 "%s (%u) %s\n", 281 "%s (%u) %s\n",
274 req->hostname, 282 req->hostname,
275 rec->type, 283 rec->type,
276 base32); 284 base32);
277 GNUNET_free (base32); 285 GNUNET_free(base32);
278 } 286 }
279 break; 287 break;
280 default: 288
281 fprintf (stderr, 289 default:
282 "Unsupported type %u\n", 290 fprintf(stderr,
283 (unsigned int) rec->type); 291 "Unsupported type %u\n",
284 break; 292 (unsigned int)rec->type);
285 } 293 break;
294 }
286} 295}
287 296
288 297
@@ -294,90 +303,90 @@ process_record (struct Request *req,
294 * @param dns_len number of bytes in @a dns 303 * @param dns_len number of bytes in @a dns
295 */ 304 */
296static void 305static void
297process_result (void *cls, 306process_result(void *cls,
298 const struct GNUNET_TUN_DnsHeader *dns, 307 const struct GNUNET_TUN_DnsHeader *dns,
299 size_t dns_len) 308 size_t dns_len)
300{ 309{
301 struct Request *req = cls; 310 struct Request *req = cls;
302 struct GNUNET_DNSPARSER_Packet *p; 311 struct GNUNET_DNSPARSER_Packet *p;
303 312
304 if (NULL == dns) 313 if (NULL == dns)
305 {
306 /* stub gave up */
307 pending--;
308 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
309 "Stub gave up on DNS reply for `%s'\n",
310 req->hostname);
311 GNUNET_CONTAINER_DLL_remove (req_head,
312 req_tail,
313 req);
314 if (req->issue_num > MAX_RETRIES)
315 { 314 {
316 failures++; 315 /* stub gave up */
317 GNUNET_free (req->hostname); 316 pending--;
318 GNUNET_free (req->raw); 317 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
319 GNUNET_free (req); 318 "Stub gave up on DNS reply for `%s'\n",
319 req->hostname);
320 GNUNET_CONTAINER_DLL_remove(req_head,
321 req_tail,
322 req);
323 if (req->issue_num > MAX_RETRIES)
324 {
325 failures++;
326 GNUNET_free(req->hostname);
327 GNUNET_free(req->raw);
328 GNUNET_free(req);
329 return;
330 }
331 GNUNET_CONTAINER_DLL_insert_tail(req_head,
332 req_tail,
333 req);
334 req->rs = NULL;
320 return; 335 return;
321 } 336 }
322 GNUNET_CONTAINER_DLL_insert_tail (req_head,
323 req_tail,
324 req);
325 req->rs = NULL;
326 return;
327 }
328 if (req->id != dns->id) 337 if (req->id != dns->id)
329 return; 338 return;
330 pending--; 339 pending--;
331 GNUNET_DNSSTUB_resolve_cancel (req->rs); 340 GNUNET_DNSSTUB_resolve_cancel(req->rs);
332 req->rs = NULL; 341 req->rs = NULL;
333 GNUNET_CONTAINER_DLL_remove (req_head, 342 GNUNET_CONTAINER_DLL_remove(req_head,
334 req_tail, 343 req_tail,
335 req); 344 req);
336 p = GNUNET_DNSPARSER_parse ((const char *) dns, 345 p = GNUNET_DNSPARSER_parse((const char *)dns,
337 dns_len); 346 dns_len);
338 if (NULL == p) 347 if (NULL == p)
339 {
340 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
341 "Failed to parse DNS reply for `%s'\n",
342 req->hostname);
343 if (req->issue_num > MAX_RETRIES)
344 { 348 {
345 failures++; 349 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
346 GNUNET_free (req->hostname); 350 "Failed to parse DNS reply for `%s'\n",
347 GNUNET_free (req->raw); 351 req->hostname);
348 GNUNET_free (req); 352 if (req->issue_num > MAX_RETRIES)
353 {
354 failures++;
355 GNUNET_free(req->hostname);
356 GNUNET_free(req->raw);
357 GNUNET_free(req);
358 return;
359 }
360 GNUNET_CONTAINER_DLL_insert_tail(req_head,
361 req_tail,
362 req);
349 return; 363 return;
350 } 364 }
351 GNUNET_CONTAINER_DLL_insert_tail (req_head, 365 for (unsigned int i = 0; i < p->num_answers; i++)
352 req_tail, 366 {
353 req); 367 struct GNUNET_DNSPARSER_Record *rs = &p->answers[i];
354 return; 368
355 } 369 process_record(req,
356 for (unsigned int i=0;i<p->num_answers;i++) 370 rs);
357 { 371 }
358 struct GNUNET_DNSPARSER_Record *rs = &p->answers[i]; 372 for (unsigned int i = 0; i < p->num_authority_records; i++)
359 373 {
360 process_record (req, 374 struct GNUNET_DNSPARSER_Record *rs = &p->authority_records[i];
361 rs); 375
362 } 376 process_record(req,
363 for (unsigned int i=0;i<p->num_authority_records;i++) 377 rs);
364 { 378 }
365 struct GNUNET_DNSPARSER_Record *rs = &p->authority_records[i]; 379 for (unsigned int i = 0; i < p->num_additional_records; i++)
366 380 {
367 process_record (req, 381 struct GNUNET_DNSPARSER_Record *rs = &p->additional_records[i];
368 rs); 382
369 } 383 process_record(req,
370 for (unsigned int i=0;i<p->num_additional_records;i++) 384 rs);
371 { 385 }
372 struct GNUNET_DNSPARSER_Record *rs = &p->additional_records[i]; 386 GNUNET_DNSPARSER_free_packet(p);
373 387 GNUNET_free(req->hostname);
374 process_record (req, 388 GNUNET_free(req->raw);
375 rs); 389 GNUNET_free(req);
376 }
377 GNUNET_DNSPARSER_free_packet (p);
378 GNUNET_free (req->hostname);
379 GNUNET_free (req->raw);
380 GNUNET_free (req);
381} 390}
382 391
383 392
@@ -391,31 +400,31 @@ process_result (void *cls,
391 * #GNUNET_SYSERR if we are at the rate limit 400 * #GNUNET_SYSERR if we are at the rate limit
392 */ 401 */
393static int 402static int
394submit_req (struct Request *req) 403submit_req(struct Request *req)
395{ 404{
396 static struct timeval last_request; 405 static struct timeval last_request;
397 struct timeval now; 406 struct timeval now;
398 407
399 if (NULL != req->rs) 408 if (NULL != req->rs)
400 return GNUNET_NO; /* already submitted */ 409 return GNUNET_NO; /* already submitted */
401 gettimeofday (&now, 410 gettimeofday(&now,
402 NULL); 411 NULL);
403 if ( ( ( (now.tv_sec - last_request.tv_sec) == 0) && 412 if ((((now.tv_sec - last_request.tv_sec) == 0) &&
404 ( (now.tv_usec - last_request.tv_usec) < TIME_THRESH) ) || 413 ((now.tv_usec - last_request.tv_usec) < TIME_THRESH)) ||
405 (pending >= THRESH) ) 414 (pending >= THRESH))
406 return GNUNET_SYSERR; 415 return GNUNET_SYSERR;
407 GNUNET_assert (NULL == req->rs); 416 GNUNET_assert(NULL == req->rs);
408 req->rs = GNUNET_DNSSTUB_resolve (ctx, 417 req->rs = GNUNET_DNSSTUB_resolve(ctx,
409 req->raw, 418 req->raw,
410 req->raw_len, 419 req->raw_len,
411 &process_result, 420 &process_result,
412 req); 421 req);
413 GNUNET_assert (NULL != req->rs); 422 GNUNET_assert(NULL != req->rs);
414 req->issue_num++; 423 req->issue_num++;
415 last_request = now; 424 last_request = now;
416 lookups++; 425 lookups++;
417 pending++; 426 pending++;
418 req->time = time (NULL); 427 req->time = time(NULL);
419 return GNUNET_OK; 428 return GNUNET_OK;
420} 429}
421 430
@@ -428,21 +437,21 @@ submit_req (struct Request *req)
428static void 437static void
429process_queue(void *cls) 438process_queue(void *cls)
430{ 439{
431 (void) cls; 440 (void)cls;
432 t = NULL; 441 t = NULL;
433 for (struct Request *req = req_head; 442 for (struct Request *req = req_head;
434 NULL != req; 443 NULL != req;
435 req = req->next) 444 req = req->next)
436 { 445 {
437 if (GNUNET_SYSERR == submit_req (req)) 446 if (GNUNET_SYSERR == submit_req(req))
438 break; 447 break;
439 } 448 }
440 if (NULL != req_head) 449 if (NULL != req_head)
441 t = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS, 450 t = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MILLISECONDS,
442 &process_queue, 451 &process_queue,
443 NULL); 452 NULL);
444 else 453 else
445 GNUNET_SCHEDULER_shutdown (); 454 GNUNET_SCHEDULER_shutdown();
446} 455}
447 456
448 457
@@ -452,15 +461,15 @@ process_queue(void *cls)
452 * @param cls NULL 461 * @param cls NULL
453 */ 462 */
454static void 463static void
455do_shutdown (void *cls) 464do_shutdown(void *cls)
456{ 465{
457 (void) cls; 466 (void)cls;
458 if (NULL != t) 467 if (NULL != t)
459 { 468 {
460 GNUNET_SCHEDULER_cancel (t); 469 GNUNET_SCHEDULER_cancel(t);
461 t = NULL; 470 t = NULL;
462 } 471 }
463 GNUNET_DNSSTUB_stop (ctx); 472 GNUNET_DNSSTUB_stop(ctx);
464 ctx = NULL; 473 ctx = NULL;
465} 474}
466 475
@@ -472,14 +481,14 @@ do_shutdown (void *cls)
472 * @param cls NULL 481 * @param cls NULL
473 */ 482 */
474static void 483static void
475run (void *cls) 484run(void *cls)
476{ 485{
477 (void) cls; 486 (void)cls;
478 487
479 GNUNET_SCHEDULER_add_shutdown (&do_shutdown, 488 GNUNET_SCHEDULER_add_shutdown(&do_shutdown,
480 NULL);
481 t = GNUNET_SCHEDULER_add_now (&process_queue,
482 NULL); 489 NULL);
490 t = GNUNET_SCHEDULER_add_now(&process_queue,
491 NULL);
483} 492}
484 493
485 494
@@ -489,7 +498,7 @@ run (void *cls)
489 * @param hostname name to resolve 498 * @param hostname name to resolve
490 */ 499 */
491static void 500static void
492queue (const char *hostname) 501queue(const char *hostname)
493{ 502{
494 struct GNUNET_DNSPARSER_Packet p; 503 struct GNUNET_DNSPARSER_Packet p;
495 struct GNUNET_DNSPARSER_Query q; 504 struct GNUNET_DNSPARSER_Query q;
@@ -499,46 +508,46 @@ queue (const char *hostname)
499 int ret; 508 int ret;
500 509
501 if (GNUNET_OK != 510 if (GNUNET_OK !=
502 GNUNET_DNSPARSER_check_name (hostname)) 511 GNUNET_DNSPARSER_check_name(hostname))
503 { 512 {
504 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 513 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
505 "Refusing invalid hostname `%s'\n", 514 "Refusing invalid hostname `%s'\n",
506 hostname); 515 hostname);
507 return; 516 return;
508 } 517 }
509 q.name = (char *) hostname; 518 q.name = (char *)hostname;
510 q.type = GNUNET_DNSPARSER_TYPE_NS; 519 q.type = GNUNET_DNSPARSER_TYPE_NS;
511 q.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; 520 q.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
512 521
513 memset (&p, 522 memset(&p,
514 0, 523 0,
515 sizeof (p)); 524 sizeof(p));
516 p.num_queries = 1; 525 p.num_queries = 1;
517 p.queries = &q; 526 p.queries = &q;
518 p.id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, 527 p.id = (uint16_t)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE,
519 UINT16_MAX); 528 UINT16_MAX);
520 ret = GNUNET_DNSPARSER_pack (&p, 529 ret = GNUNET_DNSPARSER_pack(&p,
521 UINT16_MAX, 530 UINT16_MAX,
522 &raw, 531 &raw,
523 &raw_size); 532 &raw_size);
524 if (GNUNET_OK != ret) 533 if (GNUNET_OK != ret)
525 { 534 {
526 if (GNUNET_NO == ret) 535 if (GNUNET_NO == ret)
527 GNUNET_free (raw); 536 GNUNET_free(raw);
528 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 537 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
529 "Failed to pack query for hostname `%s'\n", 538 "Failed to pack query for hostname `%s'\n",
530 hostname); 539 hostname);
531 return; 540 return;
532 } 541 }
533 542
534 req = GNUNET_new (struct Request); 543 req = GNUNET_new(struct Request);
535 req->hostname = strdup (hostname); 544 req->hostname = strdup(hostname);
536 req->raw = raw; 545 req->raw = raw;
537 req->raw_len = raw_size; 546 req->raw_len = raw_size;
538 req->id = p.id; 547 req->id = p.id;
539 GNUNET_CONTAINER_DLL_insert_tail (req_head, 548 GNUNET_CONTAINER_DLL_insert_tail(req_head,
540 req_tail, 549 req_tail,
541 req); 550 req);
542} 551}
543 552
544 553
@@ -550,50 +559,50 @@ queue (const char *hostname)
550 * @return 0 on success 559 * @return 0 on success
551 */ 560 */
552int 561int
553main (int argc, 562main(int argc,
554 char **argv) 563 char **argv)
555{ 564{
556 char hn[256]; 565 char hn[256];
557 566
558 if (2 != argc) 567 if (2 != argc)
559 { 568 {
560 fprintf (stderr, 569 fprintf(stderr,
561 "Missing required configuration argument\n"); 570 "Missing required configuration argument\n");
562 return -1; 571 return -1;
563 } 572 }
564 ctx = GNUNET_DNSSTUB_start (256); 573 ctx = GNUNET_DNSSTUB_start(256);
565 if (NULL == ctx) 574 if (NULL == ctx)
566 { 575 {
567 fprintf (stderr, 576 fprintf(stderr,
568 "Failed to initialize GNUnet DNS STUB\n"); 577 "Failed to initialize GNUnet DNS STUB\n");
569 return 1; 578 return 1;
570 } 579 }
571 if (GNUNET_OK != 580 if (GNUNET_OK !=
572 GNUNET_DNSSTUB_add_dns_ip (ctx, 581 GNUNET_DNSSTUB_add_dns_ip(ctx,
573 argv[1])) 582 argv[1]))
574 { 583 {
575 fprintf (stderr, 584 fprintf(stderr,
576 "Failed to use `%s' for DNS resolver\n", 585 "Failed to use `%s' for DNS resolver\n",
577 argv[1]); 586 argv[1]);
578 return 1; 587 return 1;
579 } 588 }
580 589
581 while (NULL != 590 while (NULL !=
582 fgets (hn, 591 fgets(hn,
583 sizeof (hn), 592 sizeof(hn),
584 stdin)) 593 stdin))
585 { 594 {
586 if (strlen(hn) > 0) 595 if (strlen(hn) > 0)
587 hn[strlen(hn)-1] = '\0'; /* eat newline */ 596 hn[strlen(hn) - 1] = '\0'; /* eat newline */
588 queue (hn); 597 queue(hn);
589 } 598 }
590 GNUNET_SCHEDULER_run (&run, 599 GNUNET_SCHEDULER_run(&run,
591 NULL); 600 NULL);
592 fprintf (stderr, 601 fprintf(stderr,
593 "Did %u lookups, found %u records, %u lookups failed, %u pending on shutdown\n", 602 "Did %u lookups, found %u records, %u lookups failed, %u pending on shutdown\n",
594 lookups, 603 lookups,
595 records, 604 records,
596 failures, 605 failures,
597 pending); 606 pending);
598 return 0; 607 return 0;
599} 608}