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