Merge branch 'master' of ssh://gnunet.org/gnunet
[oweals/gnunet.git] / 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 */