diff options
Diffstat (limited to 'src/util/dnsstub.c')
-rw-r--r-- | src/util/dnsstub.c | 543 |
1 files changed, 273 insertions, 270 deletions
diff --git a/src/util/dnsstub.c b/src/util/dnsstub.c index fef4b5f5d..1ac274c92 100644 --- a/src/util/dnsstub.c +++ b/src/util/dnsstub.c | |||
@@ -29,7 +29,7 @@ | |||
29 | * Timeout for retrying DNS queries. | 29 | * Timeout for retrying DNS queries. |
30 | */ | 30 | */ |
31 | #define DNS_RETRANSMIT_DELAY \ | 31 | #define DNS_RETRANSMIT_DELAY \ |
32 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 250) | 32 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250) |
33 | 33 | ||
34 | 34 | ||
35 | /** | 35 | /** |
@@ -41,7 +41,8 @@ struct DnsServer; | |||
41 | /** | 41 | /** |
42 | * UDP socket we are using for sending DNS requests to the Internet. | 42 | * UDP socket we are using for sending DNS requests to the Internet. |
43 | */ | 43 | */ |
44 | struct GNUNET_DNSSTUB_RequestSocket { | 44 | struct GNUNET_DNSSTUB_RequestSocket |
45 | { | ||
45 | /** | 46 | /** |
46 | * UDP socket we use for this request for IPv4 | 47 | * UDP socket we use for this request for IPv4 |
47 | */ | 48 | */ |
@@ -97,7 +98,8 @@ struct GNUNET_DNSSTUB_RequestSocket { | |||
97 | /** | 98 | /** |
98 | * DNS Server used for resolution. | 99 | * DNS Server used for resolution. |
99 | */ | 100 | */ |
100 | struct DnsServer { | 101 | struct DnsServer |
102 | { | ||
101 | /** | 103 | /** |
102 | * Kept in a DLL. | 104 | * Kept in a DLL. |
103 | */ | 105 | */ |
@@ -118,7 +120,8 @@ struct DnsServer { | |||
118 | /** | 120 | /** |
119 | * Handle to the stub resolver. | 121 | * Handle to the stub resolver. |
120 | */ | 122 | */ |
121 | struct GNUNET_DNSSTUB_Context { | 123 | struct GNUNET_DNSSTUB_Context |
124 | { | ||
122 | /** | 125 | /** |
123 | * Array of all open sockets for DNS requests. | 126 | * Array of all open sockets for DNS requests. |
124 | */ | 127 | */ |
@@ -152,33 +155,33 @@ struct GNUNET_DNSSTUB_Context { | |||
152 | * @param rs request socket to clean up | 155 | * @param rs request socket to clean up |
153 | */ | 156 | */ |
154 | static void | 157 | static void |
155 | cleanup_rs(struct GNUNET_DNSSTUB_RequestSocket *rs) | 158 | cleanup_rs (struct GNUNET_DNSSTUB_RequestSocket *rs) |
156 | { | 159 | { |
157 | if (NULL != rs->dnsout4) | 160 | if (NULL != rs->dnsout4) |
158 | { | 161 | { |
159 | GNUNET_NETWORK_socket_close(rs->dnsout4); | 162 | GNUNET_NETWORK_socket_close (rs->dnsout4); |
160 | rs->dnsout4 = NULL; | 163 | rs->dnsout4 = NULL; |
161 | } | 164 | } |
162 | if (NULL != rs->dnsout6) | 165 | if (NULL != rs->dnsout6) |
163 | { | 166 | { |
164 | GNUNET_NETWORK_socket_close(rs->dnsout6); | 167 | GNUNET_NETWORK_socket_close (rs->dnsout6); |
165 | rs->dnsout6 = NULL; | 168 | rs->dnsout6 = NULL; |
166 | } | 169 | } |
167 | if (NULL != rs->read_task) | 170 | if (NULL != rs->read_task) |
168 | { | 171 | { |
169 | GNUNET_SCHEDULER_cancel(rs->read_task); | 172 | GNUNET_SCHEDULER_cancel (rs->read_task); |
170 | rs->read_task = NULL; | 173 | rs->read_task = NULL; |
171 | } | 174 | } |
172 | if (NULL != rs->retry_task) | 175 | if (NULL != rs->retry_task) |
173 | { | 176 | { |
174 | GNUNET_SCHEDULER_cancel(rs->retry_task); | 177 | GNUNET_SCHEDULER_cancel (rs->retry_task); |
175 | rs->retry_task = NULL; | 178 | rs->retry_task = NULL; |
176 | } | 179 | } |
177 | if (NULL != rs->request) | 180 | if (NULL != rs->request) |
178 | { | 181 | { |
179 | GNUNET_free(rs->request); | 182 | GNUNET_free (rs->request); |
180 | rs->request = NULL; | 183 | rs->request = NULL; |
181 | } | 184 | } |
182 | } | 185 | } |
183 | 186 | ||
184 | 187 | ||
@@ -189,7 +192,7 @@ cleanup_rs(struct GNUNET_DNSSTUB_RequestSocket *rs) | |||
189 | * @return #GNUNET_OK on success | 192 | * @return #GNUNET_OK on success |
190 | */ | 193 | */ |
191 | static struct GNUNET_NETWORK_Handle * | 194 | static struct GNUNET_NETWORK_Handle * |
192 | open_socket(int af) | 195 | open_socket (int af) |
193 | { | 196 | { |
194 | struct sockaddr_in a4; | 197 | struct sockaddr_in a4; |
195 | struct sockaddr_in6 a6; | 198 | struct sockaddr_in6 a6; |
@@ -197,35 +200,35 @@ open_socket(int af) | |||
197 | socklen_t alen; | 200 | socklen_t alen; |
198 | struct GNUNET_NETWORK_Handle *ret; | 201 | struct GNUNET_NETWORK_Handle *ret; |
199 | 202 | ||
200 | ret = GNUNET_NETWORK_socket_create(af, SOCK_DGRAM, 0); | 203 | ret = GNUNET_NETWORK_socket_create (af, SOCK_DGRAM, 0); |
201 | if (NULL == ret) | 204 | if (NULL == ret) |
202 | return NULL; | 205 | return NULL; |
203 | switch (af) | 206 | switch (af) |
204 | { | 207 | { |
205 | case AF_INET: | 208 | case AF_INET: |
206 | memset(&a4, 0, alen = sizeof(struct sockaddr_in)); | 209 | memset (&a4, 0, alen = sizeof(struct sockaddr_in)); |
207 | sa = (struct sockaddr *)&a4; | 210 | sa = (struct sockaddr *) &a4; |
208 | break; | 211 | break; |
209 | 212 | ||
210 | case AF_INET6: | 213 | case AF_INET6: |
211 | memset(&a6, 0, alen = sizeof(struct sockaddr_in6)); | 214 | memset (&a6, 0, alen = sizeof(struct sockaddr_in6)); |
212 | sa = (struct sockaddr *)&a6; | 215 | sa = (struct sockaddr *) &a6; |
213 | break; | 216 | break; |
214 | 217 | ||
215 | default: | 218 | default: |
216 | GNUNET_break(0); | 219 | GNUNET_break (0); |
217 | GNUNET_NETWORK_socket_close(ret); | 220 | GNUNET_NETWORK_socket_close (ret); |
218 | return NULL; | 221 | return NULL; |
219 | } | 222 | } |
220 | sa->sa_family = af; | 223 | sa->sa_family = af; |
221 | if (GNUNET_OK != GNUNET_NETWORK_socket_bind(ret, sa, alen)) | 224 | if (GNUNET_OK != GNUNET_NETWORK_socket_bind (ret, sa, alen)) |
222 | { | 225 | { |
223 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 226 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
224 | _("Could not bind to any port: %s\n"), | 227 | _ ("Could not bind to any port: %s\n"), |
225 | strerror(errno)); | 228 | strerror (errno)); |
226 | GNUNET_NETWORK_socket_close(ret); | 229 | GNUNET_NETWORK_socket_close (ret); |
227 | return NULL; | 230 | return NULL; |
228 | } | 231 | } |
229 | return ret; | 232 | return ret; |
230 | } | 233 | } |
231 | 234 | ||
@@ -238,38 +241,38 @@ open_socket(int af) | |||
238 | * @return NULL on error | 241 | * @return NULL on error |
239 | */ | 242 | */ |
240 | static struct GNUNET_DNSSTUB_RequestSocket * | 243 | static struct GNUNET_DNSSTUB_RequestSocket * |
241 | get_request_socket(struct GNUNET_DNSSTUB_Context *ctx) | 244 | get_request_socket (struct GNUNET_DNSSTUB_Context *ctx) |
242 | { | 245 | { |
243 | struct GNUNET_DNSSTUB_RequestSocket *rs; | 246 | struct GNUNET_DNSSTUB_RequestSocket *rs; |
244 | 247 | ||
245 | for (unsigned int i = 0; i < 256; i++) | 248 | for (unsigned int i = 0; i < 256; i++) |
246 | { | 249 | { |
247 | rs = &ctx->sockets[GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, | 250 | rs = &ctx->sockets[GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, |
248 | ctx->num_sockets)]; | 251 | ctx->num_sockets)]; |
249 | if (NULL == rs->rc) | 252 | if (NULL == rs->rc) |
250 | break; | 253 | break; |
251 | } | 254 | } |
252 | if (NULL != rs->rc) | 255 | if (NULL != rs->rc) |
253 | { | 256 | { |
254 | /* signal "failure" */ | 257 | /* signal "failure" */ |
255 | rs->rc(rs->rc_cls, NULL, 0); | 258 | rs->rc (rs->rc_cls, NULL, 0); |
256 | rs->rc = NULL; | 259 | rs->rc = NULL; |
257 | } | 260 | } |
258 | if (NULL != rs->read_task) | 261 | if (NULL != rs->read_task) |
259 | { | 262 | { |
260 | GNUNET_SCHEDULER_cancel(rs->read_task); | 263 | GNUNET_SCHEDULER_cancel (rs->read_task); |
261 | rs->read_task = NULL; | 264 | rs->read_task = NULL; |
262 | } | 265 | } |
263 | if (NULL != rs->retry_task) | 266 | if (NULL != rs->retry_task) |
264 | { | 267 | { |
265 | GNUNET_SCHEDULER_cancel(rs->retry_task); | 268 | GNUNET_SCHEDULER_cancel (rs->retry_task); |
266 | rs->retry_task = NULL; | 269 | rs->retry_task = NULL; |
267 | } | 270 | } |
268 | if (NULL != rs->request) | 271 | if (NULL != rs->request) |
269 | { | 272 | { |
270 | GNUNET_free(rs->request); | 273 | GNUNET_free (rs->request); |
271 | rs->request = NULL; | 274 | rs->request = NULL; |
272 | } | 275 | } |
273 | rs->ctx = ctx; | 276 | rs->ctx = ctx; |
274 | return rs; | 277 | return rs; |
275 | } | 278 | } |
@@ -284,20 +287,20 @@ get_request_socket(struct GNUNET_DNSSTUB_Context *ctx) | |||
284 | * @return #GNUNET_OK on success, #GNUNET_NO on drop, #GNUNET_SYSERR on IO-errors (closed socket) | 287 | * @return #GNUNET_OK on success, #GNUNET_NO on drop, #GNUNET_SYSERR on IO-errors (closed socket) |
285 | */ | 288 | */ |
286 | static int | 289 | static int |
287 | do_dns_read(struct GNUNET_DNSSTUB_RequestSocket *rs, | 290 | do_dns_read (struct GNUNET_DNSSTUB_RequestSocket *rs, |
288 | struct GNUNET_NETWORK_Handle *dnsout) | 291 | struct GNUNET_NETWORK_Handle *dnsout) |
289 | { | 292 | { |
290 | struct GNUNET_DNSSTUB_Context *ctx = rs->ctx; | 293 | struct GNUNET_DNSSTUB_Context *ctx = rs->ctx; |
291 | ssize_t r; | 294 | ssize_t r; |
292 | int len; | 295 | int len; |
293 | 296 | ||
294 | if (0 != ioctl(GNUNET_NETWORK_get_fd(dnsout), FIONREAD, &len)) | 297 | if (0 != ioctl (GNUNET_NETWORK_get_fd (dnsout), FIONREAD, &len)) |
295 | { | 298 | { |
296 | /* conservative choice: */ | 299 | /* conservative choice: */ |
297 | len = UINT16_MAX; | 300 | len = UINT16_MAX; |
298 | } | 301 | } |
299 | 302 | ||
300 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Receiving %d byte DNS reply\n", len); | 303 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving %d byte DNS reply\n", len); |
301 | { | 304 | { |
302 | unsigned char buf[len] GNUNET_ALIGN; | 305 | unsigned char buf[len] GNUNET_ALIGN; |
303 | int found; | 306 | int found; |
@@ -306,50 +309,50 @@ do_dns_read(struct GNUNET_DNSSTUB_RequestSocket *rs, | |||
306 | struct GNUNET_TUN_DnsHeader *dns; | 309 | struct GNUNET_TUN_DnsHeader *dns; |
307 | 310 | ||
308 | addrlen = sizeof(addr); | 311 | addrlen = sizeof(addr); |
309 | memset(&addr, 0, sizeof(addr)); | 312 | memset (&addr, 0, sizeof(addr)); |
310 | r = GNUNET_NETWORK_socket_recvfrom(dnsout, | 313 | r = GNUNET_NETWORK_socket_recvfrom (dnsout, |
311 | buf, | 314 | buf, |
312 | sizeof(buf), | 315 | sizeof(buf), |
313 | (struct sockaddr *)&addr, | 316 | (struct sockaddr *) &addr, |
314 | &addrlen); | 317 | &addrlen); |
315 | if (-1 == r) | 318 | if (-1 == r) |
316 | { | 319 | { |
317 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "recvfrom"); | 320 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "recvfrom"); |
318 | GNUNET_NETWORK_socket_close(dnsout); | 321 | GNUNET_NETWORK_socket_close (dnsout); |
319 | return GNUNET_SYSERR; | 322 | return GNUNET_SYSERR; |
320 | } | 323 | } |
321 | found = GNUNET_NO; | 324 | found = GNUNET_NO; |
322 | for (struct DnsServer *ds = ctx->dns_head; NULL != ds; ds = ds->next) | 325 | for (struct DnsServer *ds = ctx->dns_head; NULL != ds; ds = ds->next) |
326 | { | ||
327 | if (0 == memcmp (&addr, | ||
328 | &ds->ss, | ||
329 | GNUNET_MIN (sizeof(struct sockaddr_storage), addrlen))) | ||
323 | { | 330 | { |
324 | if (0 == memcmp(&addr, | 331 | found = GNUNET_YES; |
325 | &ds->ss, | 332 | break; |
326 | GNUNET_MIN(sizeof(struct sockaddr_storage), addrlen))) | ||
327 | { | ||
328 | found = GNUNET_YES; | ||
329 | break; | ||
330 | } | ||
331 | } | 333 | } |
334 | } | ||
332 | if (GNUNET_NO == found) | 335 | if (GNUNET_NO == found) |
333 | { | 336 | { |
334 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 337 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
335 | "Received DNS response from server we never asked (ignored)"); | 338 | "Received DNS response from server we never asked (ignored)"); |
336 | return GNUNET_NO; | 339 | return GNUNET_NO; |
337 | } | 340 | } |
338 | if (sizeof(struct GNUNET_TUN_DnsHeader) > (size_t)r) | 341 | if (sizeof(struct GNUNET_TUN_DnsHeader) > (size_t) r) |
339 | { | 342 | { |
340 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 343 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
341 | _("Received DNS response that is too small (%u bytes)"), | 344 | _ ("Received DNS response that is too small (%u bytes)"), |
342 | (unsigned int)r); | 345 | (unsigned int) r); |
343 | return GNUNET_NO; | 346 | return GNUNET_NO; |
344 | } | 347 | } |
345 | dns = (struct GNUNET_TUN_DnsHeader *)buf; | 348 | dns = (struct GNUNET_TUN_DnsHeader *) buf; |
346 | if (NULL == rs->rc) | 349 | if (NULL == rs->rc) |
347 | { | 350 | { |
348 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 351 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
349 | "Request timeout or cancelled; ignoring reply\n"); | 352 | "Request timeout or cancelled; ignoring reply\n"); |
350 | return GNUNET_NO; | 353 | return GNUNET_NO; |
351 | } | 354 | } |
352 | rs->rc(rs->rc_cls, dns, r); | 355 | rs->rc (rs->rc_cls, dns, r); |
353 | } | 356 | } |
354 | return GNUNET_OK; | 357 | return GNUNET_OK; |
355 | } | 358 | } |
@@ -361,7 +364,7 @@ do_dns_read(struct GNUNET_DNSSTUB_RequestSocket *rs, | |||
361 | * @param cls socket to read from | 364 | * @param cls socket to read from |
362 | */ | 365 | */ |
363 | static void | 366 | static void |
364 | read_response(void *cls); | 367 | read_response (void *cls); |
365 | 368 | ||
366 | 369 | ||
367 | /** | 370 | /** |
@@ -370,25 +373,25 @@ read_response(void *cls); | |||
370 | * @param rs request to schedule read operation for | 373 | * @param rs request to schedule read operation for |
371 | */ | 374 | */ |
372 | static void | 375 | static void |
373 | schedule_read(struct GNUNET_DNSSTUB_RequestSocket *rs) | 376 | schedule_read (struct GNUNET_DNSSTUB_RequestSocket *rs) |
374 | { | 377 | { |
375 | struct GNUNET_NETWORK_FDSet *rset; | 378 | struct GNUNET_NETWORK_FDSet *rset; |
376 | 379 | ||
377 | if (NULL != rs->read_task) | 380 | if (NULL != rs->read_task) |
378 | GNUNET_SCHEDULER_cancel(rs->read_task); | 381 | GNUNET_SCHEDULER_cancel (rs->read_task); |
379 | rset = GNUNET_NETWORK_fdset_create(); | 382 | rset = GNUNET_NETWORK_fdset_create (); |
380 | if (NULL != rs->dnsout4) | 383 | if (NULL != rs->dnsout4) |
381 | GNUNET_NETWORK_fdset_set(rset, rs->dnsout4); | 384 | GNUNET_NETWORK_fdset_set (rset, rs->dnsout4); |
382 | if (NULL != rs->dnsout6) | 385 | if (NULL != rs->dnsout6) |
383 | GNUNET_NETWORK_fdset_set(rset, rs->dnsout6); | 386 | GNUNET_NETWORK_fdset_set (rset, rs->dnsout6); |
384 | rs->read_task = | 387 | rs->read_task = |
385 | GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_DEFAULT, | 388 | GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, |
386 | GNUNET_TIME_UNIT_FOREVER_REL, | 389 | GNUNET_TIME_UNIT_FOREVER_REL, |
387 | rset, | 390 | rset, |
388 | NULL, | 391 | NULL, |
389 | &read_response, | 392 | &read_response, |
390 | rs); | 393 | rs); |
391 | GNUNET_NETWORK_fdset_destroy(rset); | 394 | GNUNET_NETWORK_fdset_destroy (rset); |
392 | } | 395 | } |
393 | 396 | ||
394 | 397 | ||
@@ -398,24 +401,24 @@ schedule_read(struct GNUNET_DNSSTUB_RequestSocket *rs) | |||
398 | * @param cls `struct GNUNET_DNSSTUB_RequestSocket` to read from | 401 | * @param cls `struct GNUNET_DNSSTUB_RequestSocket` to read from |
399 | */ | 402 | */ |
400 | static void | 403 | static void |
401 | read_response(void *cls) | 404 | read_response (void *cls) |
402 | { | 405 | { |
403 | struct GNUNET_DNSSTUB_RequestSocket *rs = cls; | 406 | struct GNUNET_DNSSTUB_RequestSocket *rs = cls; |
404 | const struct GNUNET_SCHEDULER_TaskContext *tc; | 407 | const struct GNUNET_SCHEDULER_TaskContext *tc; |
405 | 408 | ||
406 | rs->read_task = NULL; | 409 | rs->read_task = NULL; |
407 | tc = GNUNET_SCHEDULER_get_task_context(); | 410 | tc = GNUNET_SCHEDULER_get_task_context (); |
408 | /* read and process ready sockets */ | 411 | /* read and process ready sockets */ |
409 | if ((NULL != rs->dnsout4) && | 412 | if ((NULL != rs->dnsout4) && |
410 | (GNUNET_NETWORK_fdset_isset(tc->read_ready, rs->dnsout4)) && | 413 | (GNUNET_NETWORK_fdset_isset (tc->read_ready, rs->dnsout4)) && |
411 | (GNUNET_SYSERR == do_dns_read(rs, rs->dnsout4))) | 414 | (GNUNET_SYSERR == do_dns_read (rs, rs->dnsout4))) |
412 | rs->dnsout4 = NULL; | 415 | rs->dnsout4 = NULL; |
413 | if ((NULL != rs->dnsout6) && | 416 | if ((NULL != rs->dnsout6) && |
414 | (GNUNET_NETWORK_fdset_isset(tc->read_ready, rs->dnsout6)) && | 417 | (GNUNET_NETWORK_fdset_isset (tc->read_ready, rs->dnsout6)) && |
415 | (GNUNET_SYSERR == do_dns_read(rs, rs->dnsout6))) | 418 | (GNUNET_SYSERR == do_dns_read (rs, rs->dnsout6))) |
416 | rs->dnsout6 = NULL; | 419 | rs->dnsout6 = NULL; |
417 | /* re-schedule read task */ | 420 | /* re-schedule read task */ |
418 | schedule_read(rs); | 421 | schedule_read (rs); |
419 | } | 422 | } |
420 | 423 | ||
421 | 424 | ||
@@ -426,7 +429,7 @@ read_response(void *cls) | |||
426 | * @param cls our `struct GNUNET_DNSSTUB_RequestSocket *` | 429 | * @param cls our `struct GNUNET_DNSSTUB_RequestSocket *` |
427 | */ | 430 | */ |
428 | static void | 431 | static void |
429 | transmit_query(void *cls) | 432 | transmit_query (void *cls) |
430 | { | 433 | { |
431 | struct GNUNET_DNSSTUB_RequestSocket *rs = cls; | 434 | struct GNUNET_DNSSTUB_RequestSocket *rs = cls; |
432 | struct GNUNET_DNSSTUB_Context *ctx = rs->ctx; | 435 | struct GNUNET_DNSSTUB_Context *ctx = rs->ctx; |
@@ -436,54 +439,54 @@ transmit_query(void *cls) | |||
436 | struct GNUNET_NETWORK_Handle *dnsout; | 439 | struct GNUNET_NETWORK_Handle *dnsout; |
437 | 440 | ||
438 | rs->retry_task = | 441 | rs->retry_task = |
439 | GNUNET_SCHEDULER_add_delayed(ctx->retry_freq, &transmit_query, rs); | 442 | GNUNET_SCHEDULER_add_delayed (ctx->retry_freq, &transmit_query, rs); |
440 | ds = rs->ds_pos; | 443 | ds = rs->ds_pos; |
441 | rs->ds_pos = ds->next; | 444 | rs->ds_pos = ds->next; |
442 | if (NULL == rs->ds_pos) | 445 | if (NULL == rs->ds_pos) |
443 | rs->ds_pos = ctx->dns_head; | 446 | rs->ds_pos = ctx->dns_head; |
444 | GNUNET_assert(NULL != ds); | 447 | GNUNET_assert (NULL != ds); |
445 | dnsout = NULL; | 448 | dnsout = NULL; |
446 | switch (ds->ss.ss_family) | 449 | switch (ds->ss.ss_family) |
447 | { | 450 | { |
448 | case AF_INET: | 451 | case AF_INET: |
449 | if (NULL == rs->dnsout4) | 452 | if (NULL == rs->dnsout4) |
450 | rs->dnsout4 = open_socket(AF_INET); | 453 | rs->dnsout4 = open_socket (AF_INET); |
451 | dnsout = rs->dnsout4; | 454 | dnsout = rs->dnsout4; |
452 | sa = (const struct sockaddr *)&ds->ss; | 455 | sa = (const struct sockaddr *) &ds->ss; |
453 | salen = sizeof(struct sockaddr_in); | 456 | salen = sizeof(struct sockaddr_in); |
454 | break; | 457 | break; |
455 | 458 | ||
456 | case AF_INET6: | 459 | case AF_INET6: |
457 | if (NULL == rs->dnsout6) | 460 | if (NULL == rs->dnsout6) |
458 | rs->dnsout6 = open_socket(AF_INET6); | 461 | rs->dnsout6 = open_socket (AF_INET6); |
459 | dnsout = rs->dnsout6; | 462 | dnsout = rs->dnsout6; |
460 | sa = (const struct sockaddr *)&ds->ss; | 463 | sa = (const struct sockaddr *) &ds->ss; |
461 | salen = sizeof(struct sockaddr_in6); | 464 | salen = sizeof(struct sockaddr_in6); |
462 | break; | 465 | break; |
463 | 466 | ||
464 | default: | 467 | default: |
465 | return; | 468 | return; |
466 | } | 469 | } |
467 | if (NULL == dnsout) | 470 | if (NULL == dnsout) |
468 | { | 471 | { |
469 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 472 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
470 | "Unable to use configure DNS server, skipping\n"); | 473 | "Unable to use configure DNS server, skipping\n"); |
471 | return; | 474 | return; |
472 | } | 475 | } |
473 | if (GNUNET_SYSERR == GNUNET_NETWORK_socket_sendto(dnsout, | 476 | if (GNUNET_SYSERR == GNUNET_NETWORK_socket_sendto (dnsout, |
474 | rs->request, | 477 | rs->request, |
475 | rs->request_len, | 478 | rs->request_len, |
476 | sa, | 479 | sa, |
477 | salen)) | 480 | salen)) |
478 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 481 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
479 | _("Failed to send DNS request to %s: %s\n"), | 482 | _ ("Failed to send DNS request to %s: %s\n"), |
480 | GNUNET_a2s(sa, salen), | 483 | GNUNET_a2s (sa, salen), |
481 | strerror(errno)); | 484 | strerror (errno)); |
482 | else | 485 | else |
483 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 486 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
484 | _("Sent DNS request to %s\n"), | 487 | _ ("Sent DNS request to %s\n"), |
485 | GNUNET_a2s(sa, salen)); | 488 | GNUNET_a2s (sa, salen)); |
486 | schedule_read(rs); | 489 | schedule_read (rs); |
487 | } | 490 | } |
488 | 491 | ||
489 | 492 | ||
@@ -498,32 +501,32 @@ transmit_query(void *cls) | |||
498 | * @return socket used for the request, NULL on error | 501 | * @return socket used for the request, NULL on error |
499 | */ | 502 | */ |
500 | struct GNUNET_DNSSTUB_RequestSocket * | 503 | struct GNUNET_DNSSTUB_RequestSocket * |
501 | GNUNET_DNSSTUB_resolve(struct GNUNET_DNSSTUB_Context *ctx, | 504 | GNUNET_DNSSTUB_resolve (struct GNUNET_DNSSTUB_Context *ctx, |
502 | const void *request, | 505 | const void *request, |
503 | size_t request_len, | 506 | size_t request_len, |
504 | GNUNET_DNSSTUB_ResultCallback rc, | 507 | GNUNET_DNSSTUB_ResultCallback rc, |
505 | void *rc_cls) | 508 | void *rc_cls) |
506 | { | 509 | { |
507 | struct GNUNET_DNSSTUB_RequestSocket *rs; | 510 | struct GNUNET_DNSSTUB_RequestSocket *rs; |
508 | 511 | ||
509 | if (NULL == ctx->dns_head) | 512 | if (NULL == ctx->dns_head) |
510 | { | 513 | { |
511 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 514 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
512 | "No DNS server configured for resolution\n"); | 515 | "No DNS server configured for resolution\n"); |
513 | return NULL; | 516 | return NULL; |
514 | } | 517 | } |
515 | if (NULL == (rs = get_request_socket(ctx))) | 518 | if (NULL == (rs = get_request_socket (ctx))) |
516 | { | 519 | { |
517 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 520 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
518 | "No request socket available for DNS resolution\n"); | 521 | "No request socket available for DNS resolution\n"); |
519 | return NULL; | 522 | return NULL; |
520 | } | 523 | } |
521 | rs->ds_pos = ctx->dns_head; | 524 | rs->ds_pos = ctx->dns_head; |
522 | rs->rc = rc; | 525 | rs->rc = rc; |
523 | rs->rc_cls = rc_cls; | 526 | rs->rc_cls = rc_cls; |
524 | rs->request = GNUNET_memdup(request, request_len); | 527 | rs->request = GNUNET_memdup (request, request_len); |
525 | rs->request_len = request_len; | 528 | rs->request_len = request_len; |
526 | rs->retry_task = GNUNET_SCHEDULER_add_now(&transmit_query, rs); | 529 | rs->retry_task = GNUNET_SCHEDULER_add_now (&transmit_query, rs); |
527 | return rs; | 530 | return rs; |
528 | } | 531 | } |
529 | 532 | ||
@@ -534,19 +537,19 @@ GNUNET_DNSSTUB_resolve(struct GNUNET_DNSSTUB_Context *ctx, | |||
534 | * @param rs resolution to cancel | 537 | * @param rs resolution to cancel |
535 | */ | 538 | */ |
536 | void | 539 | void |
537 | GNUNET_DNSSTUB_resolve_cancel(struct GNUNET_DNSSTUB_RequestSocket *rs) | 540 | GNUNET_DNSSTUB_resolve_cancel (struct GNUNET_DNSSTUB_RequestSocket *rs) |
538 | { | 541 | { |
539 | rs->rc = NULL; | 542 | rs->rc = NULL; |
540 | if (NULL != rs->retry_task) | 543 | if (NULL != rs->retry_task) |
541 | { | 544 | { |
542 | GNUNET_SCHEDULER_cancel(rs->retry_task); | 545 | GNUNET_SCHEDULER_cancel (rs->retry_task); |
543 | rs->retry_task = NULL; | 546 | rs->retry_task = NULL; |
544 | } | 547 | } |
545 | if (NULL != rs->read_task) | 548 | if (NULL != rs->read_task) |
546 | { | 549 | { |
547 | GNUNET_SCHEDULER_cancel(rs->read_task); | 550 | GNUNET_SCHEDULER_cancel (rs->read_task); |
548 | rs->read_task = NULL; | 551 | rs->read_task = NULL; |
549 | } | 552 | } |
550 | } | 553 | } |
551 | 554 | ||
552 | 555 | ||
@@ -558,19 +561,19 @@ GNUNET_DNSSTUB_resolve_cancel(struct GNUNET_DNSSTUB_RequestSocket *rs) | |||
558 | * @return NULL on error | 561 | * @return NULL on error |
559 | */ | 562 | */ |
560 | struct GNUNET_DNSSTUB_Context * | 563 | struct GNUNET_DNSSTUB_Context * |
561 | GNUNET_DNSSTUB_start(unsigned int num_sockets) | 564 | GNUNET_DNSSTUB_start (unsigned int num_sockets) |
562 | { | 565 | { |
563 | struct GNUNET_DNSSTUB_Context *ctx; | 566 | struct GNUNET_DNSSTUB_Context *ctx; |
564 | 567 | ||
565 | if (0 == num_sockets) | 568 | if (0 == num_sockets) |
566 | { | 569 | { |
567 | GNUNET_break(0); | 570 | GNUNET_break (0); |
568 | return NULL; | 571 | return NULL; |
569 | } | 572 | } |
570 | ctx = GNUNET_new(struct GNUNET_DNSSTUB_Context); | 573 | ctx = GNUNET_new (struct GNUNET_DNSSTUB_Context); |
571 | ctx->num_sockets = num_sockets; | 574 | ctx->num_sockets = num_sockets; |
572 | ctx->sockets = | 575 | ctx->sockets = |
573 | GNUNET_new_array(num_sockets, struct GNUNET_DNSSTUB_RequestSocket); | 576 | GNUNET_new_array (num_sockets, struct GNUNET_DNSSTUB_RequestSocket); |
574 | ctx->retry_freq = DNS_RETRANSMIT_DELAY; | 577 | ctx->retry_freq = DNS_RETRANSMIT_DELAY; |
575 | return ctx; | 578 | return ctx; |
576 | } | 579 | } |
@@ -585,45 +588,45 @@ GNUNET_DNSSTUB_start(unsigned int num_sockets) | |||
585 | * @return #GNUNET_OK on success | 588 | * @return #GNUNET_OK on success |
586 | */ | 589 | */ |
587 | int | 590 | int |
588 | GNUNET_DNSSTUB_add_dns_ip(struct GNUNET_DNSSTUB_Context *ctx, | 591 | GNUNET_DNSSTUB_add_dns_ip (struct GNUNET_DNSSTUB_Context *ctx, |
589 | const char *dns_ip) | 592 | const char *dns_ip) |
590 | { | 593 | { |
591 | struct DnsServer *ds; | 594 | struct DnsServer *ds; |
592 | struct in_addr i4; | 595 | struct in_addr i4; |
593 | struct in6_addr i6; | 596 | struct in6_addr i6; |
594 | 597 | ||
595 | ds = GNUNET_new(struct DnsServer); | 598 | ds = GNUNET_new (struct DnsServer); |
596 | if (1 == inet_pton(AF_INET, dns_ip, &i4)) | 599 | if (1 == inet_pton (AF_INET, dns_ip, &i4)) |
597 | { | 600 | { |
598 | struct sockaddr_in *s4 = (struct sockaddr_in *)&ds->ss; | 601 | struct sockaddr_in *s4 = (struct sockaddr_in *) &ds->ss; |
599 | 602 | ||
600 | s4->sin_family = AF_INET; | 603 | s4->sin_family = AF_INET; |
601 | s4->sin_port = htons(53); | 604 | s4->sin_port = htons (53); |
602 | s4->sin_addr = i4; | 605 | s4->sin_addr = i4; |
603 | #if HAVE_SOCKADDR_IN_SIN_LEN | 606 | #if HAVE_SOCKADDR_IN_SIN_LEN |
604 | s4->sin_len = (u_char)sizeof(struct sockaddr_in); | 607 | s4->sin_len = (u_char) sizeof(struct sockaddr_in); |
605 | #endif | 608 | #endif |
606 | } | 609 | } |
607 | else if (1 == inet_pton(AF_INET6, dns_ip, &i6)) | 610 | else if (1 == inet_pton (AF_INET6, dns_ip, &i6)) |
608 | { | 611 | { |
609 | struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)&ds->ss; | 612 | struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) &ds->ss; |
610 | 613 | ||
611 | s6->sin6_family = AF_INET6; | 614 | s6->sin6_family = AF_INET6; |
612 | s6->sin6_port = htons(53); | 615 | s6->sin6_port = htons (53); |
613 | s6->sin6_addr = i6; | 616 | s6->sin6_addr = i6; |
614 | #if HAVE_SOCKADDR_IN_SIN_LEN | 617 | #if HAVE_SOCKADDR_IN_SIN_LEN |
615 | s6->sin6_len = (u_char)sizeof(struct sockaddr_in6); | 618 | s6->sin6_len = (u_char) sizeof(struct sockaddr_in6); |
616 | #endif | 619 | #endif |
617 | } | 620 | } |
618 | else | 621 | else |
619 | { | 622 | { |
620 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 623 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
621 | "Malformed IP address `%s' for DNS server\n", | 624 | "Malformed IP address `%s' for DNS server\n", |
622 | dns_ip); | 625 | dns_ip); |
623 | GNUNET_free(ds); | 626 | GNUNET_free (ds); |
624 | return GNUNET_SYSERR; | 627 | return GNUNET_SYSERR; |
625 | } | 628 | } |
626 | GNUNET_CONTAINER_DLL_insert(ctx->dns_head, ctx->dns_tail, ds); | 629 | GNUNET_CONTAINER_DLL_insert (ctx->dns_head, ctx->dns_tail, ds); |
627 | return GNUNET_OK; | 630 | return GNUNET_OK; |
628 | } | 631 | } |
629 | 632 | ||
@@ -637,28 +640,28 @@ GNUNET_DNSSTUB_add_dns_ip(struct GNUNET_DNSSTUB_Context *ctx, | |||
637 | * @return #GNUNET_OK on success | 640 | * @return #GNUNET_OK on success |
638 | */ | 641 | */ |
639 | int | 642 | int |
640 | GNUNET_DNSSTUB_add_dns_sa(struct GNUNET_DNSSTUB_Context *ctx, | 643 | GNUNET_DNSSTUB_add_dns_sa (struct GNUNET_DNSSTUB_Context *ctx, |
641 | const struct sockaddr *sa) | 644 | const struct sockaddr *sa) |
642 | { | 645 | { |
643 | struct DnsServer *ds; | 646 | struct DnsServer *ds; |
644 | 647 | ||
645 | ds = GNUNET_new(struct DnsServer); | 648 | ds = GNUNET_new (struct DnsServer); |
646 | switch (sa->sa_family) | 649 | switch (sa->sa_family) |
647 | { | 650 | { |
648 | case AF_INET: | 651 | case AF_INET: |
649 | GNUNET_memcpy(&ds->ss, sa, sizeof(struct sockaddr_in)); | 652 | GNUNET_memcpy (&ds->ss, sa, sizeof(struct sockaddr_in)); |
650 | break; | 653 | break; |
651 | 654 | ||
652 | case AF_INET6: | 655 | case AF_INET6: |
653 | GNUNET_memcpy(&ds->ss, sa, sizeof(struct sockaddr_in6)); | 656 | GNUNET_memcpy (&ds->ss, sa, sizeof(struct sockaddr_in6)); |
654 | break; | 657 | break; |
655 | 658 | ||
656 | default: | 659 | default: |
657 | GNUNET_break(0); | 660 | GNUNET_break (0); |
658 | GNUNET_free(ds); | 661 | GNUNET_free (ds); |
659 | return GNUNET_SYSERR; | 662 | return GNUNET_SYSERR; |
660 | } | 663 | } |
661 | GNUNET_CONTAINER_DLL_insert(ctx->dns_head, ctx->dns_tail, ds); | 664 | GNUNET_CONTAINER_DLL_insert (ctx->dns_head, ctx->dns_tail, ds); |
662 | return GNUNET_OK; | 665 | return GNUNET_OK; |
663 | } | 666 | } |
664 | 667 | ||
@@ -671,8 +674,8 @@ GNUNET_DNSSTUB_add_dns_sa(struct GNUNET_DNSSTUB_Context *ctx, | |||
671 | * @param retry_freq how long to wait between retries | 674 | * @param retry_freq how long to wait between retries |
672 | */ | 675 | */ |
673 | void | 676 | void |
674 | GNUNET_DNSSTUB_set_retry(struct GNUNET_DNSSTUB_Context *ctx, | 677 | GNUNET_DNSSTUB_set_retry (struct GNUNET_DNSSTUB_Context *ctx, |
675 | struct GNUNET_TIME_Relative retry_freq) | 678 | struct GNUNET_TIME_Relative retry_freq) |
676 | { | 679 | { |
677 | ctx->retry_freq = retry_freq; | 680 | ctx->retry_freq = retry_freq; |
678 | } | 681 | } |
@@ -684,19 +687,19 @@ GNUNET_DNSSTUB_set_retry(struct GNUNET_DNSSTUB_Context *ctx, | |||
684 | * @param ctx stub resolver to clean up | 687 | * @param ctx stub resolver to clean up |
685 | */ | 688 | */ |
686 | void | 689 | void |
687 | GNUNET_DNSSTUB_stop(struct GNUNET_DNSSTUB_Context *ctx) | 690 | GNUNET_DNSSTUB_stop (struct GNUNET_DNSSTUB_Context *ctx) |
688 | { | 691 | { |
689 | struct DnsServer *ds; | 692 | struct DnsServer *ds; |
690 | 693 | ||
691 | while (NULL != (ds = ctx->dns_head)) | 694 | while (NULL != (ds = ctx->dns_head)) |
692 | { | 695 | { |
693 | GNUNET_CONTAINER_DLL_remove(ctx->dns_head, ctx->dns_tail, ds); | 696 | GNUNET_CONTAINER_DLL_remove (ctx->dns_head, ctx->dns_tail, ds); |
694 | GNUNET_free(ds); | 697 | GNUNET_free (ds); |
695 | } | 698 | } |
696 | for (unsigned int i = 0; i < ctx->num_sockets; i++) | 699 | for (unsigned int i = 0; i < ctx->num_sockets; i++) |
697 | cleanup_rs(&ctx->sockets[i]); | 700 | cleanup_rs (&ctx->sockets[i]); |
698 | GNUNET_free(ctx->sockets); | 701 | GNUNET_free (ctx->sockets); |
699 | GNUNET_free(ctx); | 702 | GNUNET_free (ctx); |
700 | } | 703 | } |
701 | 704 | ||
702 | 705 | ||