- add flat plugin config filename path
[oweals/gnunet.git] / src / namestore / namestore_api_monitor.c
1 /*
2      This file is part of GNUnet.
3      Copyright (C) 2013 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 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_CLIENT_Connection *h;
52
53   /**
54    * Function to call on events.
55    */
56   GNUNET_NAMESTORE_RecordMonitor monitor;
57
58   /**
59    * Function called when we've synchronized.
60    */
61   GNUNET_NAMESTORE_RecordsSynchronizedCallback sync_cb;
62
63   /**
64    * Closure for 'monitor' and 'sync_cb'.
65    */
66   void *cls;
67
68   /**
69    * Transmission handle to client.
70    */
71   struct GNUNET_CLIENT_TransmitHandle *th;
72
73   /**
74    * Monitored zone.
75    */
76   struct GNUNET_CRYPTO_EcdsaPrivateKey zone;
77
78   /**
79    * Do we first iterate over all existing records?
80    */
81   int iterate_first;
82
83 };
84
85
86 /**
87  * Send our request to start monitoring to the service.
88  *
89  * @param cls the monitor handle
90  * @param size number of bytes available in buf
91  * @param buf where to copy the message to the service
92  * @return number of bytes copied to buf
93  */
94 static size_t
95 transmit_monitor_message (void *cls,
96                           size_t size,
97                           void *buf);
98
99
100 /**
101  * Reconnect to the namestore service.
102  *
103  * @param zm monitor to reconnect
104  */
105 static void
106 reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
107 {
108   if (NULL != zm->h)
109     GNUNET_CLIENT_disconnect (zm->h);
110   zm->monitor (zm->cls,
111                NULL,
112                NULL, 0, NULL);
113   GNUNET_assert (NULL != (zm->h = GNUNET_CLIENT_connect ("namestore", zm->cfg)));
114   zm->th = GNUNET_CLIENT_notify_transmit_ready (zm->h,
115                                                 sizeof (struct ZoneMonitorStartMessage),
116                                                 GNUNET_TIME_UNIT_FOREVER_REL,
117                                                 GNUNET_YES,
118                                                 &transmit_monitor_message,
119                                                 zm);
120 }
121
122
123 /**
124  * We've received a notification about a change to our zone.
125  * Forward to monitor callback.
126  *
127  * @param cls the zone monitor handle
128  * @param msg the message from the service.
129  */
130 static void
131 handle_updates (void *cls,
132                 const struct GNUNET_MessageHeader *msg)
133 {
134   struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
135   const struct RecordResultMessage *lrm;
136   size_t lrm_len;
137   size_t exp_lrm_len;
138   size_t name_len;
139   size_t rd_len;
140   unsigned rd_count;
141   const char *name_tmp;
142   const char *rd_ser_tmp;
143
144   if (NULL == msg)
145   {
146     reconnect (zm);
147     return;
148   }
149   if ( (ntohs (msg->size) == sizeof (struct GNUNET_MessageHeader)) &&
150        (GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC == ntohs (msg->type) ) )
151   {
152     GNUNET_CLIENT_receive (zm->h,
153                            &handle_updates,
154                            zm,
155                            GNUNET_TIME_UNIT_FOREVER_REL);
156     if (NULL != zm->sync_cb)
157       zm->sync_cb (zm->cls);
158     return;
159   }
160   if ( (ntohs (msg->size) < sizeof (struct RecordResultMessage)) ||
161        (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT != ntohs (msg->type) ) )
162   {
163     GNUNET_break (0);
164     reconnect (zm);
165     return;
166   }
167   lrm = (const struct RecordResultMessage *) msg;
168   lrm_len = ntohs (lrm->gns_header.header.size);
169   rd_len = ntohs (lrm->rd_len);
170   rd_count = ntohs (lrm->rd_count);
171   name_len = ntohs (lrm->name_len);
172   exp_lrm_len = sizeof (struct RecordResultMessage) + name_len + rd_len;
173   if (lrm_len != exp_lrm_len)
174   {
175     GNUNET_break (0);
176     reconnect (zm);
177     return;
178   }
179   if (0 == name_len)
180   {
181     GNUNET_break (0);
182     reconnect (zm);
183     return;
184   }
185   name_tmp = (const char *) &lrm[1];
186   if ((name_tmp[name_len -1] != '\0') || (name_len > MAX_NAME_LEN))
187   {
188     GNUNET_break (0);
189     reconnect (zm);
190     return;
191   }
192   rd_ser_tmp = (const char *) &name_tmp[name_len];
193   {
194     struct GNUNET_GNSRECORD_Data rd[rd_count];
195
196     if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize (rd_len, rd_ser_tmp, rd_count, rd))
197     {
198       GNUNET_break (0);
199       reconnect (zm);
200       return;
201     }
202     GNUNET_CLIENT_receive (zm->h,
203                            &handle_updates,
204                            zm,
205                            GNUNET_TIME_UNIT_FOREVER_REL);
206     zm->monitor (zm->cls,
207                  &lrm->private_key,
208                  name_tmp,
209                  rd_count, rd);
210   }
211 }
212
213
214 /**
215  * Send our request to start monitoring to the service.
216  *
217  * @param cls the monitor handle
218  * @param size number of bytes available in buf
219  * @param buf where to copy the message to the service
220  * @return number of bytes copied to buf
221  */
222 static size_t
223 transmit_monitor_message (void *cls,
224                           size_t size,
225                           void *buf)
226 {
227   struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
228   struct ZoneMonitorStartMessage sm;
229
230   zm->th = NULL;
231   if (size < sizeof (struct ZoneMonitorStartMessage))
232   {
233     reconnect (zm);
234     return 0;
235   }
236   sm.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START);
237   sm.header.size = htons (sizeof (struct ZoneMonitorStartMessage));
238   sm.iterate_first = htonl (zm->iterate_first);
239   sm.zone = zm->zone;
240   memcpy (buf, &sm, sizeof (sm));
241   GNUNET_CLIENT_receive (zm->h,
242                          &handle_updates,
243                          zm,
244                          GNUNET_TIME_UNIT_FOREVER_REL);
245   return sizeof (sm);
246 }
247
248
249 /**
250  * Begin monitoring a zone for changes.  If @a iterate_first is set,
251  * we Will first call the @a monitor function on all existing records
252  * in the selected zone(s).  In any case, we will call @a sync and
253  * afterwards call @a monitor whenever a record changes.
254  *
255  * @param cfg configuration to use to connect to namestore
256  * @param zone zone to monitor
257  * @param iterate_first #GNUNET_YES to first iterate over all existing records,
258  *                      #GNUNET_NO to only return changes that happen from now on
259  * @param monitor function to call on zone changes
260  * @param sync_cb function called when we're in sync with the namestore
261  * @param cls closure for @a monitor and @a sync_cb
262  * @return handle to stop monitoring
263  */
264 struct GNUNET_NAMESTORE_ZoneMonitor *
265 GNUNET_NAMESTORE_zone_monitor_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
266                                      const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
267                                      int iterate_first,
268                                      GNUNET_NAMESTORE_RecordMonitor monitor,
269                                      GNUNET_NAMESTORE_RecordsSynchronizedCallback sync_cb,
270                                      void *cls)
271 {
272   struct GNUNET_NAMESTORE_ZoneMonitor *zm;
273   struct GNUNET_CLIENT_Connection *client;
274
275   if (NULL == (client = GNUNET_CLIENT_connect ("namestore", cfg)))
276     return NULL;
277   zm = GNUNET_new (struct GNUNET_NAMESTORE_ZoneMonitor);
278   zm->cfg = cfg;
279   zm->h = client;
280   if (NULL != zone)
281     zm->zone = *zone;
282   zm->iterate_first = iterate_first;
283   zm->monitor = monitor;
284   zm->sync_cb = sync_cb;
285   zm->cls = cls;
286   zm->th = GNUNET_CLIENT_notify_transmit_ready (zm->h,
287                                                 sizeof (struct ZoneMonitorStartMessage),
288                                                 GNUNET_TIME_UNIT_FOREVER_REL,
289                                                 GNUNET_YES,
290                                                 &transmit_monitor_message,
291                                                 zm);
292   return zm;
293 }
294
295
296 /**
297  * Stop monitoring a zone for changes.
298  *
299  * @param zm handle to the monitor activity to stop
300  */
301 void
302 GNUNET_NAMESTORE_zone_monitor_stop (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
303 {
304   if (NULL != zm->th)
305   {
306     GNUNET_CLIENT_notify_transmit_ready_cancel (zm->th);
307     zm->th = NULL;
308   }
309   GNUNET_CLIENT_disconnect (zm->h);
310   GNUNET_free (zm);
311 }
312
313 /* end of namestore_api_monitor.c */