aboutsummaryrefslogtreecommitdiff
path: root/src/peerinfo/peerinfo_api.c
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2010-04-21 11:49:20 +0000
committerChristian Grothoff <christian@grothoff.org>2010-04-21 11:49:20 +0000
commit6c32edc3932553c01d329d026150046ebf95b38f (patch)
treef55fc7c5bfe653463ebd4e0531f458b0ef8006cf /src/peerinfo/peerinfo_api.c
parent5e07ad9cf3ec17e0b8d33b7686c81bbb5e79c986 (diff)
downloadgnunet-6c32edc3932553c01d329d026150046ebf95b38f.tar.gz
gnunet-6c32edc3932553c01d329d026150046ebf95b38f.zip
move
Diffstat (limited to 'src/peerinfo/peerinfo_api.c')
-rw-r--r--src/peerinfo/peerinfo_api.c239
1 files changed, 0 insertions, 239 deletions
diff --git a/src/peerinfo/peerinfo_api.c b/src/peerinfo/peerinfo_api.c
index 6fd538f0d..841f14074 100644
--- a/src/peerinfo/peerinfo_api.c
+++ b/src/peerinfo/peerinfo_api.c
@@ -324,245 +324,6 @@ GNUNET_PEERINFO_iterate_cancel (struct GNUNET_PEERINFO_IteratorContext *ic)
324} 324}
325 325
326 326
327/**
328 * Context for the info handler.
329 */
330struct GNUNET_PEERINFO_NotifyContext
331{
332
333 /**
334 * Our connection to the PEERINFO service.
335 */
336 struct GNUNET_CLIENT_Connection *client;
337
338 /**
339 * Function to call with information.
340 */
341 GNUNET_PEERINFO_Processor callback;
342
343 /**
344 * Closure for callback.
345 */
346 void *callback_cls;
347
348 /**
349 * Handle to our initial request for message transmission to
350 * the peerinfo service.
351 */
352 struct GNUNET_CLIENT_TransmitHandle *init;
353
354 /**
355 * Configuration.
356 */
357 const struct GNUNET_CONFIGURATION_Handle *cfg;
358
359 /**
360 * Scheduler.
361 */
362 struct GNUNET_SCHEDULER_Handle *sched;
363};
364
365
366/**
367 * Send a request to the peerinfo service to start being
368 * notified about all changes to peer information.
369 *
370 * @param nc our context
371 */
372static void
373request_notifications (struct GNUNET_PEERINFO_NotifyContext *nc);
374
375
376/**
377 * Read notifications from the client handle and pass them
378 * to the callback.
379 *
380 * @param nc our context
381 */
382static void
383receive_notifications (struct GNUNET_PEERINFO_NotifyContext *nc);
384
385
386/**
387 * Receive a peerinfo information message, process it and
388 * go for more.
389 *
390 * @param cls closure
391 * @param msg message received, NULL on timeout or fatal error
392 */
393static void
394process_notification (void *cls,
395 const struct
396 GNUNET_MessageHeader * msg)
397{
398 struct GNUNET_PEERINFO_NotifyContext *nc = cls;
399 const struct InfoMessage *im;
400 const struct GNUNET_HELLO_Message *hello;
401 uint16_t ms;
402
403 if (msg == NULL)
404 {
405 GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
406 nc->client = GNUNET_CLIENT_connect (nc->sched, "peerinfo", nc->cfg);
407 request_notifications (nc);
408 return;
409 }
410 ms = ntohs (msg->size);
411 if ((ms < sizeof (struct InfoMessage)) ||
412 (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_PEERINFO_INFO))
413 {
414 GNUNET_break (0);
415 GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
416 nc->client = GNUNET_CLIENT_connect (nc->sched, "peerinfo", nc->cfg);
417 request_notifications (nc);
418 return;
419 }
420 im = (const struct InfoMessage *) msg;
421 hello = NULL;
422 if (ms > sizeof (struct InfoMessage) + sizeof (struct GNUNET_MessageHeader))
423 {
424 hello = (const struct GNUNET_HELLO_Message *) &im[1];
425 if (ms != sizeof (struct InfoMessage) + GNUNET_HELLO_size (hello))
426 {
427 GNUNET_break (0);
428 GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
429 nc->client = GNUNET_CLIENT_connect (nc->sched, "peerinfo", nc->cfg);
430 request_notifications (nc);
431 return;
432 }
433 }
434#if DEBUG_PEERINFO
435 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
436 "Received information about peer `%s' from peerinfo database\n",
437 GNUNET_i2s (&im->peer));
438#endif
439 nc->callback (nc->callback_cls, &im->peer, hello, ntohl (im->trust));
440 receive_notifications (nc);
441}
442
443
444/**
445 * Read notifications from the client handle and pass them
446 * to the callback.
447 *
448 * @param nc our context
449 */
450static void
451receive_notifications (struct GNUNET_PEERINFO_NotifyContext *nc)
452{
453 GNUNET_CLIENT_receive (nc->client,
454 &process_notification,
455 nc,
456 GNUNET_TIME_UNIT_FOREVER_REL);
457}
458
459
460/**
461 * Transmit our init-notify request, start receiving.
462 *
463 * @param cls closure (our 'struct GNUNET_PEERINFO_NotifyContext')
464 * @param size number of bytes available in buf
465 * @param buf where the callee should write the message
466 * @return number of bytes written to buf
467 */
468static size_t
469transmit_notify_request (void *cls,
470 size_t size,
471 void *buf)
472{
473 struct GNUNET_PEERINFO_NotifyContext *nc = cls;
474 struct GNUNET_MessageHeader hdr;
475
476 nc->init = NULL;
477 if (buf == NULL)
478 {
479 GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
480 nc->client = GNUNET_CLIENT_connect (nc->sched, "peerinfo", nc->cfg);
481 request_notifications (nc);
482 return 0;
483 }
484 GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
485 hdr.size = htons (sizeof (struct GNUNET_MessageHeader));
486 hdr.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_NOTIFY);
487 memcpy (buf, &hdr, sizeof (struct GNUNET_MessageHeader));
488 receive_notifications (nc);
489 return sizeof (struct GNUNET_MessageHeader);
490}
491
492
493/**
494 * Send a request to the peerinfo service to start being
495 * notified about all changes to peer information.
496 *
497 * @param nc our context
498 */
499static void
500request_notifications (struct GNUNET_PEERINFO_NotifyContext *nc)
501{
502 GNUNET_assert (NULL == nc->init);
503 nc->init =GNUNET_CLIENT_notify_transmit_ready (nc->client,
504 sizeof (struct GNUNET_MessageHeader),
505 GNUNET_TIME_UNIT_FOREVER_REL,
506 GNUNET_YES,
507 &transmit_notify_request,
508 nc);
509}
510
511
512/**
513 * Call a method whenever our known information about peers
514 * changes. Initially calls the given function for all known
515 * peers and then only signals changes.
516 *
517 * @param cfg configuration to use
518 * @param sched scheduler to use
519 * @param callback the method to call for each peer
520 * @param callback_cls closure for callback
521 * @return NULL on error
522 */
523struct GNUNET_PEERINFO_NotifyContext *
524GNUNET_PEERINFO_notify (const struct GNUNET_CONFIGURATION_Handle *cfg,
525 struct GNUNET_SCHEDULER_Handle *sched,
526 GNUNET_PEERINFO_Processor callback,
527 void *callback_cls)
528{
529 struct GNUNET_PEERINFO_NotifyContext *nc;
530 struct GNUNET_CLIENT_Connection *client;
531
532 client = GNUNET_CLIENT_connect (sched, "peerinfo", cfg);
533 if (client == NULL)
534 {
535 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
536 _("Could not connect to `%s' service.\n"), "peerinfo");
537 return NULL;
538 }
539 nc = GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_NotifyContext));
540 nc->sched = sched;
541 nc->cfg = cfg;
542 nc->client = client;
543 nc->callback = callback;
544 nc->callback_cls = callback_cls;
545 request_notifications (nc);
546 return nc;
547}
548
549
550/**
551 * Stop notifying about changes.
552 *
553 * @param nc context to stop notifying
554 */
555void
556GNUNET_PEERINFO_notify_cancel (struct GNUNET_PEERINFO_NotifyContext *nc)
557{
558 if (NULL != nc->init)
559 {
560 GNUNET_CLIENT_notify_transmit_ready_cancel (nc->init);
561 nc->init = NULL;
562 }
563 GNUNET_CLIENT_disconnect (nc->client, GNUNET_NO);
564 GNUNET_free (nc);
565}
566 327
567 328
568/* end of peerinfo_api.c */ 329/* end of peerinfo_api.c */