gnunet-service-transport_hello.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2010,2011 GNUnet e.V.
 
     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.
 
     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
 
#include "platform.h"
#include "gnunet_constants.h"
#include "gnunet_hello_lib.h"
#include "gnunet_peerinfo_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet-service-transport_hello.h"
#include "gnunet-service-transport.h"
#include "gnunet-service-transport_plugins.h"
 
 
#define HELLO_REFRESH_PERIOD GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_HOURS, 6)
 
extern struct GNUNET_TIME_Relative hello_expiration;
 
 
struct OwnAddressList
{
  struct OwnAddressList *next;
 
  struct OwnAddressList *prev;
 
  struct GNUNET_HELLO_Address *address;
 
  struct GNUNET_TIME_Absolute pong_sig_expires;
 
  struct GNUNET_CRYPTO_EddsaSignature pong_signature;
 
  unsigned int rc;
};
 
 
static struct GNUNET_HELLO_Message *our_hello;
 
static GST_HelloCallback hello_cb;
 
static void *hello_cb_cls;
 
static struct OwnAddressList *oal_head;
 
static struct OwnAddressList *oal_tail;
 
static int friend_option;
 
static struct GNUNET_SCHEDULER_Task *hello_task;
 
 
struct GeneratorContext
{
  struct OwnAddressList *addr_pos;
 
  struct GNUNET_TIME_Absolute expiration;
};
 
 
static ssize_t
address_generator (void *cls,
                   size_t max,
                   void *buf)
{
  struct GeneratorContext *gc = cls;
  ssize_t ret;
 
  if (NULL == gc->addr_pos)
    return GNUNET_SYSERR; /* Done */
  ret = GNUNET_HELLO_add_address (gc->addr_pos->address,
                                  gc->expiration,
                                  buf,
                                  max);
  gc->addr_pos = gc->addr_pos->next;
  return ret;
}
 
 
static void
refresh_hello_task (void *cls)
{
  struct GeneratorContext gc;
 
  hello_task = NULL;
  gc.addr_pos = oal_head;
  gc.expiration = GNUNET_TIME_relative_to_absolute (hello_expiration);
 
  GNUNET_free (our_hello);
  our_hello = GNUNET_HELLO_create (&GST_my_identity.public_key,
                                   &address_generator,
                                   &gc,
                                   friend_option);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Refreshed my %s HELLO, new size is %d\n",
              (GNUNET_YES == friend_option) ? "friend-only" : "public",
              GNUNET_HELLO_size (our_hello));
  GNUNET_STATISTICS_update (GST_stats,
                            gettext_noop ("# refreshed my HELLO"),
                            1,
                            GNUNET_NO);
  if (NULL != hello_cb)
    hello_cb (hello_cb_cls,
              GST_hello_get ());
  GNUNET_PEERINFO_add_peer (GST_peerinfo,
                            our_hello,
                            NULL,
                            NULL);
  hello_task =
    GNUNET_SCHEDULER_add_delayed (HELLO_REFRESH_PERIOD,
                                  &refresh_hello_task,
                                  NULL);
}
 
 
static void
refresh_hello ()
{
  if (NULL != hello_task)
  {
    GNUNET_SCHEDULER_cancel (hello_task);
    hello_task = GNUNET_SCHEDULER_add_now (&refresh_hello_task,
                                           NULL);
  }
}
 
 
void
GST_hello_start (int friend_only,
                 GST_HelloCallback cb,
                 void *cb_cls)
{
  hello_cb = cb;
  hello_cb_cls = cb_cls;
  friend_option = friend_only;
  refresh_hello_task (NULL);
}
 
 
void
GST_hello_stop ()
{
  hello_cb = NULL;
  hello_cb_cls = NULL;
  if (NULL != hello_task)
  {
    GNUNET_SCHEDULER_cancel (hello_task);
    hello_task = NULL;
  }
  if (NULL != our_hello)
  {
    GNUNET_free (our_hello);
    our_hello = NULL;
  }
}
 
 
const struct GNUNET_MessageHeader *
GST_hello_get ()
{
  return (const struct GNUNET_MessageHeader *) our_hello;
}
 
 
void
GST_hello_modify_addresses (int addremove,
                            const struct GNUNET_HELLO_Address *address)
{
  struct OwnAddressList *al;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              (GNUNET_YES == addremove)
              ? "Adding `%s' to the set of our addresses\n"
              : "Removing `%s' from the set of our addresses\n",
              GST_plugins_a2s (address));
  GNUNET_assert (NULL != address);
  for (al = oal_head; al != NULL; al = al->next)
    if (0 == GNUNET_HELLO_address_cmp (address, al->address))
      break;
  if (GNUNET_NO == addremove)
  {
    if (NULL == al)
    {
      /* address to be removed not found!? */
      GNUNET_break (0);
      return;
    }
    al->rc--;
    if (0 != al->rc)
      return;   /* RC not yet zero */
    GNUNET_CONTAINER_DLL_remove (oal_head,
                                 oal_tail,
                                 al);
    GNUNET_HELLO_address_free (al->address);
    GNUNET_free (al);
    refresh_hello ();
    return;
  }
  if (NULL != al)
  {
    /* address added twice or more */
    al->rc++;
    return;
  }
  al = GNUNET_new (struct OwnAddressList);
  al->rc = 1;
  GNUNET_CONTAINER_DLL_insert (oal_head,
                               oal_tail,
                               al);
  al->address = GNUNET_HELLO_address_copy (address);
  refresh_hello ();
}
 
 
int
GST_hello_test_address (const struct GNUNET_HELLO_Address *address,
                        struct GNUNET_CRYPTO_EddsaSignature **sig,
                        struct GNUNET_TIME_Absolute **sig_expiration)
{
  struct OwnAddressList *al;
 
  for (al = oal_head; al != NULL; al = al->next)
    if (0 == GNUNET_HELLO_address_cmp (address,
                                       al->address))
    {
      *sig = &al->pong_signature;
      *sig_expiration = &al->pong_sig_expires;
      return GNUNET_YES;
    }
  *sig = NULL;
  *sig_expiration = NULL;
  return GNUNET_NO;
}
 
 
/* end of file gnunet-service-transport_hello.c */