namestore_api_monitor.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2013, 2016, 2018 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_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_arm_service.h"
#include "gnunet_signatures.h"
#include "gnunet_namestore_service.h"
#include "namestore.h"
 
 
struct GNUNET_NAMESTORE_ZoneMonitor
{
  const struct GNUNET_CONFIGURATION_Handle *cfg;
 
  struct GNUNET_MQ_Handle *mq;
 
  GNUNET_SCHEDULER_TaskCallback error_cb;
 
  void *error_cb_cls;
 
  GNUNET_NAMESTORE_RecordMonitor monitor;
 
  GNUNET_NAMESTORE_RecordSetMonitor monitor2;
 
  enum GNUNET_GNSRECORD_Filter filter;
 
  void *monitor_cls;
 
  GNUNET_SCHEDULER_TaskCallback sync_cb;
 
  void *sync_cb_cls;
 
  struct GNUNET_IDENTITY_PrivateKey zone;
 
  int iterate_first;
 
  uint32_t key_len;
};
 
 
static void
reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm);
 
 
static void
handle_sync (void *cls, const struct GNUNET_MessageHeader *msg)
{
  struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
 
  (void) cls;
  (void) msg;
  if (NULL != zm->sync_cb)
    zm->sync_cb (zm->sync_cb_cls);
}
 
 
static int
check_result (void *cls, const struct RecordResultMessage *lrm)
{
  struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
  size_t lrm_len;
  size_t exp_lrm_len;
  size_t name_len;
  size_t rd_len;
  unsigned rd_count;
  const char *name_tmp;
  const char *rd_ser_tmp;
  size_t key_len;
 
  (void) zm;
  key_len = ntohs (lrm->key_len);
  (void) cls;
  if (0 == key_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  lrm_len = ntohs (lrm->gns_header.header.size);
  rd_len = ntohs (lrm->rd_len);
  rd_count = ntohs (lrm->rd_count);
  name_len = ntohs (lrm->name_len);
  if (name_len > MAX_NAME_LEN)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  exp_lrm_len = sizeof(struct RecordResultMessage) + name_len + rd_len + key_len;
  if (lrm_len != exp_lrm_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (0 == name_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  name_tmp = (const char *) &lrm[1] + key_len;
  if (name_tmp[name_len - 1] != '\0')
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  rd_ser_tmp = (const char *) &name_tmp[name_len];
  {
    struct GNUNET_GNSRECORD_Data rd[rd_count];
 
    if (GNUNET_OK !=
        GNUNET_GNSRECORD_records_deserialize (rd_len, rd_ser_tmp, rd_count, rd))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
  }
  return GNUNET_OK;
}
 
 
static void
handle_result (void *cls, const struct RecordResultMessage *lrm)
{
  struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
  struct GNUNET_IDENTITY_PrivateKey private_key;
  size_t name_len;
  size_t rd_len;
  size_t key_len;
  size_t kbytes_read;
  unsigned rd_count;
  const char *name_tmp;
  const char *rd_ser_tmp;
 
  key_len = ntohs (lrm->key_len);
  rd_len = ntohs (lrm->rd_len);
  rd_count = ntohs (lrm->rd_count);
  name_len = ntohs (lrm->name_len);
  name_tmp = (const char *) &lrm[1] + key_len;
  GNUNET_assert (GNUNET_SYSERR !=
                 GNUNET_IDENTITY_read_private_key_from_buffer (&lrm[1],
                                                               key_len,
                                                               &private_key,
                                                               &kbytes_read));
  GNUNET_assert (kbytes_read == key_len);
  rd_ser_tmp = (const char *) &name_tmp[name_len];
  {
    struct GNUNET_GNSRECORD_Data rd[rd_count];
 
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_GNSRECORD_records_deserialize (rd_len, rd_ser_tmp, rd_count, rd));
    if (NULL != zm->monitor2)
      zm->monitor2 (zm->monitor_cls, &private_key, name_tmp,
                    rd_count, rd, GNUNET_TIME_absolute_ntoh (lrm->expire));
    else
      zm->monitor (zm->monitor_cls, &private_key, name_tmp, rd_count, rd);
  }
}
 
 
static void
mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
{
  struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
 
  (void) error;
  reconnect (zm);
}
 
 
static void
reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
{
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_fixed_size (sync,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC,
                             struct GNUNET_MessageHeader,
                             zm),
    GNUNET_MQ_hd_var_size (result,
                           GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT,
                           struct RecordResultMessage,
                           zm),
    GNUNET_MQ_handler_end () };
  struct GNUNET_MQ_Envelope *env;
  struct ZoneMonitorStartMessage *sm;
 
  if (NULL != zm->mq)
  {
    GNUNET_MQ_destroy (zm->mq);
    zm->error_cb (zm->error_cb_cls);
  }
  zm->mq = GNUNET_CLIENT_connect (zm->cfg,
                                  "namestore",
                                  handlers,
                                  &mq_error_handler,
                                  zm);
  if (NULL == zm->mq)
    return;
  env = GNUNET_MQ_msg_extra (sm,
                             zm->key_len,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START);
  sm->iterate_first = htonl (zm->iterate_first);
  if (0 < zm->key_len)
    GNUNET_IDENTITY_write_private_key_to_buffer (&zm->zone,
                                               &sm[1],
                                               zm->key_len);
  sm->key_len = htons (zm->key_len);
  sm->filter = htons (zm->filter);
  GNUNET_MQ_send (zm->mq, env);
}
 
 
struct GNUNET_NAMESTORE_ZoneMonitor *
GNUNET_NAMESTORE_zone_monitor_start (
  const struct GNUNET_CONFIGURATION_Handle *cfg,
  const struct GNUNET_IDENTITY_PrivateKey *zone,
  int iterate_first,
  GNUNET_SCHEDULER_TaskCallback error_cb,
  void *error_cb_cls,
  GNUNET_NAMESTORE_RecordMonitor monitor,
  void *monitor_cls,
  GNUNET_SCHEDULER_TaskCallback sync_cb,
  void *sync_cb_cls)
{
  struct GNUNET_NAMESTORE_ZoneMonitor *zm;
 
  zm = GNUNET_new (struct GNUNET_NAMESTORE_ZoneMonitor);
  if (NULL != zone)
  {
    zm->key_len = GNUNET_IDENTITY_private_key_get_length (zone);
    zm->zone = *zone;
  }
  zm->iterate_first = iterate_first;
  zm->error_cb = error_cb;
  zm->error_cb_cls = error_cb_cls;
  zm->monitor = monitor;
  zm->monitor_cls = monitor_cls;
  zm->sync_cb = sync_cb;
  zm->sync_cb_cls = sync_cb_cls;
  zm->cfg = cfg;
  reconnect (zm);
  if (NULL == zm->mq)
  {
    GNUNET_free (zm);
    return NULL;
  }
  return zm;
}
 
struct GNUNET_NAMESTORE_ZoneMonitor *
GNUNET_NAMESTORE_zone_monitor_start2 (
  const struct GNUNET_CONFIGURATION_Handle *cfg,
  const struct GNUNET_IDENTITY_PrivateKey *zone,
  int iterate_first,
  GNUNET_SCHEDULER_TaskCallback error_cb,
  void *error_cb_cls,
  GNUNET_NAMESTORE_RecordSetMonitor monitor,
  void *monitor_cls,
  GNUNET_SCHEDULER_TaskCallback sync_cb,
  void *sync_cb_cls,
  enum GNUNET_GNSRECORD_Filter filter)
{
  struct GNUNET_NAMESTORE_ZoneMonitor *zm;
 
  zm = GNUNET_new (struct GNUNET_NAMESTORE_ZoneMonitor);
  if (NULL != zone)
  {
    zm->key_len = GNUNET_IDENTITY_private_key_get_length (zone);
    zm->zone = *zone;
  }
  zm->iterate_first = iterate_first;
  zm->error_cb = error_cb;
  zm->error_cb_cls = error_cb_cls;
  zm->monitor2 = monitor;
  zm->monitor_cls = monitor_cls;
  zm->sync_cb = sync_cb;
  zm->sync_cb_cls = sync_cb_cls;
  zm->cfg = cfg;
  zm->filter = filter;
  reconnect (zm);
  if (NULL == zm->mq)
  {
    GNUNET_free (zm);
    return NULL;
  }
  return zm;
}
 
 
void
GNUNET_NAMESTORE_zone_monitor_next (struct GNUNET_NAMESTORE_ZoneMonitor *zm,
                                    uint64_t limit)
{
  struct GNUNET_MQ_Envelope *env;
  struct ZoneMonitorNextMessage *nm;
 
  env = GNUNET_MQ_msg (nm, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT);
  nm->limit = GNUNET_htonll (limit);
  GNUNET_MQ_send (zm->mq, env);
}
 
 
void
GNUNET_NAMESTORE_zone_monitor_stop (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
{
  if (NULL != zm->mq)
  {
    GNUNET_MQ_destroy (zm->mq);
    zm->mq = NULL;
  }
  GNUNET_free (zm);
}
 
 
/* end of namestore_api_monitor.c */