diff options
Diffstat (limited to 'src/dns/gnunet-zonewalk.c')
-rw-r--r-- | src/dns/gnunet-zonewalk.c | 593 |
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 | */ |
34 | struct Request | 34 | struct 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 | */ |
146 | static void | 145 | static void |
147 | process_record (struct Request *req, | 146 | process_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 | */ |
296 | static void | 305 | static void |
297 | process_result (void *cls, | 306 | process_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 | */ |
393 | static int | 402 | static int |
394 | submit_req (struct Request *req) | 403 | submit_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) | |||
428 | static void | 437 | static void |
429 | process_queue(void *cls) | 438 | process_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 | */ |
454 | static void | 463 | static void |
455 | do_shutdown (void *cls) | 464 | do_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 | */ |
474 | static void | 483 | static void |
475 | run (void *cls) | 484 | run(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 | */ |
491 | static void | 500 | static void |
492 | queue (const char *hostname) | 501 | queue(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 | */ |
552 | int | 561 | int |
553 | main (int argc, | 562 | main(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 | } |