diff options
Diffstat (limited to 'src/hostlist/hostlist-server.c')
-rw-r--r-- | src/hostlist/hostlist-server.c | 570 |
1 files changed, 268 insertions, 302 deletions
diff --git a/src/hostlist/hostlist-server.c b/src/hostlist/hostlist-server.c index c8e17f33a..e30b3c1e0 100644 --- a/src/hostlist/hostlist-server.c +++ b/src/hostlist/hostlist-server.c | |||
@@ -51,7 +51,7 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg; | |||
51 | 51 | ||
52 | /** | 52 | /** |
53 | * For keeping statistics. | 53 | * For keeping statistics. |
54 | */ | 54 | */ |
55 | static struct GNUNET_STATISTICS_Handle *stats; | 55 | static struct GNUNET_STATISTICS_Handle *stats; |
56 | 56 | ||
57 | /** | 57 | /** |
@@ -107,7 +107,7 @@ static int advertising; | |||
107 | /** | 107 | /** |
108 | * Buffer for the hostlist address | 108 | * Buffer for the hostlist address |
109 | */ | 109 | */ |
110 | static char * hostlist_uri; | 110 | static char *hostlist_uri; |
111 | 111 | ||
112 | 112 | ||
113 | /** | 113 | /** |
@@ -125,16 +125,14 @@ finish_response (struct HostSet *results) | |||
125 | #endif | 125 | #endif |
126 | response = MHD_create_response_from_data (results->size, | 126 | response = MHD_create_response_from_data (results->size, |
127 | results->data, MHD_YES, MHD_NO); | 127 | results->data, MHD_YES, MHD_NO); |
128 | if ( (daemon_handle_v4 == NULL) && | 128 | if ((daemon_handle_v4 == NULL) && (daemon_handle_v6 == NULL)) |
129 | (daemon_handle_v6 == NULL) ) | ||
130 | { | 129 | { |
131 | MHD_destroy_response (response); | 130 | MHD_destroy_response (response); |
132 | response = NULL; | 131 | response = NULL; |
133 | } | 132 | } |
134 | GNUNET_STATISTICS_set (stats, | 133 | GNUNET_STATISTICS_set (stats, |
135 | gettext_noop("bytes in hostlist"), | 134 | gettext_noop ("bytes in hostlist"), |
136 | results->size, | 135 | results->size, GNUNET_YES); |
137 | GNUNET_YES); | ||
138 | GNUNET_free (results); | 136 | GNUNET_free (results); |
139 | } | 137 | } |
140 | 138 | ||
@@ -151,21 +149,19 @@ finish_response (struct HostSet *results) | |||
151 | */ | 149 | */ |
152 | static int | 150 | static int |
153 | check_has_addr (void *cls, | 151 | check_has_addr (void *cls, |
154 | const char *tname, | 152 | const char *tname, |
155 | struct GNUNET_TIME_Absolute expiration, | 153 | struct GNUNET_TIME_Absolute expiration, |
156 | const void *addr, | 154 | const void *addr, uint16_t addrlen) |
157 | uint16_t addrlen) | ||
158 | { | 155 | { |
159 | int *arg = cls; | 156 | int *arg = cls; |
160 | 157 | ||
161 | if (GNUNET_TIME_absolute_get_remaining (expiration).rel_value == 0) | 158 | if (GNUNET_TIME_absolute_get_remaining (expiration).rel_value == 0) |
162 | { | 159 | { |
163 | GNUNET_STATISTICS_update (stats, | 160 | GNUNET_STATISTICS_update (stats, |
164 | gettext_noop("expired addresses encountered"), | 161 | gettext_noop ("expired addresses encountered"), |
165 | 1, | 162 | 1, GNUNET_YES); |
166 | GNUNET_YES); | 163 | return GNUNET_YES; /* ignore this address */ |
167 | return GNUNET_YES; /* ignore this address */ | 164 | } |
168 | } | ||
169 | *arg = GNUNET_YES; | 165 | *arg = GNUNET_YES; |
170 | return GNUNET_SYSERR; | 166 | return GNUNET_SYSERR; |
171 | } | 167 | } |
@@ -177,74 +173,66 @@ check_has_addr (void *cls, | |||
177 | */ | 173 | */ |
178 | static void | 174 | static void |
179 | host_processor (void *cls, | 175 | host_processor (void *cls, |
180 | const struct GNUNET_PeerIdentity * peer, | 176 | const struct GNUNET_PeerIdentity *peer, |
181 | const struct GNUNET_HELLO_Message *hello, | 177 | const struct GNUNET_HELLO_Message *hello, const char *err_msg) |
182 | const char *err_msg) | ||
183 | { | 178 | { |
184 | struct HostSet *results = cls; | 179 | struct HostSet *results = cls; |
185 | size_t old; | 180 | size_t old; |
186 | size_t s; | 181 | size_t s; |
187 | int has_addr; | 182 | int has_addr; |
188 | 183 | ||
189 | if (err_msg != NULL) | 184 | if (err_msg != NULL) |
190 | { | 185 | { |
191 | GNUNET_assert (NULL == peer); | 186 | GNUNET_assert (NULL == peer); |
192 | pitr = NULL; | 187 | pitr = NULL; |
193 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 188 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
194 | _("Error in communication with PEERINFO service: %s\n"), | 189 | _("Error in communication with PEERINFO service: %s\n"), |
195 | err_msg); | 190 | err_msg); |
196 | return; | 191 | return; |
197 | } | 192 | } |
198 | if (peer == NULL) | 193 | if (peer == NULL) |
199 | { | 194 | { |
200 | pitr = NULL; | 195 | pitr = NULL; |
201 | finish_response (results); | 196 | finish_response (results); |
202 | return; | 197 | return; |
203 | } | 198 | } |
204 | if (hello == NULL) | 199 | if (hello == NULL) |
205 | return; | 200 | return; |
206 | has_addr = GNUNET_NO; | 201 | has_addr = GNUNET_NO; |
207 | GNUNET_HELLO_iterate_addresses (hello, | 202 | GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &check_has_addr, &has_addr); |
208 | GNUNET_NO, | ||
209 | &check_has_addr, | ||
210 | &has_addr); | ||
211 | if (GNUNET_NO == has_addr) | 203 | if (GNUNET_NO == has_addr) |
212 | { | 204 | { |
213 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 205 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
214 | "HELLO for peer `%4s' has no address, not suitable for hostlist!\n", | 206 | "HELLO for peer `%4s' has no address, not suitable for hostlist!\n", |
215 | GNUNET_i2s (peer)); | 207 | GNUNET_i2s (peer)); |
216 | GNUNET_STATISTICS_update (stats, | 208 | GNUNET_STATISTICS_update (stats, |
217 | gettext_noop("HELLOs without addresses encountered (ignored)"), | 209 | gettext_noop |
218 | 1, | 210 | ("HELLOs without addresses encountered (ignored)"), |
219 | GNUNET_NO); | 211 | 1, GNUNET_NO); |
220 | return; | 212 | return; |
221 | } | 213 | } |
222 | old = results->size; | 214 | old = results->size; |
223 | s = GNUNET_HELLO_size(hello); | 215 | s = GNUNET_HELLO_size (hello); |
224 | #if DEBUG_HOSTLIST_SERVER | 216 | #if DEBUG_HOSTLIST_SERVER |
225 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 217 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
226 | "Received %u bytes of `%s' from peer `%s' for hostlist.\n", | 218 | "Received %u bytes of `%s' from peer `%s' for hostlist.\n", |
227 | (unsigned int) s, | 219 | (unsigned int) s, "HELLO", GNUNET_i2s (peer)); |
228 | "HELLO", | ||
229 | GNUNET_i2s (peer)); | ||
230 | #endif | 220 | #endif |
231 | if ( (old + s >= GNUNET_MAX_MALLOC_CHECKED) || (old + s >= MAX_BYTES_PER_HOSTLISTS) ) | 221 | if ((old + s >= GNUNET_MAX_MALLOC_CHECKED) || |
232 | { | 222 | (old + s >= MAX_BYTES_PER_HOSTLISTS)) |
233 | GNUNET_STATISTICS_update (stats, | 223 | { |
234 | gettext_noop("bytes not included in hostlist (size limit)"), | 224 | GNUNET_STATISTICS_update (stats, |
235 | s, | 225 | gettext_noop |
236 | GNUNET_NO); | 226 | ("bytes not included in hostlist (size limit)"), |
237 | return; /* too large, skip! */ | 227 | s, GNUNET_NO); |
238 | } | 228 | return; /* too large, skip! */ |
229 | } | ||
239 | #if DEBUG_HOSTLIST_SERVER | 230 | #if DEBUG_HOSTLIST_SERVER |
240 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 231 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
241 | "Adding peer `%s' to hostlist (%u bytes)\n", | 232 | "Adding peer `%s' to hostlist (%u bytes)\n", |
242 | GNUNET_i2s (peer), | 233 | GNUNET_i2s (peer), (unsigned int) s); |
243 | (unsigned int) s); | ||
244 | #endif | 234 | #endif |
245 | GNUNET_array_grow (results->data, | 235 | GNUNET_array_grow (results->data, results->size, old + s); |
246 | results->size, | ||
247 | old + s); | ||
248 | memcpy (&results->data[old], hello, s); | 236 | memcpy (&results->data[old], hello, s); |
249 | } | 237 | } |
250 | 238 | ||
@@ -258,13 +246,13 @@ accept_policy_callback (void *cls, | |||
258 | const struct sockaddr *addr, socklen_t addrlen) | 246 | const struct sockaddr *addr, socklen_t addrlen) |
259 | { | 247 | { |
260 | if (NULL == response) | 248 | if (NULL == response) |
261 | { | 249 | { |
262 | #if DEBUG_HOSTLIST_SERVER | 250 | #if DEBUG_HOSTLIST_SERVER |
263 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 251 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
264 | "Received request for hostlist, but I am not yet ready; rejecting!\n"); | 252 | "Received request for hostlist, but I am not yet ready; rejecting!\n"); |
265 | #endif | 253 | #endif |
266 | return MHD_NO; | 254 | return MHD_NO; |
267 | } | 255 | } |
268 | return MHD_YES; /* accept all */ | 256 | return MHD_YES; /* accept all */ |
269 | } | 257 | } |
270 | 258 | ||
@@ -279,58 +267,54 @@ access_handler_callback (void *cls, | |||
279 | const char *method, | 267 | const char *method, |
280 | const char *version, | 268 | const char *version, |
281 | const char *upload_data, | 269 | const char *upload_data, |
282 | size_t*upload_data_size, void **con_cls) | 270 | size_t * upload_data_size, void **con_cls) |
283 | { | 271 | { |
284 | static int dummy; | 272 | static int dummy; |
285 | 273 | ||
286 | if (0 != strcmp (method, MHD_HTTP_METHOD_GET)) | 274 | if (0 != strcmp (method, MHD_HTTP_METHOD_GET)) |
287 | { | 275 | { |
288 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 276 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
289 | _("Refusing `%s' request to hostlist server\n"), | 277 | _("Refusing `%s' request to hostlist server\n"), method); |
290 | method); | 278 | GNUNET_STATISTICS_update (stats, |
291 | GNUNET_STATISTICS_update (stats, | 279 | gettext_noop |
292 | gettext_noop("hostlist requests refused (not HTTP GET)"), | 280 | ("hostlist requests refused (not HTTP GET)"), 1, |
293 | 1, | 281 | GNUNET_YES); |
294 | GNUNET_YES); | 282 | return MHD_NO; |
295 | return MHD_NO; | 283 | } |
296 | } | ||
297 | if (NULL == *con_cls) | 284 | if (NULL == *con_cls) |
298 | { | 285 | { |
299 | (*con_cls) = &dummy; | 286 | (*con_cls) = &dummy; |
300 | #if DEBUG_HOSTLIST_SERVER | 287 | #if DEBUG_HOSTLIST_SERVER |
301 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 288 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Sending 100 CONTINUE reply\n")); |
302 | _("Sending 100 CONTINUE reply\n")); | ||
303 | #endif | 289 | #endif |
304 | return MHD_YES; /* send 100 continue */ | 290 | return MHD_YES; /* send 100 continue */ |
305 | } | 291 | } |
306 | if (*upload_data_size != 0) | 292 | if (*upload_data_size != 0) |
307 | { | 293 | { |
308 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 294 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
309 | _("Refusing `%s' request with %llu bytes of upload data\n"), | 295 | _("Refusing `%s' request with %llu bytes of upload data\n"), |
310 | method, | 296 | method, (unsigned long long) *upload_data_size); |
311 | (unsigned long long) *upload_data_size); | 297 | GNUNET_STATISTICS_update (stats, |
312 | GNUNET_STATISTICS_update (stats, | 298 | gettext_noop |
313 | gettext_noop("hostlist requests refused (upload data)"), | 299 | ("hostlist requests refused (upload data)"), 1, |
314 | 1, | 300 | GNUNET_YES); |
315 | GNUNET_YES); | 301 | return MHD_NO; /* do not support upload data */ |
316 | return MHD_NO; /* do not support upload data */ | 302 | } |
317 | } | ||
318 | if (response == NULL) | 303 | if (response == NULL) |
319 | { | 304 | { |
320 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 305 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
321 | _("Could not handle hostlist request since I do not have a response yet\n")); | 306 | _ |
322 | GNUNET_STATISTICS_update (stats, | 307 | ("Could not handle hostlist request since I do not have a response yet\n")); |
323 | gettext_noop("hostlist requests refused (not ready)"), | 308 | GNUNET_STATISTICS_update (stats, |
324 | 1, | 309 | gettext_noop |
325 | GNUNET_YES); | 310 | ("hostlist requests refused (not ready)"), 1, |
326 | return MHD_NO; /* internal error, no response yet */ | 311 | GNUNET_YES); |
327 | } | 312 | return MHD_NO; /* internal error, no response yet */ |
328 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 313 | } |
329 | _("Received request for our hostlist\n")); | 314 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Received request for our hostlist\n")); |
330 | GNUNET_STATISTICS_update (stats, | 315 | GNUNET_STATISTICS_update (stats, |
331 | gettext_noop("hostlist requests processed"), | 316 | gettext_noop ("hostlist requests processed"), |
332 | 1, | 317 | 1, GNUNET_YES); |
333 | GNUNET_YES); | ||
334 | return MHD_queue_response (connection, MHD_HTTP_OK, response); | 318 | return MHD_queue_response (connection, MHD_HTTP_OK, response); |
335 | } | 319 | } |
336 | 320 | ||
@@ -342,41 +326,38 @@ access_handler_callback (void *cls, | |||
342 | * @param buf buffer to copy message to | 326 | * @param buf buffer to copy message to |
343 | */ | 327 | */ |
344 | static size_t | 328 | static size_t |
345 | adv_transmit_ready ( void *cls, size_t size, void *buf) | 329 | adv_transmit_ready (void *cls, size_t size, void *buf) |
346 | { | 330 | { |
347 | static uint64_t hostlist_adv_count; | 331 | static uint64_t hostlist_adv_count; |
348 | 332 | ||
349 | size_t transmission_size; | 333 | size_t transmission_size; |
350 | size_t uri_size; /* Including \0 termination! */ | 334 | size_t uri_size; /* Including \0 termination! */ |
351 | struct GNUNET_MessageHeader header; | 335 | struct GNUNET_MessageHeader header; |
352 | char *cbuf; | 336 | char *cbuf; |
353 | 337 | ||
354 | if (buf == NULL) | 338 | if (buf == NULL) |
355 | { | 339 | { |
356 | GNUNET_log ( GNUNET_ERROR_TYPE_DEBUG, | 340 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
357 | "Transmission failed, buffer invalid!\n" ); | 341 | "Transmission failed, buffer invalid!\n"); |
358 | return 0; | 342 | return 0; |
359 | } | 343 | } |
360 | uri_size = strlen ( hostlist_uri ) + 1; | 344 | uri_size = strlen (hostlist_uri) + 1; |
361 | transmission_size = sizeof (struct GNUNET_MessageHeader) + uri_size; | 345 | transmission_size = sizeof (struct GNUNET_MessageHeader) + uri_size; |
362 | header.type = htons (GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT); | 346 | header.type = htons (GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT); |
363 | header.size = htons (transmission_size); | 347 | header.size = htons (transmission_size); |
364 | GNUNET_assert (size >= transmission_size); | 348 | GNUNET_assert (size >= transmission_size); |
365 | memcpy (buf, &header, sizeof (struct GNUNET_MessageHeader)); | 349 | memcpy (buf, &header, sizeof (struct GNUNET_MessageHeader)); |
366 | cbuf = buf; | 350 | cbuf = buf; |
367 | memcpy (&cbuf[sizeof (struct GNUNET_MessageHeader)], | 351 | memcpy (&cbuf[sizeof (struct GNUNET_MessageHeader)], hostlist_uri, uri_size); |
368 | hostlist_uri, uri_size); | 352 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
369 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 353 | "Sent advertisement message: Copied %u bytes into buffer!\n", |
370 | "Sent advertisement message: Copied %u bytes into buffer!\n", | 354 | (unsigned int) transmission_size); |
371 | (unsigned int) transmission_size); | ||
372 | hostlist_adv_count++; | 355 | hostlist_adv_count++; |
373 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 356 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
374 | " # Sent advertisement message: %u\n", | 357 | " # Sent advertisement message: %u\n", hostlist_adv_count); |
375 | hostlist_adv_count); | ||
376 | GNUNET_STATISTICS_update (stats, | 358 | GNUNET_STATISTICS_update (stats, |
377 | gettext_noop("# hostlist advertisements send"), | 359 | gettext_noop ("# hostlist advertisements send"), |
378 | 1, | 360 | 1, GNUNET_NO); |
379 | GNUNET_NO); | ||
380 | return transmission_size; | 361 | return transmission_size; |
381 | } | 362 | } |
382 | 363 | ||
@@ -391,41 +372,42 @@ adv_transmit_ready ( void *cls, size_t size, void *buf) | |||
391 | static void | 372 | static void |
392 | connect_handler (void *cls, | 373 | connect_handler (void *cls, |
393 | const struct | 374 | const struct |
394 | GNUNET_PeerIdentity * peer, | 375 | GNUNET_PeerIdentity *peer, |
395 | const struct GNUNET_TRANSPORT_ATS_Information *atsi) | 376 | const struct GNUNET_TRANSPORT_ATS_Information *atsi) |
396 | { | 377 | { |
397 | size_t size; | 378 | size_t size; |
398 | 379 | ||
399 | if ( !advertising ) | 380 | if (!advertising) |
400 | return; | 381 | return; |
401 | if (hostlist_uri == NULL) | 382 | if (hostlist_uri == NULL) |
402 | return; | 383 | return; |
403 | size = strlen (hostlist_uri) + 1; | 384 | size = strlen (hostlist_uri) + 1; |
404 | if (size + sizeof (struct GNUNET_MessageHeader) >= GNUNET_SERVER_MAX_MESSAGE_SIZE) | 385 | if (size + sizeof (struct GNUNET_MessageHeader) >= |
405 | { | 386 | GNUNET_SERVER_MAX_MESSAGE_SIZE) |
406 | GNUNET_break (0); | 387 | { |
407 | return; | 388 | GNUNET_break (0); |
408 | } | 389 | return; |
390 | } | ||
409 | size += sizeof (struct GNUNET_MessageHeader); | 391 | size += sizeof (struct GNUNET_MessageHeader); |
410 | if (NULL == core) | 392 | if (NULL == core) |
411 | { | 393 | { |
412 | GNUNET_break (0); | 394 | GNUNET_break (0); |
413 | return; | 395 | return; |
414 | } | 396 | } |
415 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 397 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
416 | "Asked core to transmit advertisement message with a size of %u bytes to peer `%s'\n", | 398 | "Asked core to transmit advertisement message with a size of %u bytes to peer `%s'\n", |
417 | size,GNUNET_i2s(peer)); | 399 | size, GNUNET_i2s (peer)); |
418 | if (NULL == GNUNET_CORE_notify_transmit_ready (core, | 400 | if (NULL == GNUNET_CORE_notify_transmit_ready (core, |
419 | GNUNET_YES, | 401 | GNUNET_YES, |
420 | 0, | 402 | 0, |
421 | GNUNET_ADV_TIMEOUT, | 403 | GNUNET_ADV_TIMEOUT, |
422 | peer, | 404 | peer, |
423 | size, | 405 | size, |
424 | &adv_transmit_ready, NULL)) | 406 | &adv_transmit_ready, NULL)) |
425 | { | 407 | { |
426 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 408 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
427 | _("Advertisement message could not be queued by core\n")); | 409 | _("Advertisement message could not be queued by core\n")); |
428 | } | 410 | } |
429 | } | 411 | } |
430 | 412 | ||
431 | 413 | ||
@@ -436,9 +418,7 @@ connect_handler (void *cls, | |||
436 | * @param peer peer identity this notification is about | 418 | * @param peer peer identity this notification is about |
437 | */ | 419 | */ |
438 | static void | 420 | static void |
439 | disconnect_handler (void *cls, | 421 | disconnect_handler (void *cls, const struct GNUNET_PeerIdentity *peer) |
440 | const struct | ||
441 | GNUNET_PeerIdentity * peer) | ||
442 | { | 422 | { |
443 | /* nothing to do */ | 423 | /* nothing to do */ |
444 | } | 424 | } |
@@ -455,27 +435,26 @@ disconnect_handler (void *cls, | |||
455 | static void | 435 | static void |
456 | process_notify (void *cls, | 436 | process_notify (void *cls, |
457 | const struct GNUNET_PeerIdentity *peer, | 437 | const struct GNUNET_PeerIdentity *peer, |
458 | const struct GNUNET_HELLO_Message *hello, | 438 | const struct GNUNET_HELLO_Message *hello, const char *err_msg) |
459 | const char *err_msg) | ||
460 | { | 439 | { |
461 | struct HostSet *results; | 440 | struct HostSet *results; |
441 | |||
462 | #if DEBUG_HOSTLIST_SERVER | 442 | #if DEBUG_HOSTLIST_SERVER |
463 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 443 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
464 | "Peerinfo is notifying us to rebuild our hostlist\n"); | 444 | "Peerinfo is notifying us to rebuild our hostlist\n"); |
465 | #endif | 445 | #endif |
466 | if (err_msg != NULL) | 446 | if (err_msg != NULL) |
467 | { | 447 | { |
468 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 448 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
469 | _("Error in communication with PEERINFO service\n")); | 449 | _("Error in communication with PEERINFO service\n")); |
470 | /* return; */ | 450 | /* return; */ |
471 | } | 451 | } |
472 | results = GNUNET_malloc(sizeof(struct HostSet)); | 452 | results = GNUNET_malloc (sizeof (struct HostSet)); |
473 | GNUNET_assert (peerinfo != NULL); | 453 | GNUNET_assert (peerinfo != NULL); |
474 | pitr = GNUNET_PEERINFO_iterate (peerinfo, | 454 | pitr = GNUNET_PEERINFO_iterate (peerinfo, |
475 | NULL, | 455 | NULL, |
476 | GNUNET_TIME_UNIT_MINUTES, | 456 | GNUNET_TIME_UNIT_MINUTES, |
477 | &host_processor, | 457 | &host_processor, results); |
478 | results); | ||
479 | } | 458 | } |
480 | 459 | ||
481 | /** | 460 | /** |
@@ -491,8 +470,7 @@ prepare_daemon (struct MHD_Daemon *daemon_handle); | |||
491 | * and schedule the next run. | 470 | * and schedule the next run. |
492 | */ | 471 | */ |
493 | static void | 472 | static void |
494 | run_daemon (void *cls, | 473 | run_daemon (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
495 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
496 | { | 474 | { |
497 | struct MHD_Daemon *daemon_handle = cls; | 475 | struct MHD_Daemon *daemon_handle = cls; |
498 | 476 | ||
@@ -502,7 +480,7 @@ run_daemon (void *cls, | |||
502 | hostlist_task_v6 = GNUNET_SCHEDULER_NO_TASK; | 480 | hostlist_task_v6 = GNUNET_SCHEDULER_NO_TASK; |
503 | 481 | ||
504 | if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) | 482 | if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) |
505 | return; | 483 | return; |
506 | GNUNET_assert (MHD_YES == MHD_run (daemon_handle)); | 484 | GNUNET_assert (MHD_YES == MHD_run (daemon_handle)); |
507 | if (daemon_handle == daemon_handle_v4) | 485 | if (daemon_handle == daemon_handle_v4) |
508 | hostlist_task_v4 = prepare_daemon (daemon_handle); | 486 | hostlist_task_v4 = prepare_daemon (daemon_handle); |
@@ -529,20 +507,15 @@ prepare_daemon (struct MHD_Daemon *daemon_handle) | |||
529 | unsigned long long timeout; | 507 | unsigned long long timeout; |
530 | int haveto; | 508 | int haveto; |
531 | struct GNUNET_TIME_Relative tv; | 509 | struct GNUNET_TIME_Relative tv; |
532 | 510 | ||
533 | FD_ZERO(&rs); | 511 | FD_ZERO (&rs); |
534 | FD_ZERO(&ws); | 512 | FD_ZERO (&ws); |
535 | FD_ZERO(&es); | 513 | FD_ZERO (&es); |
536 | wrs = GNUNET_NETWORK_fdset_create (); | 514 | wrs = GNUNET_NETWORK_fdset_create (); |
537 | wes = GNUNET_NETWORK_fdset_create (); | 515 | wes = GNUNET_NETWORK_fdset_create (); |
538 | wws = GNUNET_NETWORK_fdset_create (); | 516 | wws = GNUNET_NETWORK_fdset_create (); |
539 | max = -1; | 517 | max = -1; |
540 | GNUNET_assert (MHD_YES == | 518 | GNUNET_assert (MHD_YES == MHD_get_fdset (daemon_handle, &rs, &ws, &es, &max)); |
541 | MHD_get_fdset (daemon_handle, | ||
542 | &rs, | ||
543 | &ws, | ||
544 | &es, | ||
545 | &max)); | ||
546 | haveto = MHD_get_timeout (daemon_handle, &timeout); | 519 | haveto = MHD_get_timeout (daemon_handle, &timeout); |
547 | if (haveto == MHD_YES) | 520 | if (haveto == MHD_YES) |
548 | tv.rel_value = (uint64_t) timeout; | 521 | tv.rel_value = (uint64_t) timeout; |
@@ -552,12 +525,8 @@ prepare_daemon (struct MHD_Daemon *daemon_handle) | |||
552 | GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1); | 525 | GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1); |
553 | GNUNET_NETWORK_fdset_copy_native (wes, &es, max + 1); | 526 | GNUNET_NETWORK_fdset_copy_native (wes, &es, max + 1); |
554 | ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH, | 527 | ret = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH, |
555 | GNUNET_SCHEDULER_NO_TASK, | 528 | GNUNET_SCHEDULER_NO_TASK, |
556 | tv, | 529 | tv, wrs, wws, &run_daemon, daemon_handle); |
557 | wrs, | ||
558 | wws, | ||
559 | &run_daemon, | ||
560 | daemon_handle); | ||
561 | GNUNET_NETWORK_fdset_destroy (wrs); | 530 | GNUNET_NETWORK_fdset_destroy (wrs); |
562 | GNUNET_NETWORK_fdset_destroy (wws); | 531 | GNUNET_NETWORK_fdset_destroy (wws); |
563 | GNUNET_NETWORK_fdset_destroy (wes); | 532 | GNUNET_NETWORK_fdset_destroy (wes); |
@@ -573,9 +542,9 @@ prepare_daemon (struct MHD_Daemon *daemon_handle) | |||
573 | */ | 542 | */ |
574 | int | 543 | int |
575 | GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, | 544 | GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, |
576 | struct GNUNET_STATISTICS_Handle *st, | 545 | struct GNUNET_STATISTICS_Handle *st, |
577 | struct GNUNET_CORE_Handle *co, | 546 | struct GNUNET_CORE_Handle *co, |
578 | GNUNET_CORE_ConnectEventHandler *server_ch, | 547 | GNUNET_CORE_ConnectEventHandler *server_ch, |
579 | GNUNET_CORE_DisconnectEventHandler *server_dh, | 548 | GNUNET_CORE_DisconnectEventHandler *server_dh, |
580 | int advertise) | 549 | int advertise) |
581 | { | 550 | { |
@@ -584,102 +553,100 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
584 | size_t size; | 553 | size_t size; |
585 | 554 | ||
586 | advertising = advertise; | 555 | advertising = advertise; |
587 | if ( !advertising ) | 556 | if (!advertising) |
588 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 557 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
589 | "Advertising not enabled on this hostlist server\n"); | 558 | "Advertising not enabled on this hostlist server\n"); |
590 | else | 559 | else |
591 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 560 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
592 | "Advertising enabled on this hostlist server\n"); | 561 | "Advertising enabled on this hostlist server\n"); |
593 | cfg = c; | 562 | cfg = c; |
594 | stats = st; | 563 | stats = st; |
595 | peerinfo = GNUNET_PEERINFO_connect (cfg); | 564 | peerinfo = GNUNET_PEERINFO_connect (cfg); |
596 | if (peerinfo == NULL) | 565 | if (peerinfo == NULL) |
597 | { | 566 | { |
598 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 567 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
599 | _("Could not access PEERINFO service. Exiting.\n")); | 568 | _("Could not access PEERINFO service. Exiting.\n")); |
600 | return GNUNET_SYSERR; | 569 | return GNUNET_SYSERR; |
601 | } | 570 | } |
602 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, | 571 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, |
603 | "HOSTLIST", | 572 | "HOSTLIST", |
604 | "HTTPPORT", | 573 | "HTTPPORT", &port)) |
605 | &port)) | ||
606 | return GNUNET_SYSERR; | 574 | return GNUNET_SYSERR; |
607 | if ( (port == 0) || | 575 | if ((port == 0) || (port > UINT16_MAX)) |
608 | (port > UINT16_MAX) ) | 576 | { |
609 | { | 577 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
610 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 578 | _("Invalid port number %llu. Exiting.\n"), port); |
611 | _("Invalid port number %llu. Exiting.\n"), | 579 | return GNUNET_SYSERR; |
612 | port); | 580 | } |
613 | return GNUNET_SYSERR; | ||
614 | } | ||
615 | 581 | ||
616 | if ( GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg, | 582 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg, |
617 | "HOSTLIST", | 583 | "HOSTLIST", |
618 | "EXTERNAL_DNS_NAME", | 584 | "EXTERNAL_DNS_NAME", |
619 | &hostname)) | 585 | &hostname)) |
620 | hostname = GNUNET_RESOLVER_local_fqdn_get (); | 586 | hostname = GNUNET_RESOLVER_local_fqdn_get (); |
621 | 587 | ||
622 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 588 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
623 | _("Hostlist service starts on %s:%llu\n"), | 589 | _("Hostlist service starts on %s:%llu\n"), hostname, port); |
624 | hostname, port); | ||
625 | if (NULL != hostname) | 590 | if (NULL != hostname) |
591 | { | ||
592 | size = strlen (hostname); | ||
593 | if (size + 15 > MAX_URL_LEN) | ||
626 | { | 594 | { |
627 | size = strlen (hostname); | 595 | GNUNET_break (0); |
628 | if (size + 15 > MAX_URL_LEN) | ||
629 | { | ||
630 | GNUNET_break (0); | ||
631 | } | ||
632 | else | ||
633 | { | ||
634 | GNUNET_asprintf (&hostlist_uri, | ||
635 | "http://%s:%u/", | ||
636 | hostname, | ||
637 | (unsigned int) port); | ||
638 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
639 | _("Address to obtain hostlist: `%s'\n"), | ||
640 | hostlist_uri); | ||
641 | } | ||
642 | GNUNET_free ( hostname ); | ||
643 | } | 596 | } |
644 | daemon_handle_v6 = MHD_start_daemon (MHD_USE_IPv6 | 597 | else |
598 | { | ||
599 | GNUNET_asprintf (&hostlist_uri, | ||
600 | "http://%s:%u/", hostname, (unsigned int) port); | ||
601 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
602 | _("Address to obtain hostlist: `%s'\n"), hostlist_uri); | ||
603 | } | ||
604 | GNUNET_free (hostname); | ||
605 | } | ||
606 | daemon_handle_v6 = MHD_start_daemon (MHD_USE_IPv6 | ||
645 | #if DEBUG_HOSTLIST_SERVER | 607 | #if DEBUG_HOSTLIST_SERVER |
646 | | MHD_USE_DEBUG | 608 | | MHD_USE_DEBUG |
647 | #endif | 609 | #endif |
648 | , | 610 | , |
649 | (unsigned short) port, | 611 | (unsigned short) port, |
650 | &accept_policy_callback, | 612 | &accept_policy_callback, |
651 | NULL, | 613 | NULL, |
652 | &access_handler_callback, | 614 | &access_handler_callback, |
653 | NULL, | 615 | NULL, |
654 | MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 16, | 616 | MHD_OPTION_CONNECTION_LIMIT, |
655 | MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) 1, | 617 | (unsigned int) 16, |
656 | MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16, | 618 | MHD_OPTION_PER_IP_CONNECTION_LIMIT, |
657 | MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (16 * 1024), | 619 | (unsigned int) 1, |
658 | MHD_OPTION_END); | 620 | MHD_OPTION_CONNECTION_TIMEOUT, |
621 | (unsigned int) 16, | ||
622 | MHD_OPTION_CONNECTION_MEMORY_LIMIT, | ||
623 | (size_t) (16 * 1024), MHD_OPTION_END); | ||
659 | daemon_handle_v4 = MHD_start_daemon (MHD_NO_FLAG | 624 | daemon_handle_v4 = MHD_start_daemon (MHD_NO_FLAG |
660 | #if DEBUG_HOSTLIST_SERVER | 625 | #if DEBUG_HOSTLIST_SERVER |
661 | | MHD_USE_DEBUG | 626 | | MHD_USE_DEBUG |
662 | #endif | 627 | #endif |
663 | , | 628 | , |
664 | (unsigned short) port, | 629 | (unsigned short) port, |
665 | &accept_policy_callback, | 630 | &accept_policy_callback, |
666 | NULL, | 631 | NULL, |
667 | &access_handler_callback, | 632 | &access_handler_callback, |
668 | NULL, | 633 | NULL, |
669 | MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 16, | 634 | MHD_OPTION_CONNECTION_LIMIT, |
670 | MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) 1, | 635 | (unsigned int) 16, |
671 | MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16, | 636 | MHD_OPTION_PER_IP_CONNECTION_LIMIT, |
672 | MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (16 * 1024), | 637 | (unsigned int) 1, |
673 | MHD_OPTION_END); | 638 | MHD_OPTION_CONNECTION_TIMEOUT, |
674 | 639 | (unsigned int) 16, | |
675 | if ( (daemon_handle_v6 == NULL) && | 640 | MHD_OPTION_CONNECTION_MEMORY_LIMIT, |
676 | (daemon_handle_v4 == NULL) ) | 641 | (size_t) (16 * 1024), MHD_OPTION_END); |
677 | { | 642 | |
678 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 643 | if ((daemon_handle_v6 == NULL) && (daemon_handle_v4 == NULL)) |
679 | _("Could not start hostlist HTTP server on port %u\n"), | 644 | { |
680 | (unsigned short) port); | 645 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
681 | return GNUNET_SYSERR; | 646 | _("Could not start hostlist HTTP server on port %u\n"), |
682 | } | 647 | (unsigned short) port); |
648 | return GNUNET_SYSERR; | ||
649 | } | ||
683 | 650 | ||
684 | core = co; | 651 | core = co; |
685 | 652 | ||
@@ -691,7 +658,7 @@ GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
691 | if (daemon_handle_v6 != NULL) | 658 | if (daemon_handle_v6 != NULL) |
692 | hostlist_task_v6 = prepare_daemon (daemon_handle_v6); | 659 | hostlist_task_v6 = prepare_daemon (daemon_handle_v6); |
693 | 660 | ||
694 | notify = GNUNET_PEERINFO_notify ( cfg, process_notify, NULL); | 661 | notify = GNUNET_PEERINFO_notify (cfg, process_notify, NULL); |
695 | 662 | ||
696 | return GNUNET_OK; | 663 | return GNUNET_OK; |
697 | } | 664 | } |
@@ -703,49 +670,48 @@ void | |||
703 | GNUNET_HOSTLIST_server_stop () | 670 | GNUNET_HOSTLIST_server_stop () |
704 | { | 671 | { |
705 | #if DEBUG_HOSTLIST_SERVER | 672 | #if DEBUG_HOSTLIST_SERVER |
706 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 673 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist server shutdown\n"); |
707 | "Hostlist server shutdown\n"); | ||
708 | #endif | 674 | #endif |
709 | if (NULL != notify) | 675 | if (NULL != notify) |
710 | { | 676 | { |
711 | GNUNET_PEERINFO_notify_cancel (notify); | 677 | GNUNET_PEERINFO_notify_cancel (notify); |
712 | notify = NULL; | 678 | notify = NULL; |
713 | } | 679 | } |
714 | if (GNUNET_SCHEDULER_NO_TASK != hostlist_task_v6) | 680 | if (GNUNET_SCHEDULER_NO_TASK != hostlist_task_v6) |
715 | { | 681 | { |
716 | GNUNET_SCHEDULER_cancel (hostlist_task_v6); | 682 | GNUNET_SCHEDULER_cancel (hostlist_task_v6); |
717 | hostlist_task_v6 = GNUNET_SCHEDULER_NO_TASK; | 683 | hostlist_task_v6 = GNUNET_SCHEDULER_NO_TASK; |
718 | } | 684 | } |
719 | if (GNUNET_SCHEDULER_NO_TASK != hostlist_task_v4) | 685 | if (GNUNET_SCHEDULER_NO_TASK != hostlist_task_v4) |
720 | { | 686 | { |
721 | GNUNET_SCHEDULER_cancel (hostlist_task_v4); | 687 | GNUNET_SCHEDULER_cancel (hostlist_task_v4); |
722 | hostlist_task_v4 = GNUNET_SCHEDULER_NO_TASK; | 688 | hostlist_task_v4 = GNUNET_SCHEDULER_NO_TASK; |
723 | } | 689 | } |
724 | if (pitr != NULL) | 690 | if (pitr != NULL) |
725 | { | 691 | { |
726 | GNUNET_PEERINFO_iterate_cancel (pitr); | 692 | GNUNET_PEERINFO_iterate_cancel (pitr); |
727 | pitr = NULL; | 693 | pitr = NULL; |
728 | } | 694 | } |
729 | if (NULL != daemon_handle_v4) | 695 | if (NULL != daemon_handle_v4) |
730 | { | 696 | { |
731 | MHD_stop_daemon (daemon_handle_v4); | 697 | MHD_stop_daemon (daemon_handle_v4); |
732 | daemon_handle_v4 = NULL; | 698 | daemon_handle_v4 = NULL; |
733 | } | 699 | } |
734 | if (NULL != daemon_handle_v6) | 700 | if (NULL != daemon_handle_v6) |
735 | { | 701 | { |
736 | MHD_stop_daemon (daemon_handle_v6); | 702 | MHD_stop_daemon (daemon_handle_v6); |
737 | daemon_handle_v6 = NULL; | 703 | daemon_handle_v6 = NULL; |
738 | } | 704 | } |
739 | if (response != NULL) | 705 | if (response != NULL) |
740 | { | 706 | { |
741 | MHD_destroy_response (response); | 707 | MHD_destroy_response (response); |
742 | response = NULL; | 708 | response = NULL; |
743 | } | 709 | } |
744 | if (peerinfo != NULL) | 710 | if (peerinfo != NULL) |
745 | { | 711 | { |
746 | GNUNET_PEERINFO_disconnect (peerinfo); | 712 | GNUNET_PEERINFO_disconnect (peerinfo); |
747 | peerinfo = NULL; | 713 | peerinfo = NULL; |
748 | } | 714 | } |
749 | cfg = NULL; | 715 | cfg = NULL; |
750 | stats = NULL; | 716 | stats = NULL; |
751 | core = NULL; | 717 | core = NULL; |