src/topology/gnunet-daemon-topology.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2007, 2008, 2009 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 2, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file topology/gnunet-daemon-topology.c
  23  * @brief code for bootstrapping via topology servers
  24  * @author Christian Grothoff
  25  */
  26
  27 #include <stdlib.h>
  28 #include "platform.h"
  29 #include "gnunet_core_service.h"
  30 #include "gnunet_protocols.h"
  31 #include "gnunet_peerinfo_service.h"
  32 #include "gnunet_transport_service.h"
  33 #include "gnunet_util_lib.h"
  34
  35
  36 #define DEBUG_TOPOLOGY GNUNET_NO
  37
  38 /**
  39  * For how long do we blacklist a peer after a failed
  40  * connection attempt?
  41  */
  42 #define BLACKLIST_AFTER_ATTEMPT GNUNET_TIME_UNIT_HOURS
  43
  44 /**
  45  * For how long do we blacklist a friend after a failed
  46  * connection attempt?
  47  */
  48 #define BLACKLIST_AFTER_ATTEMPT_FRIEND GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
  49
  50 /**
  51  * How frequently are we allowed to ask PEERINFO for more
  52  * HELLO's to advertise (at most)?
  53  */
  54 #define MIN_HELLO_GATHER_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 27)
  55
  56 /**
  57  * How often do we at most advertise the same HELLO to the same peer?
  58  * Also used to remove HELLOs of peers that PEERINFO no longer lists
  59  * from our cache.
  60  */
  61 #define HELLO_ADVERTISEMENT_MIN_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 12)
  62
  63
  64 /**
  65  * List of neighbours, friends and blacklisted peers.
  66  */
  67 struct PeerList
  68 {
  69
  70   /**
  71    * This is a linked list.
  72    */
  73   struct PeerList *next;
  74
  75   /**
  76    * Is this peer listed here because he is a friend?
  77    */
  78   int is_friend;
  79
  80   /**
  81    * Are we connected to this peer right now?
  82    */
  83   int is_connected;
  84
  85   /**
  86    * Until what time should we not try to connect again
  87    * to this peer?
  88    */
  89   struct GNUNET_TIME_Absolute blacklisted_until;
  90
  91   /**
  92    * Last time we transmitted a HELLO to this peer?
  93    */
  94   struct GNUNET_TIME_Absolute last_hello_sent;
  95
  96   /**
  97    * ID of the peer.
  98    */
  99   struct GNUNET_PeerIdentity id;
 100
 101 };
 102
 103
 104 /**
 105  * List of HELLOs we may consider for advertising.
 106  */
 107 struct HelloList
 108 {
 109   /**
 110    * This is a linked list.
 111    */
 112   struct HelloList *next;
 113
 114   /**
 115    * Pointer to the HELLO message.  Memory allocated as part
 116    * of the "struct HelloList" --- do not free!
 117    */
 118   struct GNUNET_HELLO_Message *msg;
 119
 120   /**
 121    * Bloom filter used to mark which peers already got
 122    * this HELLO.
 123    */
 124   struct GNUNET_CONTAINER_BloomFilter *filter;
 125
 126   /**
 127    * What peer is this HELLO for?
 128    */
 129   struct GNUNET_PeerIdentity id;
 130
 131   /**
 132    * When should we remove this entry from the linked list (either
 133    * resetting the filter or possibly eliminating it for good because
 134    * we no longer consider the peer to be participating in the
 135    * network)?
 136    */
 137   struct GNUNET_TIME_Absolute expiration;
 138 };
 139
 140
 141 /**
 142  * Linked list of HELLOs for advertising.
 143  */
 144 static struct HelloList *hellos;
 145
 146 /**
 147  * Our scheduler.
 148  */
 149 static struct GNUNET_SCHEDULER_Handle * sched;
 150
 151 /**
 152  * Our configuration.
 153  */
 154 static struct GNUNET_CONFIGURATION_Handle * cfg;
 155
 156 /**
 157  * Handle to the core API.
 158  */
 159 static struct GNUNET_CORE_Handle *handle;
 160
 161 /**
 162  * Handle to the transport API.
 163  */
 164 static struct GNUNET_TRANSPORT_Handle *transport;
 165
 166 /**
 167  * Identity of this peer.
 168  */
 169 static struct GNUNET_PeerIdentity my_identity;
 170
 171 /**
 172  * Linked list of all of our friends and all of our current
 173  * neighbours.
 174  */
 175 static struct PeerList *friends;
 176
 177 /**
 178  * Timestamp from the last time we tried to gather HELLOs.
 179  */
 180 static struct GNUNET_TIME_Absolute last_hello_gather_time;
 181
 182 /**
 183  * Flag to disallow non-friend connections (pure F2F mode).
 184  */
 185 static int friends_only;
 186
 187 /**
 188  * Minimum number of friends to have in the
 189  * connection set before we allow non-friends.
 190  */
 191 static unsigned int minimum_friend_count;
 192
 193 /**
 194  * Number of peers (friends and others) that we are currently connected to.
 195  */
 196 static unsigned int connection_count;
 197
 198 /**
 199  * Target number of connections.
 200  */
 201 static unsigned int target_connection_count;
 202
 203 /**
 204  * Number of friends that we are currently connected to.
 205  */
 206 static unsigned int friend_count;
 207
 208 /**
 209  * Should the topology daemon try to establish connections?
 210  */
 211 static int autoconnect;
 212
 213 /**
 214  * Are we currently having a request pending with
 215  * PEERINFO asking for HELLOs for advertising?
 216  */
 217 static int hello_gathering_active;
 218
 219
 220
 221 /**
 222  * Force a disconnect from the specified peer.
 223  */
 224 static void
 225 force_disconnect (const struct GNUNET_PeerIdentity *peer)
 226 {
 227   GNUNET_CORE_peer_configure (handle,
 228                               peer,
 229                               GNUNET_TIME_UNIT_FOREVER_REL,
 230                               0,
 231                               0,
 232                               0,
 233                               NULL,
 234                               NULL);
 235 }
 236
 237
 238 /**
 239  * Function called by core when our attempt to connect
 240  * succeeded.  Does nothing.
 241  */
 242 static size_t
 243 ready_callback (void *cls,
 244                 size_t size, void *buf)
 245 {
 246   return 0;
 247 }
 248
 249
 250 /**
 251  * Try to connect to the specified peer.
 252  *
 253  * @param pos NULL if not in friend list yet
 254  */
 255 static void
 256 attempt_connect (const struct GNUNET_PeerIdentity *peer,
 257                  struct PeerList *pos)
 258 {
 259   if (pos == NULL)
 260     {
 261       pos = friends;
 262       while (pos != NULL)
 263         {
 264           if (0 == memcmp (&pos->id, peer, sizeof (struct GNUNET_PeerIdentity)))
 265             break;
 266         }
 267     }
 268   if (pos == NULL)
 269     {
 270       pos = GNUNET_malloc (sizeof(struct PeerList));
 271       pos->id = *peer;
 272       pos->next = friends;
 273       friends = pos;
 274     }
 275   if (GNUNET_YES == pos->is_friend)
 276     pos->blacklisted_until = GNUNET_TIME_relative_to_absolute (BLACKLIST_AFTER_ATTEMPT_FRIEND);
 277   else
 278     pos->blacklisted_until = GNUNET_TIME_relative_to_absolute (BLACKLIST_AFTER_ATTEMPT);
 279   GNUNET_CORE_notify_transmit_ready (handle,
 280                                      0 /* priority */,
 281                                      GNUNET_TIME_UNIT_MINUTES,
 282                                      peer,
 283                                      sizeof(struct GNUNET_MessageHeader),
 284                                      &ready_callback,
 285                                      NULL);
 286 }
 287
 288
 289 /**
 290  * Is this peer one of our friends?
 291  */
 292 static int
 293 is_friend (const struct GNUNET_PeerIdentity * peer)
 294 {
 295   struct PeerList *pos;
 296
 297   pos = friends;
 298   while (pos != NULL)
 299     {
 300       if ( (GNUNET_YES == pos->is_friend) &&
 301            (0 == memcmp (&pos->id, peer, sizeof (struct GNUNET_PeerIdentity))) )
 302         return GNUNET_YES;
 303       pos = pos->next;
 304     }
 305   return GNUNET_NO;
 306 }
 307
 308
 309 /**
 310  * Check if an additional connection from the given peer is allowed.
 311  */
 312 static int
 313 is_connection_allowed (const struct GNUNET_PeerIdentity * peer)
 314 {
 315   if (0 == memcmp (&my_identity, peer, sizeof (struct GNUNET_PeerIdentity)))
 316     return GNUNET_SYSERR;       /* disallow connections to self */
 317   if (is_friend (peer))
 318     return GNUNET_OK;
 319   if (GNUNET_YES == friends_only)
 320     return GNUNET_SYSERR;
 321   if (friend_count >= minimum_friend_count)
 322     return GNUNET_OK;
 323   return GNUNET_SYSERR;
 324 }
 325
 326
 327 /**
 328  * Method called whenever a peer connects.
 329  *
 330  * @param cls closure
 331  * @param peer peer identity this notification is about
 332  */
 333 static void connect_notify (void *cls,
 334                             const struct
 335                             GNUNET_PeerIdentity * peer)
 336 {
 337   struct PeerList *pos;
 338
 339   connection_count++;
 340   pos = friends;
 341   while (pos != NULL)
 342     {
 343       if ( (GNUNET_YES == pos->is_friend) &&
 344            (0 == memcmp (&pos->id, peer, sizeof (struct GNUNET_PeerIdentity))) )
 345         {
 346           GNUNET_assert (GNUNET_NO == pos->is_connected);
 347           pos->is_connected = GNUNET_YES;
 348           pos->blacklisted_until.value = 0; /* remove blacklisting */
 349           friend_count++;
 350           return;
 351         }
 352       pos = pos->next;
 353     }
 354   pos = GNUNET_malloc (sizeof(struct PeerList));
 355   pos->id = *peer;
 356   pos->is_connected = GNUNET_YES;
 357   pos->next = friends;
 358   friends = pos;
 359   if (GNUNET_OK != is_connection_allowed (peer))
 360     force_disconnect (peer);
 361 }
 362
 363
 364 /**
 365  * Disconnect from all non-friends (we're below quota).
 366  */
 367 static void
 368 drop_non_friends ()
 369 {
 370   struct PeerList *pos;
 371
 372   pos = friends;
 373   while (pos != NULL)
 374     {
 375       if (GNUNET_NO == pos->is_friend)
 376         {
 377           GNUNET_assert (GNUNET_YES == pos->is_connected);
 378           force_disconnect (&pos->id);
 379         }
 380       pos = pos->next;
 381     }
 382 }
 383
 384
 385 /**
 386  * Method called whenever a peer disconnects.
 387  *
 388  * @param cls closure
 389  * @param peer peer identity this notification is about
 390  */
 391 static void disconnect_notify (void *cls,
 392                                const struct
 393                                GNUNET_PeerIdentity * peer)
 394 {
 395   struct PeerList *pos;
 396   struct PeerList *prev;
 397
 398   connection_count--;
 399   pos = friends;
 400   prev = NULL;
 401   while (pos != NULL)
 402     {
 403       if (0 == memcmp (&pos->id, peer, sizeof (struct GNUNET_PeerIdentity)))
 404         {
 405           GNUNET_assert (GNUNET_YES == pos->is_connected);
 406           pos->is_connected = GNUNET_NO;
 407           if (GNUNET_YES == pos->is_friend)
 408             {
 409               friend_count--;
 410               if (friend_count < minimum_friend_count)
 411                 {
 412                   /* disconnect from all non-friends */
 413                   drop_non_friends ();
 414                   attempt_connect (peer, pos);
 415                 }
 416             }
 417           else
 418             {
 419               /* free entry */
 420               if (prev == NULL)
 421                 friends = pos->next;
 422               else
 423                 prev->next = pos->next;
 424               GNUNET_free (pos);
 425             }
 426           return;
 427         }
 428       prev = pos;
 429       pos = pos->next;
 430     }
 431   GNUNET_break (0);
 432 }
 433
 434
 435 /**
 436  * Find more peers that we should connect to and ask the
 437  * core to establish connections.
 438  */
 439 static void
 440 find_more_peers (void *cls,
 441                  const struct GNUNET_SCHEDULER_TaskContext *tc);
 442
 443
 444 /**
 445  * Determine when we should try again to find more peers and
 446  * schedule the task.
 447  */
 448 static void
 449 schedule_peer_search ()
 450 {
 451   struct GNUNET_TIME_Relative delay;
 452
 453   /* Typically, we try again every 15 minutes; the minimum period is
 454      15s; if we are above the connection target, we reduce re-trying
 455      by the square of how much we are above; so for example, with 200%
 456      of the connection target we would only look for more peers once
 457      every hour (after all, we're quite busy processing twice as many
 458      connections as we intended to have); similarly, if we are at only
 459      25% of our connectivity goal, we will try 16x as hard to connect
 460      (so roughly once a minute, plus the 15s minimum delay */
 461   delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
 462                                          15 + 15 * 60 * connection_count * connection_count / target_connection_count / target_connection_count);
 463   GNUNET_SCHEDULER_add_delayed (sched,
 464                                 GNUNET_NO,
 465                                 GNUNET_SCHEDULER_PRIORITY_DEFAULT,
 466                                 GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
 467                                 delay,
 468                                 &find_more_peers,
 469                                 NULL);
 470 }
 471
 472
 473
 474
 475 /**
 476  * Iterator called on each address.
 477  *
 478  * @param cls flag that we will set if we see any addresses.
 479  */
 480 static int
 481 address_iterator (void *cls,
 482                   const char *tname,
 483                   struct GNUNET_TIME_Absolute expiration,
 484                   const void *addr, size_t addrlen)
 485 {
 486   int *flag = cls;
 487   *flag = GNUNET_YES;
 488   return GNUNET_SYSERR;
 489 }
 490
 491
 492 /**
 493  * We've gotten a HELLO from another peer.
 494  * Consider it for advertising.
 495  */
 496 static void
 497 consider_for_advertising (const struct GNUNET_HELLO_Message *hello)
 498 {
 499   int have_address;
 500   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
 501   struct GNUNET_PeerIdentity pid;
 502   struct HelloList *pos;
 503   uint16_t size;
 504
 505   have_address = GNUNET_NO;
 506   GNUNET_HELLO_iterate_addresses (hello,
 507                                   GNUNET_NO,
 508                                   &address_iterator,
 509                                   &have_address);
 510   if (GNUNET_NO == have_address)
 511     return; /* no point in advertising this one... */
 512   GNUNET_HELLO_get_key (hello, &pkey);
 513   GNUNET_CRYPTO_hash (&pkey, sizeof (pkey), &pid.hashPubKey);
 514   pos = hellos;
 515   while (pos != NULL)
 516     {
 517       if (0 == memcmp (&pos->id,
 518                        &pid,
 519                        sizeof(struct GNUNET_PeerIdentity)))
 520         return; /* duplicate, at least "mostly" */
 521       pos = pos->next;
 522     }
 523   size = GNUNET_HELLO_size (hello);
 524   pos = GNUNET_malloc (sizeof(struct HelloList) + size);
 525   pos->msg = (struct GNUNET_HELLO_Message*) &pos[1];
 526   memcpy (&pos->msg, hello, size);
 527   pos->id = pid;
 528   pos->expiration = GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_FREQUENCY);
 529   /* 2^{-5} chance of not sending a HELLO to a peer is
 530      acceptably small (if the filter is 50% full);
 531      64 bytes of memory are small compared to the rest
 532      of the data structure and would only really become
 533      "useless" once a HELLO has been passed on to ~100
 534      other peers, which is likely more than enough in
 535      any case; hence 64, 5 as bloomfilter parameters. */
 536   pos->filter = GNUNET_CONTAINER_bloomfilter_load (NULL, 64, 5);
 537   /* never send a peer its own HELLO */
 538   GNUNET_CONTAINER_bloomfilter_add (pos->filter, &pos->id.hashPubKey);
 539   pos->next = hellos;
 540   hellos = pos;
 541 }
 542
 543
 544 /**
 545  * Peerinfo calls this function to let us know about a
 546  * possible peer that we might want to connect to.
 547  */
 548 static void
 549 process_peer (void *cls,
 550               const struct GNUNET_PeerIdentity *peer,
 551               const struct GNUNET_HELLO_Message *hello,
 552               uint32_t trust)
 553 {
 554   struct PeerList *pos;
 555
 556   if (peer == NULL)
 557     {
 558       /* last call, schedule 'find_more_peers' again... */
 559       schedule_peer_search ();
 560       return;
 561     }
 562   if (hello == NULL)
 563     {
 564       /* no HELLO known; can not connect, ignore! */
 565       return;
 566     }
 567   if (0 == memcmp (&my_identity,
 568                    peer, sizeof (struct GNUNET_PeerIdentity)))
 569     return;  /* that's me! */
 570
 571   consider_for_advertising (hello);
 572   pos = friends;
 573   while (pos != NULL)
 574     {
 575       if (0 == memcmp (&pos->id, peer, sizeof (struct GNUNET_PeerIdentity)))
 576         {
 577           if (GNUNET_YES == pos->is_connected)
 578             return;
 579           if (GNUNET_TIME_absolute_get_remaining (pos->blacklisted_until).value > 0)
 580             return; /* peer still blacklisted */
 581           if (GNUNET_YES == pos->is_friend)
 582             {
 583               attempt_connect (peer, pos);
 584               return;
 585             }
 586         }
 587       pos = pos->next;
 588     }
 589   if (GNUNET_YES == friends_only)
 590     return;
 591   if (friend_count < minimum_friend_count)
 592     return;
 593   attempt_connect (peer, NULL);
 594 }
 595
 596
 597 /**
 598  * Try to add more friends to our connection set.
 599  */
 600 static void
 601 try_add_friends ()
 602 {
 603   struct PeerList *pos;
 604
 605   pos = friends;
 606   while (pos != NULL)
 607     {
 608       if ( (GNUNET_TIME_absolute_get_remaining (pos->blacklisted_until).value == 0) &&
 609            (GNUNET_YES == pos->is_friend) &&
 610            (GNUNET_YES != pos->is_connected) )
 611         attempt_connect (&pos->id, pos);
 612       pos = pos->next;
 613     }
 614 }
 615
 616
 617 /**
 618  * Discard peer entries for blacklisted peers
 619  * where the blacklisting has expired.
 620  */
 621 static void
 622 discard_old_blacklist_entries ()
 623 {
 624   struct PeerList *pos;
 625   struct PeerList *next;
 626   struct PeerList *prev;
 627
 628   next = friends;
 629   prev = NULL;
 630   while (NULL != (pos = next))
 631     {
 632       next = pos->next;
 633       if ( (GNUNET_NO == pos->is_friend) &&
 634            (GNUNET_NO == pos->is_connected) &&
 635            (0 == GNUNET_TIME_absolute_get_remaining (pos->blacklisted_until).value) )
 636         {
 637           /* delete 'pos' from list */
 638           if (prev == NULL)
 639             friends = next;
 640           else
 641             prev->next = next;
 642           GNUNET_free (pos);
 643         }
 644       else
 645         {
 646           prev = pos;
 647         }
 648     }
 649 }
 650
 651
 652 /**
 653  * Find more peers that we should connect to and ask the
 654  * core to establish connections.
 655  */
 656 static void
 657 find_more_peers (void *cls,
 658                  const struct GNUNET_SCHEDULER_TaskContext *tc)
 659 {
 660   discard_old_blacklist_entries ();
 661   if (target_connection_count <= connection_count)
 662     {
 663       schedule_peer_search ();
 664       return;
 665     }
 666   if ( (GNUNET_YES == friends_only) ||
 667        (friend_count < minimum_friend_count) )
 668     {
 669       try_add_friends ();
 670       schedule_peer_search ();
 671       return;
 672     }
 673   GNUNET_PEERINFO_for_all (cfg,
 674                            sched,
 675                            NULL,
 676                            0, GNUNET_TIME_UNIT_FOREVER_REL,
 677                            &process_peer, NULL);
 678 }
 679
 680
 681 /**
 682  * Function called after GNUNET_CORE_connect has succeeded
 683  * (or failed for good).
 684  *
 685  * @param cls closure
 686  * @param server handle to the server, NULL if we failed
 687  * @param my_id ID of this peer, NULL if we failed
 688  * @param publicKey public key of this peer, NULL if we failed
 689  */
 690 static void
 691 core_init (void *cls,
 692            struct GNUNET_CORE_Handle * server,
 693            const struct GNUNET_PeerIdentity *
 694            my_id,
 695            const struct
 696            GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *
 697            publicKey)
 698 {
 699   if (server == NULL)
 700     {
 701       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 702                   _("Failed to connect to core service, can not manage topology!\n"));
 703       return;
 704     }
 705   handle = server;
 706   my_identity = *my_id;
 707   if (autoconnect)
 708     GNUNET_SCHEDULER_add_delayed (sched,
 709                                   GNUNET_NO,
 710                                   GNUNET_SCHEDULER_PRIORITY_DEFAULT,
 711                                   GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
 712                                   GNUNET_TIME_UNIT_SECONDS /* give core time to tell us about existing connections */,
 713                                   &find_more_peers,
 714                                   NULL);
 715 }
 716
 717
 718 /**
 719  * gnunet-daemon-topology command line options.
 720  */
 721 static struct GNUNET_GETOPT_CommandLineOption options[] = {
 722   GNUNET_GETOPT_OPTION_END
 723 };
 724
 725
 726 /**
 727  * Read the friends file.
 728  */
 729 static void
 730 read_friends_file (struct GNUNET_CONFIGURATION_Handle *cfg)
 731 {
 732   char *fn;
 733   char *data;
 734   size_t pos;
 735   GNUNET_HashCode hc;
 736   struct stat frstat;
 737   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
 738   unsigned int entries_found;
 739   struct PeerList *fl;
 740
 741   fn = NULL;
 742   GNUNET_CONFIGURATION_get_value_filename (cfg,
 743                                            "TOPOLOGY",
 744                                            "FRIENDS",
 745                                            &fn);
 746   if (GNUNET_OK != GNUNET_DISK_file_test (fn))
 747     GNUNET_DISK_fn_write (fn, NULL, 0, "600");
 748   if (0 != STAT (fn, &frstat))
 749     {
 750       if ((friends_only) || (minimum_friend_count > 0))
 751         {
 752           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 753                       _("Could not read friends list `%s'\n"), fn);
 754           GNUNET_free (fn);
 755           return;
 756         }
 757     }
 758   if (frstat.st_size == 0)
 759     {
 760       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 761                   _("Friends file `%s' is empty.\n"),
 762                   fn);
 763       GNUNET_free (fn);
 764       return;
 765     }
 766   data = GNUNET_malloc_large (frstat.st_size);
 767   if (frstat.st_size !=
 768       GNUNET_DISK_fn_read (fn, data, frstat.st_size))
 769     {
 770       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 771                   _("Failed to read friends list from `%s'\n"), fn);
 772       GNUNET_free (fn);
 773       GNUNET_free (data);
 774       return;
 775     }
 776   entries_found = 0;
 777   pos = 0;
 778   while ((pos < frstat.st_size) && isspace (data[pos]))
 779     pos++;
 780   while ((frstat.st_size >= sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)) &&
 781          (pos <= frstat.st_size - sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)))
 782     {
 783       memcpy (&enc, &data[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
 784       if (!isspace (enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1]))
 785         {
 786           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 787                       _("Syntax error in topology specification at offset %llu, skipping bytes.\n"),
 788                       (unsigned long long) pos);
 789           pos++;
 790           while ((pos < frstat.st_size) && (!isspace (data[pos])))
 791             pos++;
 792           continue;
 793         }
 794       enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
 795       if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((char *) &enc, &hc))
 796         {
 797           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 798                       _("Syntax error in topology specification at offset %llu, skipping bytes `%s'.\n"),
 799                       (unsigned long long) pos,
 800                       &enc);
 801         }
 802       else
 803         {
 804           entries_found++;
 805           fl = GNUNET_malloc (sizeof(struct PeerList));
 806           fl->is_friend = GNUNET_YES;
 807           fl->id.hashPubKey = hc;
 808           fl->next = friends;
 809           friends = fl;
 810         }
 811       pos = pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded);
 812       while ((pos < frstat.st_size) && isspace (data[pos]))
 813         pos++;
 814     }
 815   GNUNET_free (data);
 816   GNUNET_free (fn);
 817   if ( (minimum_friend_count > entries_found) &&
 818        (friends_only == GNUNET_NO) )
 819     {
 820       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 821                   _("Fewer friends specified than required by minimum friend count. Will only connect to friends.\n"));
 822     }
 823   if ( (minimum_friend_count > target_connection_count) &&
 824        (friends_only == GNUNET_NO) )
 825     {
 826       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 827                   _("More friendly connections required than target total number of connections.\n"));
 828     }
 829 }
 830
 831
 832 /**
 833  * This function is called whenever an encrypted HELLO message is
 834  * received.
 835  *
 836  * @param cls closure
 837  * @param peer the other peer involved (sender or receiver, NULL
 838  *        for loopback messages where we are both sender and receiver)
 839  * @param message the actual HELLO message
 840  * @return GNUNET_OK to keep the connection open,
 841  *         GNUNET_SYSERR to close it (signal serious error)
 842  */
 843 static int
 844 handle_encrypted_hello (void *cls,
 845                         const struct GNUNET_PeerIdentity * other,
 846                         const struct GNUNET_MessageHeader *
 847                         message)
 848 {
 849   if (transport != NULL)
 850     GNUNET_TRANSPORT_offer_hello (transport,
 851                                   message);
 852   return GNUNET_OK;
 853 }
 854
 855
 856 /**
 857  * Peerinfo calls this function to let us know about a
 858  * possible peer that we might want to connect to.
 859  */
 860 static void
 861 gather_hello_callback (void *cls,
 862                        const struct GNUNET_PeerIdentity *peer,
 863                        const struct GNUNET_HELLO_Message *hello,
 864                        uint32_t trust)
 865 {
 866   if (peer == NULL)
 867     {
 868       hello_gathering_active = GNUNET_NO;
 869       return;
 870     }
 871   if (hello != NULL)
 872     consider_for_advertising (hello);
 873 }
 874
 875
 876 /**
 877  * Function to fill send buffer with HELLO.
 878  *
 879  * @param receiver the receiver of the message
 880  * @param position is the reference to the
 881  *        first unused position in the buffer where GNUnet is building
 882  *        the message
 883  * @param padding is the number of bytes left in that buffer.
 884  * @return the number of bytes written to
 885  *   that buffer (must be a positive number).
 886  */
 887 static unsigned int
 888 hello_advertising (void *cls,
 889                    const struct GNUNET_PeerIdentity *
 890                    receiver,
 891                    void *position, unsigned int padding)
 892 {
 893   struct PeerList *pl;
 894   struct HelloList *pos;
 895   struct HelloList *prev;
 896   struct HelloList *next;
 897   uint16_t size;
 898
 899   pl = friends;
 900   while (pl != NULL)
 901     {
 902       if (0 == memcmp (&pl->id, receiver, sizeof (struct GNUNET_PeerIdentity)))
 903         break;
 904       pl = pl->next;
 905     }
 906   if (pl == NULL)
 907     {
 908       GNUNET_break (0);
 909       return 0;
 910     }
 911   /* find applicable HELLOs */
 912   prev = NULL;
 913   next = hellos;
 914   while (NULL != (pos = next))
 915     {
 916       next = pos->next;
 917       if (GNUNET_NO ==
 918           GNUNET_CONTAINER_bloomfilter_test (pos->filter,
 919                                              &receiver->hashPubKey))
 920         break;
 921       if (0 == GNUNET_TIME_absolute_get_remaining (pos->expiration).value)
 922         {
 923           /* time to discard... */
 924           if (prev == NULL)
 925             prev->next = next;
 926           else
 927             hellos = next;
 928           GNUNET_CONTAINER_bloomfilter_free (pos->filter);
 929           GNUNET_free (pos);
 930         }
 931       else
 932         {
 933           prev = pos;
 934         }
 935     }
 936   if (pos != NULL)
 937     {
 938       size = GNUNET_HELLO_size (pos->msg);
 939       if (size < padding)
 940         {
 941           memcpy (position, pos->msg, size);
 942           GNUNET_CONTAINER_bloomfilter_add (pos->filter,
 943                                             &receiver->hashPubKey);
 944         }
 945       else
 946         {
 947           size = 0;
 948         }
 949       return size;
 950     }
 951   if ( (GNUNET_NO == hello_gathering_active) &&
 952        (GNUNET_TIME_absolute_get_duration (last_hello_gather_time).value >
 953         MIN_HELLO_GATHER_DELAY.value) )
 954     {
 955       hello_gathering_active = GNUNET_YES;
 956       last_hello_gather_time = GNUNET_TIME_absolute_get();
 957       GNUNET_PEERINFO_for_all (cfg,
 958                                sched,
 959                                NULL,
 960                                0, GNUNET_TIME_UNIT_FOREVER_REL,
 961                                &gather_hello_callback, NULL);
 962     }
 963   return 0;
 964 }
 965
 966
 967 /**
 968  * Last task run during shutdown.  Disconnects us from
 969  * the transport and core.
 970  */
 971 static void
 972 cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 973 {
 974   struct PeerList *pl;
 975
 976   GNUNET_TRANSPORT_disconnect (transport);
 977   transport = NULL;
 978   GNUNET_CORE_disconnect (handle);
 979   handle = NULL;
 980   while (NULL != (pl = friends))
 981     {
 982       friends = pl->next;
 983       GNUNET_free (pl);
 984     }
 985 }
 986
 987
 988 /**
 989  * Main function that will be run.
 990  *
 991  * @param cls closure
 992  * @param s the scheduler to use
 993  * @param args remaining command-line arguments
 994  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 995  * @param c configuration
 996  */
 997 static void
 998 run (void *cls,
 999      struct GNUNET_SCHEDULER_Handle * s,
1000      char *const *args,
1001      const char *cfgfile,
1002      struct GNUNET_CONFIGURATION_Handle * c)
1003 {
1004   struct GNUNET_CORE_MessageHandler handlers[] =
1005     {
1006       { &handle_encrypted_hello, GNUNET_MESSAGE_TYPE_HELLO, 0},
1007       { NULL, 0, 0 }
1008     };
1009   unsigned long long opt;
1010
1011   sched = s;
1012   cfg = c;
1013   autoconnect = GNUNET_CONFIGURATION_get_value_yesno (cfg,
1014                                                       "TOPOLOGY",
1015                                                       "AUTOCONNECT");
1016   friends_only = GNUNET_CONFIGURATION_get_value_yesno (cfg,
1017                                                        "TOPOLOGY",
1018                                                        "FRIENDS-ONLY");
1019   opt = 0;
1020   GNUNET_CONFIGURATION_get_value_number (cfg,
1021                                          "TOPOLOGY",
1022                                          "MINIMUM-FRIENDS",
1023                                          &opt);
1024   minimum_friend_count = (unsigned int) opt;
1025   opt = 16;
1026   GNUNET_CONFIGURATION_get_value_number (cfg,
1027                                          "TOPOLOGY",
1028                                          "TARGET-CONNECTION-COUNT",
1029                                          &opt);
1030   target_connection_count = (unsigned int) opt;
1031
1032   if ( (friends_only == GNUNET_YES) ||
1033        (minimum_friend_count > 0) )
1034     read_friends_file (cfg);
1035
1036   transport = GNUNET_TRANSPORT_connect (sched,
1037                                         cfg,
1038                                         NULL,
1039                                         NULL,
1040                                         NULL,
1041                                         NULL);
1042   GNUNET_CORE_connect (sched,
1043                        cfg,
1044                        GNUNET_TIME_UNIT_FOREVER_REL,
1045                        NULL,
1046                        &core_init,
1047                        &connect_notify,
1048                        &disconnect_notify,
1049                        &hello_advertising,
1050                        NULL, GNUNET_NO,
1051                        NULL, GNUNET_NO,
1052                        handlers);
1053
1054   GNUNET_SCHEDULER_add_delayed (sched,
1055                                 GNUNET_YES,
1056                                 GNUNET_SCHEDULER_PRIORITY_IDLE,
1057                                 GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
1058                                 GNUNET_TIME_UNIT_FOREVER_REL,
1059                                 &cleaning_task, NULL);
1060 }
1061
1062
1063 /**
1064  * The main function for the topology daemon.
1065  *
1066  * @param argc number of arguments from the command line
1067  * @param argv command line arguments
1068  * @return 0 ok, 1 on error
1069  */
1070 int
1071 main (int argc, char *const *argv)
1072 {
1073   int ret;
1074
1075   ret = (GNUNET_OK ==
1076          GNUNET_PROGRAM_run (argc,
1077                              argv,
1078                              "topology",
1079                              _("GNUnet topology control (maintaining P2P mesh and F2F constraints)"),
1080                              options,
1081                              &run, NULL)) ? 0 : 1;
1082   return ret;
1083 }
1084
1085 /* end of gnunet-daemon-topology.c */