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