src/namestore/namestore_api_monitor.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2013, 2016 GNUnet e.V.
   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 3, 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., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20
  21 /**
  22  * @file namestore/namestore_api_monitor.c
  23  * @brief API to monitor changes in the NAMESTORE
  24  * @author Christian Grothoff
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_crypto_lib.h"
  30 #include "gnunet_constants.h"
  31 #include "gnunet_dnsparser_lib.h"
  32 #include "gnunet_arm_service.h"
  33 #include "gnunet_signatures.h"
  34 #include "gnunet_namestore_service.h"
  35 #include "namestore.h"
  36
  37
  38 /**
  39  * Handle for a monitoring activity.
  40  */
  41 struct GNUNET_NAMESTORE_ZoneMonitor
  42 {
  43   /**
  44    * Configuration (to reconnect).
  45    */
  46   const struct GNUNET_CONFIGURATION_Handle *cfg;
  47
  48   /**
  49    * Handle to namestore service.
  50    */
  51   struct GNUNET_MQ_Handle *mq;
  52
  53   /**
  54    * Function to call on errors.
  55    */
  56   GNUNET_SCHEDULER_TaskCallback error_cb;
  57
  58   /**
  59    * Closure for @e error_cb.
  60    */
  61   void *error_cb_cls;
  62
  63   /**
  64    * Function to call on events.
  65    */
  66   GNUNET_NAMESTORE_RecordMonitor monitor;
  67
  68   /**
  69    * Closure for @e monitor.
  70    */
  71   void *monitor_cls;
  72
  73   /**
  74    * Function called when we've synchronized.
  75    */
  76   GNUNET_SCHEDULER_TaskCallback sync_cb;
  77
  78   /**
  79    * Closure for @e sync_cb.
  80    */
  81   void *sync_cb_cls;
  82
  83   /**
  84    * Monitored zone.
  85    */
  86   struct GNUNET_CRYPTO_EcdsaPrivateKey zone;
  87
  88   /**
  89    * Do we first iterate over all existing records?
  90    */
  91   int iterate_first;
  92
  93 };
  94
  95
  96 /**
  97  * Reconnect to the namestore service.
  98  *
  99  * @param zm monitor to reconnect
 100  */
 101 static void
 102 reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm);
 103
 104
 105 /**
 106  * Handle SYNC message from the namestore service.
 107  *
 108  * @param cls the monitor
 109  * @param msg the sync message
 110  */
 111 static void
 112 handle_sync (void *cls,
 113              const struct GNUNET_MessageHeader *msg)
 114 {
 115   struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
 116
 117   if (NULL != zm->sync_cb)
 118     zm->sync_cb (zm->sync_cb_cls);
 119 }
 120
 121
 122 /**
 123  * We've received a notification about a change to our zone.
 124  * Check that it is well-formed.
 125  *
 126  * @param cls the zone monitor handle
 127  * @param lrm the message from the service.
 128  */
 129 static int
 130 check_result (void *cls,
 131               const struct RecordResultMessage *lrm)
 132 {
 133   size_t lrm_len;
 134   size_t exp_lrm_len;
 135   size_t name_len;
 136   size_t rd_len;
 137   unsigned rd_count;
 138   const char *name_tmp;
 139   const char *rd_ser_tmp;
 140
 141   lrm_len = ntohs (lrm->gns_header.header.size);
 142   rd_len = ntohs (lrm->rd_len);
 143   rd_count = ntohs (lrm->rd_count);
 144   name_len = ntohs (lrm->name_len);
 145   exp_lrm_len = sizeof (struct RecordResultMessage) + name_len + rd_len;
 146   if (lrm_len != exp_lrm_len)
 147   {
 148     GNUNET_break (0);
 149     return GNUNET_SYSERR;
 150   }
 151   if (0 == name_len)
 152   {
 153     GNUNET_break (0);
 154     return GNUNET_SYSERR;
 155   }
 156   name_tmp = (const char *) &lrm[1];
 157   if ((name_tmp[name_len -1] != '\0') || (name_len > MAX_NAME_LEN))
 158   {
 159     GNUNET_break (0);
 160     return GNUNET_SYSERR;
 161   }
 162   rd_ser_tmp = (const char *) &name_tmp[name_len];
 163   {
 164     struct GNUNET_GNSRECORD_Data rd[rd_count];
 165
 166     if (GNUNET_OK !=
 167         GNUNET_GNSRECORD_records_deserialize (rd_len,
 168                                               rd_ser_tmp,
 169                                               rd_count,
 170                                               rd))
 171     {
 172       GNUNET_break (0);
 173       return GNUNET_SYSERR;
 174     }
 175   }
 176   return GNUNET_OK;
 177 }
 178
 179
 180 /**
 181  * We've received a notification about a change to our zone.
 182  * Forward to monitor callback.
 183  *
 184  * @param cls the zone monitor handle
 185  * @param lrm the message from the service.
 186  */
 187 static void
 188 handle_result (void *cls,
 189                const struct RecordResultMessage *lrm)
 190 {
 191   struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
 192   size_t name_len;
 193   size_t rd_len;
 194   unsigned rd_count;
 195   const char *name_tmp;
 196   const char *rd_ser_tmp;
 197
 198   rd_len = ntohs (lrm->rd_len);
 199   rd_count = ntohs (lrm->rd_count);
 200   name_len = ntohs (lrm->name_len);
 201   name_tmp = (const char *) &lrm[1];
 202   rd_ser_tmp = (const char *) &name_tmp[name_len];
 203   {
 204     struct GNUNET_GNSRECORD_Data rd[rd_count];
 205
 206     GNUNET_assert (GNUNET_OK ==
 207                    GNUNET_GNSRECORD_records_deserialize (rd_len,
 208                                                          rd_ser_tmp,
 209                                                          rd_count,
 210                                                          rd));
 211     zm->monitor (zm->monitor_cls,
 212                  &lrm->private_key,
 213                  name_tmp,
 214                  rd_count,
 215                  rd);
 216   }
 217 }
 218
 219
 220 /**
 221  * Generic error handler, called with the appropriate error code and
 222  * the same closure specified at the creation of the message queue.
 223  * Not every message queue implementation supports an error handler.
 224  *
 225  * @param cls closure with the `struct GNUNET_NAMESTORE_ZoneMonitor *`
 226  * @param error error code
 227  */
 228 static void
 229 mq_error_handler (void *cls,
 230                   enum GNUNET_MQ_Error error)
 231 {
 232   struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
 233
 234   reconnect (zm);
 235 }
 236
 237
 238 /**
 239  * Reconnect to the namestore service.
 240  *
 241  * @param zm monitor to reconnect
 242  */
 243 static void
 244 reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
 245 {
 246   struct GNUNET_MQ_MessageHandler handlers[] = {
 247     GNUNET_MQ_hd_fixed_size (sync,
 248                              GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC,
 249                              struct GNUNET_MessageHeader,
 250                              zm),
 251     GNUNET_MQ_hd_var_size (result,
 252                            GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT,
 253                            struct RecordResultMessage,
 254                            zm),
 255     GNUNET_MQ_handler_end ()
 256   };
 257   struct GNUNET_MQ_Envelope *env;
 258   struct ZoneMonitorStartMessage *sm;
 259
 260   if (NULL != zm->mq)
 261   {
 262     GNUNET_MQ_destroy (zm->mq);
 263     zm->error_cb (zm->error_cb_cls);
 264   }
 265   zm->mq = GNUNET_CLIENT_connect (zm->cfg,
 266                                   "namestore",
 267                                   handlers,
 268                                   &mq_error_handler,
 269                                   zm);
 270   if (NULL == zm->mq)
 271     return;
 272   env = GNUNET_MQ_msg (sm,
 273                        GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START);
 274   sm->iterate_first = htonl (zm->iterate_first);
 275   sm->zone = zm->zone;
 276   GNUNET_MQ_send (zm->mq,
 277                   env);
 278 }
 279
 280
 281
 282 /**
 283  * Begin monitoring a zone for changes.  If @a iterate_first is set,
 284  * we Will first call the @a monitor function on all existing records
 285  * in the selected zone(s).  In any case, we will call @a sync and
 286  * afterwards call @a monitor whenever a record changes.
 287  *
 288  * @param cfg configuration to use to connect to namestore
 289  * @param zone zone to monitor
 290  * @param iterate_first #GNUNET_YES to first iterate over all existing records,
 291  *                      #GNUNET_NO to only return changes that happen from now on
 292  * @param error_cb function to call on error (i.e. disconnect); note that
 293  *         unlike the other error callbacks in this API, a call to this
 294  *         function does NOT destroy the monitor handle, it merely signals
 295  *         that monitoring is down. You need to still explicitly call
 296  *         #GNUNET_NAMESTORE_zone_monitor_stop().
 297  * @param error_cb_cls closure for @a error_cb
 298  * @param monitor function to call on zone changes
 299  * @param monitor_cls closure for @a monitor
 300  * @param sync_cb function called when we're in sync with the namestore
 301  * @param cls closure for @a sync_cb
 302  * @return handle to stop monitoring
 303  */
 304 struct GNUNET_NAMESTORE_ZoneMonitor *
 305 GNUNET_NAMESTORE_zone_monitor_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
 306                                      const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
 307                                      int iterate_first,
 308                                      GNUNET_SCHEDULER_TaskCallback error_cb,
 309                                      void *error_cb_cls,
 310                                      GNUNET_NAMESTORE_RecordMonitor monitor,
 311                                      void *monitor_cls,
 312                                      GNUNET_SCHEDULER_TaskCallback sync_cb,
 313                                      void *sync_cb_cls)
 314 {
 315   struct GNUNET_NAMESTORE_ZoneMonitor *zm;
 316
 317   zm = GNUNET_new (struct GNUNET_NAMESTORE_ZoneMonitor);
 318   if (NULL != zone)
 319     zm->zone = *zone;
 320   zm->iterate_first = iterate_first;
 321   zm->error_cb = error_cb;
 322   zm->error_cb_cls = error_cb_cls;
 323   zm->monitor = monitor;
 324   zm->monitor_cls = monitor_cls;
 325   zm->sync_cb = sync_cb;
 326   zm->sync_cb_cls = sync_cb_cls;
 327   zm->cfg = cfg;
 328   reconnect (zm);
 329   if (NULL == zm->mq)
 330   {
 331     GNUNET_free (zm);
 332     return NULL;
 333   }
 334   return zm;
 335 }
 336
 337
 338 /**
 339  * Stop monitoring a zone for changes.
 340  *
 341  * @param zm handle to the monitor activity to stop
 342  */
 343 void
 344 GNUNET_NAMESTORE_zone_monitor_stop (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
 345 {
 346   if (NULL != zm->mq)
 347   {
 348     GNUNET_MQ_destroy (zm->mq);
 349     zm->mq = NULL;
 350   }
 351   GNUNET_free (zm);
 352 }
 353
 354 /* end of namestore_api_monitor.c */