- add flat plugin config filename path
[oweals/gnunet.git] / src / namestore / namestore_api.c
1 /*
2      This file is part of GNUnet.
3      Copyright (C) 2010-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.c
23  * @brief API to access the NAMESTORE service
24  * @author Martin Schanzenbach
25  * @author Matthias Wachs
26  * @author Christian Grothoff
27  */
28
29 #include "platform.h"
30 #include "gnunet_util_lib.h"
31 #include "gnunet_crypto_lib.h"
32 #include "gnunet_constants.h"
33 #include "gnunet_dnsparser_lib.h"
34 #include "gnunet_arm_service.h"
35 #include "gnunet_signatures.h"
36 #include "gnunet_gns_service.h"
37 #include "gnunet_namestore_service.h"
38 #include "namestore.h"
39
40
41 #define LOG(kind,...) GNUNET_log_from (kind, "namestore-api",__VA_ARGS__)
42
43
44 /**
45  * An QueueEntry used to store information for a pending
46  * NAMESTORE record operation
47  */
48 struct GNUNET_NAMESTORE_QueueEntry
49 {
50
51   /**
52    * Kept in a DLL.
53    */
54   struct GNUNET_NAMESTORE_QueueEntry *next;
55
56   /**
57    * Kept in a DLL.
58    */
59   struct GNUNET_NAMESTORE_QueueEntry *prev;
60
61   /**
62    * Main handle to access the namestore.
63    */
64   struct GNUNET_NAMESTORE_Handle *nsh;
65
66   /**
67    * Continuation to call
68    */
69   GNUNET_NAMESTORE_ContinuationWithStatus cont;
70
71   /**
72    * Closure for 'cont'.
73    */
74   void *cont_cls;
75
76   /**
77    * Function to call with the records we get back; or NULL.
78    */
79   GNUNET_NAMESTORE_RecordMonitor proc;
80
81   /**
82    * Closure for @e proc.
83    */
84   void *proc_cls;
85
86   /**
87    * The operation id this zone iteration operation has
88    */
89   uint32_t op_id;
90
91 };
92
93
94 /**
95  * Handle for a zone iterator operation
96  */
97 struct GNUNET_NAMESTORE_ZoneIterator
98 {
99
100   /**
101    * Kept in a DLL.
102    */
103   struct GNUNET_NAMESTORE_ZoneIterator *next;
104
105   /**
106    * Kept in a DLL.
107    */
108   struct GNUNET_NAMESTORE_ZoneIterator *prev;
109
110   /**
111    * Main handle to access the namestore.
112    */
113   struct GNUNET_NAMESTORE_Handle *h;
114
115   /**
116    * The continuation to call with the results
117    */
118   GNUNET_NAMESTORE_RecordMonitor proc;
119
120   /**
121    * Closure for @e proc.
122    */
123   void* proc_cls;
124
125   /**
126    * Private key of the zone.
127    */
128   struct GNUNET_CRYPTO_EcdsaPrivateKey zone;
129
130   /**
131    * The operation id this zone iteration operation has
132    */
133   uint32_t op_id;
134
135 };
136
137
138 /**
139  * Message in linked list we should send to the service.  The
140  * actual binary message follows this struct.
141  */
142 struct PendingMessage
143 {
144
145   /**
146    * Kept in a DLL.
147    */
148   struct PendingMessage *next;
149
150   /**
151    * Kept in a DLL.
152    */
153   struct PendingMessage *prev;
154
155   /**
156    * Size of the message.
157    */
158   size_t size;
159
160 };
161
162
163 /**
164  * Connection to the NAMESTORE service.
165  */
166 struct GNUNET_NAMESTORE_Handle
167 {
168
169   /**
170    * Configuration to use.
171    */
172   const struct GNUNET_CONFIGURATION_Handle *cfg;
173
174   /**
175    * Socket (if available).
176    */
177   struct GNUNET_CLIENT_Connection *client;
178
179   /**
180    * Currently pending transmission request (or NULL).
181    */
182   struct GNUNET_CLIENT_TransmitHandle *th;
183
184   /**
185    * Head of linked list of pending messages to send to the service
186    */
187   struct PendingMessage *pending_head;
188
189   /**
190    * Tail of linked list of pending messages to send to the service
191    */
192   struct PendingMessage *pending_tail;
193
194   /**
195    * Head of pending namestore queue entries
196    */
197   struct GNUNET_NAMESTORE_QueueEntry *op_head;
198
199   /**
200    * Tail of pending namestore queue entries
201    */
202   struct GNUNET_NAMESTORE_QueueEntry *op_tail;
203
204   /**
205    * Head of pending namestore zone iterator entries
206    */
207   struct GNUNET_NAMESTORE_ZoneIterator *z_head;
208
209   /**
210    * Tail of pending namestore zone iterator entries
211    */
212   struct GNUNET_NAMESTORE_ZoneIterator *z_tail;
213
214   /**
215    * Reconnect task
216    */
217   struct GNUNET_SCHEDULER_Task * reconnect_task;
218
219   /**
220    * Delay introduced before we reconnect.
221    */
222   struct GNUNET_TIME_Relative reconnect_delay;
223
224   /**
225    * Should we reconnect to service due to some serious error?
226    */
227   int reconnect;
228
229   /**
230    * Did we start to receive yet?
231    */
232   int is_receiving;
233
234   /**
235    * The last operation id used for a NAMESTORE operation
236    */
237   uint32_t last_op_id_used;
238
239 };
240
241
242 /**
243  * Disconnect from service and then reconnect.
244  *
245  * @param h our handle
246  */
247 static void
248 force_reconnect (struct GNUNET_NAMESTORE_Handle *h);
249
250
251 /**
252  * Handle an incoming message of type
253  * #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE
254  *
255  * @param qe the respective entry in the message queue
256  * @param msg the message we received
257  * @param size the message size
258  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and we did NOT notify the client
259  */
260 static int
261 handle_record_store_response (struct GNUNET_NAMESTORE_QueueEntry *qe,
262                               const struct RecordStoreResponseMessage* msg,
263                               size_t size)
264 {
265   int res;
266   const char *emsg;
267
268   LOG (GNUNET_ERROR_TYPE_DEBUG,
269        "Received `%s' with result %i\n",
270        "RECORD_STORE_RESPONSE",
271        ntohl (msg->op_result));
272   /* TODO: add actual error message from namestore to response... */
273   res = ntohl (msg->op_result);
274   if (GNUNET_SYSERR == res)
275     emsg = _("Namestore failed to store record\n");
276   else
277     emsg = NULL;
278   if (NULL != qe->cont)
279     qe->cont (qe->cont_cls, res, emsg);
280   return GNUNET_OK;
281 }
282
283
284 /**
285  * Handle an incoming message of type
286  * #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE
287  *
288  * @param qe the respective entry in the message queue
289  * @param msg the message we received
290  * @param size the message size
291  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and we did NOT notify the client
292  */
293 static int
294 handle_lookup_result (struct GNUNET_NAMESTORE_QueueEntry *qe,
295                       const struct LabelLookupResponseMessage *msg,
296                       size_t size)
297 {
298   const char *name;
299   const char *rd_tmp;
300   size_t exp_msg_len;
301   size_t msg_len;
302   size_t name_len;
303   size_t rd_len;
304   unsigned int rd_count;
305   int found;
306
307   LOG (GNUNET_ERROR_TYPE_DEBUG,
308        "Received `%s'\n",
309        "RECORD_LOOKUP_RESULT");
310
311   rd_len = ntohs (msg->rd_len);
312   rd_count = ntohs (msg->rd_count);
313   msg_len = ntohs (msg->gns_header.header.size);
314   name_len = ntohs (msg->name_len);
315   found = ntohs (msg->found);
316   exp_msg_len = sizeof (struct LabelLookupResponseMessage) + name_len + rd_len;
317   if (msg_len != exp_msg_len)
318   {
319     GNUNET_break (0);
320     return GNUNET_SYSERR;
321   }
322   name = (const char *) &msg[1];
323   if ( (name_len > 0) &&
324        ('\0' != name[name_len -1]) )
325   {
326     GNUNET_break (0);
327     return GNUNET_SYSERR;
328   }
329   if (GNUNET_NO == found)
330   {
331     /* label was not in namestore */
332     if (NULL != qe->proc)
333       qe->proc (qe->proc_cls,
334                 &msg->private_key,
335                 name,
336                 0, NULL);
337     return GNUNET_OK;
338   }
339
340   rd_tmp = &name[name_len];
341   {
342     struct GNUNET_GNSRECORD_Data rd[rd_count];
343
344     if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize(rd_len, rd_tmp, rd_count, rd))
345     {
346       GNUNET_break (0);
347       return GNUNET_SYSERR;
348     }
349     if (0 == name_len)
350       name = NULL;
351     if (NULL != qe->proc)
352       qe->proc (qe->proc_cls,
353                 &msg->private_key,
354                 name,
355                 rd_count,
356                 (rd_count > 0) ? rd : NULL);
357   }
358   return GNUNET_OK;
359 }
360
361
362 /**
363  * Handle an incoming message of type
364  * #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT
365  *
366  * @param qe the respective entry in the message queue
367  * @param msg the message we received
368  * @param size the message size
369  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and we did NOT notify the client
370  */
371 static int
372 handle_record_result (struct GNUNET_NAMESTORE_QueueEntry *qe,
373                       const struct RecordResultMessage *msg,
374                       size_t size)
375 {
376   const char *name;
377   const char *rd_tmp;
378   size_t exp_msg_len;
379   size_t msg_len;
380   size_t name_len;
381   size_t rd_len;
382   unsigned int rd_count;
383
384   LOG (GNUNET_ERROR_TYPE_DEBUG,
385        "Received `%s'\n",
386        "RECORD_RESULT");
387   rd_len = ntohs (msg->rd_len);
388   rd_count = ntohs (msg->rd_count);
389   msg_len = ntohs (msg->gns_header.header.size);
390   name_len = ntohs (msg->name_len);
391   GNUNET_break (0 == ntohs (msg->reserved));
392   exp_msg_len = sizeof (struct RecordResultMessage) + name_len + rd_len;
393   if (msg_len != exp_msg_len)
394   {
395     GNUNET_break (0);
396     return GNUNET_SYSERR;
397   }
398   name = (const char *) &msg[1];
399   if ( (name_len > 0) &&
400        ('\0' != name[name_len -1]) )
401   {
402     GNUNET_break (0);
403     return GNUNET_SYSERR;
404   }
405   rd_tmp = &name[name_len];
406   {
407     struct GNUNET_GNSRECORD_Data rd[rd_count];
408
409     if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize(rd_len, rd_tmp, rd_count, rd))
410     {
411       GNUNET_break (0);
412       return GNUNET_SYSERR;
413     }
414     if (0 == name_len)
415       name = NULL;
416     if (NULL != qe->proc)
417       qe->proc (qe->proc_cls,
418                 &msg->private_key,
419                 name,
420                 rd_count,
421                 (rd_count > 0) ? rd : NULL);
422   }
423   return GNUNET_OK;
424 }
425
426
427 /**
428  * Handle an incoming message of type
429  * #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE.
430  *
431  * @param qe the respective entry in the message queue
432  * @param msg the message we received
433  * @param size the message size
434  * @return #GNUNET_OK on success, #GNUNET_NO if we notified the client about
435  *         the error, #GNUNET_SYSERR on error and we did NOT notify the client
436  */
437 static int
438 handle_zone_to_name_response (struct GNUNET_NAMESTORE_QueueEntry *qe,
439                               const struct ZoneToNameResponseMessage *msg,
440                               size_t size)
441 {
442   int res;
443   size_t name_len;
444   size_t rd_ser_len;
445   unsigned int rd_count;
446   const char *name_tmp;
447   const char *rd_tmp;
448
449   LOG (GNUNET_ERROR_TYPE_DEBUG,
450        "Received `%s'\n",
451        "ZONE_TO_NAME_RESPONSE");
452   res = ntohs (msg->res);
453   switch (res)
454   {
455   case GNUNET_SYSERR:
456     LOG (GNUNET_ERROR_TYPE_DEBUG,
457          "An error occured during zone to name operation\n");
458     break;
459   case GNUNET_NO:
460     LOG (GNUNET_ERROR_TYPE_DEBUG,
461          "Namestore has no result for zone to name mapping \n");
462     if (NULL != qe->proc)
463       qe->proc (qe->proc_cls, &msg->zone, NULL, 0, NULL);
464     return GNUNET_NO;
465   case GNUNET_YES:
466     LOG (GNUNET_ERROR_TYPE_DEBUG,
467          "Namestore has result for zone to name mapping \n");
468     name_len = ntohs (msg->name_len);
469     rd_count = ntohs (msg->rd_count);
470     rd_ser_len = ntohs (msg->rd_len);
471     name_tmp = (const char *) &msg[1];
472     if ( (name_len > 0) &&
473          ('\0' != name_tmp[name_len -1]) )
474     {
475       GNUNET_break (0);
476       return GNUNET_SYSERR;
477     }
478     rd_tmp = &name_tmp[name_len];
479     {
480       struct GNUNET_GNSRECORD_Data rd[rd_count];
481
482       if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize(rd_ser_len, rd_tmp, rd_count, rd))
483       {
484         GNUNET_break (0);
485         return GNUNET_SYSERR;
486       }
487       /* normal end, call continuation with result */
488       if (NULL != qe->proc)
489         qe->proc (qe->proc_cls,
490                   &msg->zone,
491                   name_tmp,
492                   rd_count, rd);
493       /* return is important here: break would call continuation with error! */
494       return GNUNET_OK;
495     }
496   default:
497     GNUNET_break (0);
498     return GNUNET_SYSERR;
499   }
500   /* error case, call continuation with error */
501   if (NULL != qe->proc)
502     qe->proc (qe->proc_cls, NULL, NULL, 0, NULL);
503   return GNUNET_NO;
504 }
505
506
507 /**
508  * Handle incoming messages for record operations
509  *
510  * @param qe the respective zone iteration handle
511  * @param msg the message we received
512  * @param type the message type in host byte order
513  * @param size the message size
514  * @return #GNUNET_OK on success, #GNUNET_NO if we notified the client about
515  *         the error, #GNUNET_SYSERR on error and we did NOT notify the client
516  */
517 static int
518 manage_record_operations (struct GNUNET_NAMESTORE_QueueEntry *qe,
519                           const struct GNUNET_MessageHeader *msg,
520                           uint16_t type,
521                           size_t size)
522 {
523   /* handle different message type */
524   switch (type)
525   {
526   case GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE:
527     if (size != sizeof (struct RecordStoreResponseMessage))
528     {
529       GNUNET_break (0);
530       return GNUNET_SYSERR;
531     }
532     return handle_record_store_response (qe, (const struct RecordStoreResponseMessage *) msg, size);
533   case GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE:
534     if (size < sizeof (struct ZoneToNameResponseMessage))
535     {
536       GNUNET_break (0);
537       return GNUNET_SYSERR;
538     }
539     return handle_zone_to_name_response (qe, (const struct ZoneToNameResponseMessage *) msg, size);
540   case GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT:
541     if (size < sizeof (struct RecordResultMessage))
542     {
543       GNUNET_break (0);
544       return GNUNET_SYSERR;
545     }
546     return handle_record_result (qe, (const struct RecordResultMessage *) msg, size);
547   case GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE:
548     if (size < sizeof (struct LabelLookupResponseMessage))
549     {
550       GNUNET_break (0);
551       return GNUNET_SYSERR;
552     }
553     return handle_lookup_result (qe, (const struct LabelLookupResponseMessage *) msg, size);
554   default:
555     GNUNET_break (0);
556     return GNUNET_SYSERR;
557   }
558 }
559
560
561 /**
562  * Handle a response from NAMESTORE service for a zone iteration request
563  *
564  * @param ze the respective iterator for this operation
565  * @param msg the message containing the respoonse
566  * @param size the message size
567  * @return #GNUNET_YES on success, @a ze should be kept, #GNUNET_NO on success if @a ze should
568  *         not be kept any longer, #GNUNET_SYSERR on error (disconnect) and @a ze should be kept
569  */
570 static int
571 handle_zone_iteration_response (struct GNUNET_NAMESTORE_ZoneIterator *ze,
572                                 const struct RecordResultMessage *msg,
573                                 size_t size)
574 {
575   static struct GNUNET_CRYPTO_EcdsaPrivateKey priv_dummy;
576   size_t msg_len;
577   size_t exp_msg_len;
578   size_t name_len;
579   size_t rd_len;
580   unsigned rd_count;
581   const char *name_tmp;
582   const char *rd_ser_tmp;
583
584   LOG (GNUNET_ERROR_TYPE_DEBUG,
585        "Received `%s'\n",
586        "ZONE_ITERATION_RESPONSE");
587   msg_len = ntohs (msg->gns_header.header.size);
588   rd_len = ntohs (msg->rd_len);
589   rd_count = ntohs (msg->rd_count);
590   name_len = ntohs (msg->name_len);
591   exp_msg_len = sizeof (struct RecordResultMessage) + name_len + rd_len;
592   if (msg_len != exp_msg_len)
593   {
594     GNUNET_break (0);
595     return GNUNET_SYSERR;
596   }
597   if ( (0 == name_len) &&
598        (0 == (memcmp (&msg->private_key,
599                       &priv_dummy,
600                       sizeof (priv_dummy)))) )
601   {
602     LOG (GNUNET_ERROR_TYPE_DEBUG,
603          "Zone iteration completed!\n");
604     if (NULL != ze->proc)
605       ze->proc (ze->proc_cls, NULL, NULL, 0, NULL);
606     return GNUNET_NO;
607   }
608   name_tmp = (const char *) &msg[1];
609   if ((name_tmp[name_len -1] != '\0') || (name_len > MAX_NAME_LEN))
610   {
611     GNUNET_break (0);
612     return GNUNET_SYSERR;
613   }
614   rd_ser_tmp = (const char *) &name_tmp[name_len];
615   {
616     struct GNUNET_GNSRECORD_Data rd[rd_count];
617
618     if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize (rd_len,
619                                                            rd_ser_tmp,
620                                                            rd_count,
621                                                            rd))
622     {
623       GNUNET_break (0);
624       return GNUNET_SYSERR;
625     }
626     if (NULL != ze->proc)
627       ze->proc (ze->proc_cls,
628                 &msg->private_key,
629                 name_tmp,
630                 rd_count, rd);
631     return GNUNET_YES;
632   }
633 }
634
635
636 /**
637  * Handle incoming messages for zone iterations
638  *
639  * @param ze the respective zone iteration handle
640  * @param msg the message we received
641  * @param type the message type in HBO
642  * @param size the message size
643  * @return #GNUNET_YES on success, @a ze should be kept, #GNUNET_NO on success if @a ze should
644  *         not be kept any longer, #GNUNET_SYSERR on error (disconnect) and @a ze should be kept
645  */
646 static int
647 manage_zone_operations (struct GNUNET_NAMESTORE_ZoneIterator *ze,
648                         const struct GNUNET_MessageHeader *msg,
649                         int type, size_t size)
650 {
651   /* handle different message type */
652   switch (type)
653   {
654   case GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT:
655     if (size < sizeof (struct RecordResultMessage))
656     {
657       GNUNET_break (0);
658       return GNUNET_SYSERR;
659     }
660     return handle_zone_iteration_response (ze,
661                                            (const struct RecordResultMessage *) msg,
662                                            size);
663   default:
664     GNUNET_break (0);
665     return GNUNET_SYSERR;
666   }
667 }
668
669
670 /**
671  * Type of a function to call when we receive a message
672  * from the service.
673  *
674  * @param cls the `struct GNUNET_NAMESTORE_SchedulingHandle`
675  * @param msg message received, NULL on timeout or fatal error
676  */
677 static void
678 process_namestore_message (void *cls,
679                            const struct GNUNET_MessageHeader *msg)
680 {
681   struct GNUNET_NAMESTORE_Handle *h = cls;
682   const struct GNUNET_NAMESTORE_Header *gm;
683   struct GNUNET_NAMESTORE_QueueEntry *qe;
684   struct GNUNET_NAMESTORE_ZoneIterator *ze;
685   uint16_t size;
686   uint16_t type;
687   uint32_t r_id;
688   int ret;
689
690   if (NULL == msg)
691   {
692     force_reconnect (h);
693     return;
694   }
695   size = ntohs (msg->size);
696   type = ntohs (msg->type);
697   if (size < sizeof (struct GNUNET_NAMESTORE_Header))
698   {
699     GNUNET_break_op (0);
700     GNUNET_CLIENT_receive (h->client,
701                            &process_namestore_message, h,
702                            GNUNET_TIME_UNIT_FOREVER_REL);
703     return;
704   }
705   gm = (const struct GNUNET_NAMESTORE_Header *) msg;
706   r_id = ntohl (gm->r_id);
707
708   LOG (GNUNET_ERROR_TYPE_DEBUG,
709        "Received message type %u size %u op %u\n",
710        (unsigned int) type,
711        (unsigned int) size,
712        (unsigned int) r_id);
713
714   /* Is it a record related operation ? */
715   for (qe = h->op_head; qe != NULL; qe = qe->next)
716     if (qe->op_id == r_id)
717       break;
718   if (NULL != qe)
719   {
720     ret = manage_record_operations (qe, msg, type, size);
721     if (GNUNET_SYSERR == ret)
722     {
723       /* protocol error, need to reconnect */
724       h->reconnect = GNUNET_YES;
725     }
726     else
727     {
728       /* client was notified about success or failure, clean up 'qe' */
729       GNUNET_CONTAINER_DLL_remove (h->op_head,
730                                    h->op_tail,
731                                    qe);
732       GNUNET_free (qe);
733     }
734   }
735   /* Is it a zone iteration operation? */
736   for (ze = h->z_head; ze != NULL; ze = ze->next)
737     if (ze->op_id == r_id)
738       break;
739   if (NULL != ze)
740   {
741     ret = manage_zone_operations (ze, msg, type, size);
742     if (GNUNET_NO == ret)
743     {
744       /* end of iteration, clean up 'ze' */
745       GNUNET_CONTAINER_DLL_remove (h->z_head,
746                                    h->z_tail,
747                                    ze);
748       GNUNET_free (ze);
749     }
750     if (GNUNET_SYSERR == ret)
751     {
752       /* protocol error, need to reconnect */
753       h->reconnect = GNUNET_YES;
754     }
755   }
756   if (GNUNET_YES == h->reconnect)
757   {
758     force_reconnect (h);
759     return;
760   }
761   GNUNET_CLIENT_receive (h->client, &process_namestore_message, h,
762                          GNUNET_TIME_UNIT_FOREVER_REL);
763 }
764
765
766 /**
767  * Transmit messages from the message queue to the service
768  * (if there are any, and if we are not already trying).
769  *
770  * @param h handle to use
771  */
772 static void
773 do_transmit (struct GNUNET_NAMESTORE_Handle *h);
774
775
776 /**
777  * We can now transmit a message to NAMESTORE. Do it.
778  *
779  * @param cls the `struct GNUNET_NAMESTORE_Handle`
780  * @param size number of bytes we can transmit
781  * @param buf where to copy the messages
782  * @return number of bytes copied into @a buf
783  */
784 static size_t
785 transmit_message_to_namestore (void *cls,
786                                size_t size,
787                                void *buf)
788 {
789   struct GNUNET_NAMESTORE_Handle *h = cls;
790   struct PendingMessage *p;
791   size_t ret;
792   char *cbuf;
793
794   h->th = NULL;
795   if ((0 == size) || (NULL == buf))
796   {
797     force_reconnect (h);
798     return 0;
799   }
800   ret = 0;
801   cbuf = buf;
802   while ( (NULL != (p = h->pending_head)) &&
803           (p->size <= size) )
804   {
805     memcpy (&cbuf[ret], &p[1], p->size);
806     ret += p->size;
807     size -= p->size;
808     GNUNET_CONTAINER_DLL_remove (h->pending_head,
809                                  h->pending_tail,
810                                  p);
811     if (GNUNET_NO == h->is_receiving)
812     {
813       h->is_receiving = GNUNET_YES;
814       GNUNET_CLIENT_receive (h->client,
815                              &process_namestore_message, h,
816                              GNUNET_TIME_UNIT_FOREVER_REL);
817     }
818     GNUNET_free (p);
819   }
820   do_transmit (h);
821   return ret;
822 }
823
824
825 /**
826  * Transmit messages from the message queue to the service
827  * (if there are any, and if we are not already trying).
828  *
829  * @param h handle to use
830  */
831 static void
832 do_transmit (struct GNUNET_NAMESTORE_Handle *h)
833 {
834   struct PendingMessage *p;
835
836   if (NULL != h->th)
837     return; /* transmission request already pending */
838   if (NULL == (p = h->pending_head))
839     return; /* transmission queue empty */
840   if (NULL == h->client)
841     return;                     /* currently reconnecting */
842   h->th = GNUNET_CLIENT_notify_transmit_ready (h->client, p->size,
843                                                GNUNET_TIME_UNIT_FOREVER_REL,
844                                                GNUNET_NO, &transmit_message_to_namestore,
845                                                h);
846   GNUNET_break (NULL != h->th);
847 }
848
849
850 /**
851  * Reconnect to namestore service.
852  *
853  * @param h the handle to the NAMESTORE service
854  */
855 static void
856 reconnect (struct GNUNET_NAMESTORE_Handle *h)
857 {
858   GNUNET_assert (NULL == h->client);
859   h->client = GNUNET_CLIENT_connect ("namestore", h->cfg);
860   GNUNET_assert (NULL != h->client);
861   do_transmit (h);
862 }
863
864
865 /**
866  * Re-establish the connection to the service.
867  *
868  * @param cls handle to use to re-connect.
869  * @param tc scheduler context
870  */
871 static void
872 reconnect_task (void *cls,
873                 const struct GNUNET_SCHEDULER_TaskContext *tc)
874 {
875   struct GNUNET_NAMESTORE_Handle *h = cls;
876
877   h->reconnect_task = NULL;
878   reconnect (h);
879 }
880
881
882 /**
883  * Disconnect from service and then reconnect.
884  *
885  * @param h our handle
886  */
887 static void
888 force_reconnect (struct GNUNET_NAMESTORE_Handle *h)
889 {
890   if (NULL != h->th)
891   {
892     GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
893     h->th = NULL;
894   }
895   h->reconnect = GNUNET_NO;
896   GNUNET_CLIENT_disconnect (h->client);
897   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
898               "Reconnecting to namestore\n");
899   h->is_receiving = GNUNET_NO;
900   h->client = NULL;
901   h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
902   h->reconnect_task = GNUNET_SCHEDULER_add_delayed (h->reconnect_delay,
903                                                     &reconnect_task,
904                                                     h);
905 }
906
907
908 /**
909  * Get a fresh operation id to distinguish between namestore requests
910  *
911  * @param h the namestore handle
912  * @return next operation id to use
913  */
914 static uint32_t
915 get_op_id (struct GNUNET_NAMESTORE_Handle *h)
916 {
917   return h->last_op_id_used++;
918 }
919
920
921 /**
922  * Initialize the connection with the NAMESTORE service.
923  *
924  * @param cfg configuration to use
925  * @return handle to the GNS service, or NULL on error
926  */
927 struct GNUNET_NAMESTORE_Handle *
928 GNUNET_NAMESTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
929 {
930   struct GNUNET_NAMESTORE_Handle *h;
931
932   h = GNUNET_new (struct GNUNET_NAMESTORE_Handle);
933   h->cfg = cfg;
934   h->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect_task, h);
935   h->last_op_id_used = 0;
936   return h;
937 }
938
939
940 /**
941  * Disconnect from the namestore service (and free associated
942  * resources).
943  *
944  * @param h handle to the namestore
945  */
946 void
947 GNUNET_NAMESTORE_disconnect (struct GNUNET_NAMESTORE_Handle *h)
948 {
949   struct PendingMessage *p;
950   struct GNUNET_NAMESTORE_QueueEntry *q;
951   struct GNUNET_NAMESTORE_ZoneIterator *z;
952
953   LOG (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
954   GNUNET_assert (NULL != h);
955   if (NULL != h->th)
956   {
957     GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
958     h->th = NULL;
959   }
960   while (NULL != (p = h->pending_head))
961   {
962     GNUNET_CONTAINER_DLL_remove (h->pending_head, h->pending_tail, p);
963     GNUNET_free (p);
964   }
965   GNUNET_break (NULL == h->op_head);
966   while (NULL != (q = h->op_head))
967   {
968     GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, q);
969     GNUNET_free (q);
970   }
971   GNUNET_break (NULL == h->z_head);
972   while (NULL != (z = h->z_head))
973   {
974     GNUNET_CONTAINER_DLL_remove (h->z_head, h->z_tail, z);
975     GNUNET_free (z);
976   }
977   if (NULL != h->client)
978   {
979     GNUNET_CLIENT_disconnect (h->client);
980     h->client = NULL;
981   }
982   if (NULL != h->reconnect_task)
983   {
984     GNUNET_SCHEDULER_cancel (h->reconnect_task);
985     h->reconnect_task = NULL;
986   }
987   GNUNET_free (h);
988 }
989
990
991 /**
992  * Store an item in the namestore.  If the item is already present,
993  * it is replaced with the new record.  Use an empty array to
994  * remove all records under the given name.
995  *
996  * @param h handle to the namestore
997  * @param pkey private key of the zone
998  * @param label name that is being mapped (at most 255 characters long)
999  * @param rd_count number of records in the 'rd' array
1000  * @param rd array of records with data to store
1001  * @param cont continuation to call when done
1002  * @param cont_cls closure for @a cont
1003  * @return handle to abort the request
1004  */
1005 struct GNUNET_NAMESTORE_QueueEntry *
1006 GNUNET_NAMESTORE_records_store (struct GNUNET_NAMESTORE_Handle *h,
1007                                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
1008                                 const char *label,
1009                                 unsigned int rd_count,
1010                                 const struct GNUNET_GNSRECORD_Data *rd,
1011                                 GNUNET_NAMESTORE_ContinuationWithStatus cont,
1012                                 void *cont_cls)
1013 {
1014   struct GNUNET_NAMESTORE_QueueEntry *qe;
1015   struct PendingMessage *pe;
1016   char *name_tmp;
1017   char *rd_ser;
1018   size_t rd_ser_len;
1019   size_t msg_size;
1020   size_t name_len;
1021   uint32_t rid;
1022   struct RecordStoreMessage *msg;
1023
1024   GNUNET_assert (NULL != h);
1025   GNUNET_assert (NULL != pkey);
1026   GNUNET_assert (NULL != label);
1027   name_len = strlen (label) + 1;
1028   if (name_len > MAX_NAME_LEN)
1029   {
1030     GNUNET_break (0);
1031     return NULL;
1032   }
1033   rid = get_op_id (h);
1034   qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
1035   qe->nsh = h;
1036   qe->cont = cont;
1037   qe->cont_cls = cont_cls;
1038   qe->op_id = rid;
1039   GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
1040
1041   /* setup msg */
1042   rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
1043   msg_size = sizeof (struct RecordStoreMessage) + name_len + rd_ser_len;
1044   pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
1045   pe->size = msg_size;
1046   msg = (struct RecordStoreMessage *) &pe[1];
1047   msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE);
1048   msg->gns_header.header.size = htons (msg_size);
1049   msg->gns_header.r_id = htonl (rid);
1050   msg->name_len = htons (name_len);
1051   msg->rd_count = htons (rd_count);
1052   msg->rd_len = htons (rd_ser_len);
1053   msg->reserved = htons (0);
1054   msg->private_key = *pkey;
1055
1056   name_tmp = (char *) &msg[1];
1057   memcpy (name_tmp, label, name_len);
1058   rd_ser = &name_tmp[name_len];
1059   GNUNET_break (rd_ser_len ==
1060                 GNUNET_GNSRECORD_records_serialize (rd_count, rd,
1061                                                     rd_ser_len,
1062                                                     rd_ser));
1063   LOG (GNUNET_ERROR_TYPE_DEBUG,
1064        "Sending `%s' message for name `%s' with size %u and %u records\n",
1065        "NAMESTORE_RECORD_STORE", label, msg_size,
1066        rd_count);
1067   GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
1068   do_transmit (h);
1069   return qe;
1070 }
1071
1072 /**
1073  * Set the desired nick name for a zone
1074  *
1075  * @param h handle to the namestore
1076  * @param pkey private key of the zone
1077  * @param nick the nick name to set
1078  * @param cont continuation to call when done
1079  * @param cont_cls closure for 'cont'
1080  * @return handle to abort the request
1081  */
1082 struct GNUNET_NAMESTORE_QueueEntry *
1083 GNUNET_NAMESTORE_set_nick (struct GNUNET_NAMESTORE_Handle *h,
1084                            const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
1085                            const char *nick,
1086                            GNUNET_NAMESTORE_ContinuationWithStatus cont,
1087                            void *cont_cls)
1088 {
1089   struct GNUNET_GNSRECORD_Data rd;
1090
1091   memset (&rd, 0, sizeof (rd));
1092   rd.data = nick;
1093   rd.data_size = strlen (nick) +1;
1094   rd.record_type = GNUNET_GNSRECORD_TYPE_NICK;
1095   rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
1096   rd.flags |= GNUNET_GNSRECORD_RF_PRIVATE;
1097   return GNUNET_NAMESTORE_records_store(h, pkey, GNUNET_GNS_MASTERZONE_STR, 1, &rd, cont, cont_cls);
1098 }
1099
1100
1101 /**
1102  * Lookup an item in the namestore.
1103  *
1104  * @param h handle to the namestore
1105  * @param pkey private key of the zone
1106  * @param label name that is being mapped (at most 255 characters long)
1107  * @param rm function to call with the result (with 0 records if we don't have that label)
1108  * @param rm_cls closure for @a rm
1109  * @return handle to abort the request
1110  */
1111 struct GNUNET_NAMESTORE_QueueEntry *
1112 GNUNET_NAMESTORE_records_lookup (struct GNUNET_NAMESTORE_Handle *h,
1113                                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
1114                                  const char *label,
1115                                  GNUNET_NAMESTORE_RecordMonitor rm,
1116                                  void *rm_cls)
1117 {
1118   struct GNUNET_NAMESTORE_QueueEntry *qe;
1119   struct PendingMessage *pe;
1120   struct LabelLookupMessage * msg;
1121   size_t msg_size;
1122   size_t label_len;
1123
1124   GNUNET_assert (NULL != h);
1125   GNUNET_assert (NULL != pkey);
1126   GNUNET_assert (NULL != label);
1127
1128   if (1 == (label_len = strlen (label) + 1))
1129     return NULL;
1130
1131   qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
1132   qe->nsh = h;
1133   qe->proc = rm;
1134   qe->proc_cls = rm_cls;
1135   qe->op_id = get_op_id(h);
1136   GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
1137
1138   msg_size = sizeof (struct LabelLookupMessage) + label_len;
1139   pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
1140   pe->size = msg_size;
1141   msg = (struct LabelLookupMessage *) &pe[1];
1142   msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP);
1143   msg->gns_header.header.size = htons (msg_size);
1144   msg->gns_header.r_id = htonl (qe->op_id);
1145   msg->zone = *pkey;
1146   msg->label_len = htonl(label_len);
1147   memcpy (&msg[1], label, label_len);
1148
1149   /* transmit message */
1150   GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
1151   do_transmit (h);
1152   return qe;
1153 }
1154
1155
1156 /**
1157  * Look for an existing PKEY delegation record for a given public key.
1158  * Returns at most one result to the processor.
1159  *
1160  * @param h handle to the namestore
1161  * @param zone public key of the zone to look up in, never NULL
1162  * @param value_zone public key of the target zone (value), never NULL
1163  * @param proc function to call on the matching records, or with
1164  *        NULL (rd_count == 0) if there are no matching records
1165  * @param proc_cls closure for @a proc
1166  * @return a handle that can be used to
1167  *         cancel
1168  */
1169 struct GNUNET_NAMESTORE_QueueEntry *
1170 GNUNET_NAMESTORE_zone_to_name (struct GNUNET_NAMESTORE_Handle *h,
1171                                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
1172                                const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
1173                                GNUNET_NAMESTORE_RecordMonitor proc, void *proc_cls)
1174 {
1175   struct GNUNET_NAMESTORE_QueueEntry *qe;
1176   struct PendingMessage *pe;
1177   struct ZoneToNameMessage * msg;
1178   size_t msg_size;
1179   uint32_t rid;
1180
1181   GNUNET_assert (NULL != h);
1182   GNUNET_assert (NULL != zone);
1183   GNUNET_assert (NULL != value_zone);
1184   rid = get_op_id(h);
1185   qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
1186   qe->nsh = h;
1187   qe->proc = proc;
1188   qe->proc_cls = proc_cls;
1189   qe->op_id = rid;
1190   GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
1191
1192   msg_size = sizeof (struct ZoneToNameMessage);
1193   pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
1194   pe->size = msg_size;
1195   msg = (struct ZoneToNameMessage *) &pe[1];
1196   msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME);
1197   msg->gns_header.header.size = htons (msg_size);
1198   msg->gns_header.r_id = htonl (rid);
1199   msg->zone = *zone;
1200   msg->value_zone = *value_zone;
1201
1202   /* transmit message */
1203   GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
1204   do_transmit (h);
1205   return qe;
1206 }
1207
1208
1209 /**
1210  * Starts a new zone iteration (used to periodically PUT all of our
1211  * records into our DHT). This MUST lock the struct GNUNET_NAMESTORE_Handle
1212  * for any other calls than #GNUNET_NAMESTORE_zone_iterator_next and
1213  * #GNUNET_NAMESTORE_zone_iteration_stop. @a proc will be called once
1214  * immediately, and then again after
1215  * #GNUNET_NAMESTORE_zone_iterator_next is invoked.
1216  *
1217  * @param h handle to the namestore
1218  * @param zone zone to access, NULL for all zones
1219  * @param proc function to call on each name from the zone; it
1220  *        will be called repeatedly with a value (if available)
1221  *        and always once at the end with a name of NULL.
1222  * @param proc_cls closure for @a proc
1223  * @return an iterator handle to use for iteration
1224  */
1225 struct GNUNET_NAMESTORE_ZoneIterator *
1226 GNUNET_NAMESTORE_zone_iteration_start (struct GNUNET_NAMESTORE_Handle *h,
1227                                        const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
1228                                        GNUNET_NAMESTORE_RecordMonitor proc,
1229                                        void *proc_cls)
1230 {
1231   struct GNUNET_NAMESTORE_ZoneIterator *it;
1232   struct PendingMessage *pe;
1233   struct ZoneIterationStartMessage * msg;
1234   size_t msg_size;
1235   uint32_t rid;
1236
1237   GNUNET_assert (NULL != h);
1238   rid = get_op_id(h);
1239   it = GNUNET_new (struct GNUNET_NAMESTORE_ZoneIterator);
1240   it->h = h;
1241   it->proc = proc;
1242   it->proc_cls = proc_cls;
1243   it->op_id = rid;
1244   if (NULL != zone)
1245     it->zone = *zone;
1246   GNUNET_CONTAINER_DLL_insert_tail (h->z_head, h->z_tail, it);
1247
1248   msg_size = sizeof (struct ZoneIterationStartMessage);
1249   pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
1250   pe->size = msg_size;
1251   msg = (struct ZoneIterationStartMessage *) &pe[1];
1252   msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START);
1253   msg->gns_header.header.size = htons (msg_size);
1254   msg->gns_header.r_id = htonl (rid);
1255   if (NULL != zone)
1256     msg->zone = *zone;
1257   GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
1258   do_transmit (h);
1259   return it;
1260 }
1261
1262
1263 /**
1264  * Calls the record processor specified in #GNUNET_NAMESTORE_zone_iteration_start
1265  * for the next record.
1266  *
1267  * @param it the iterator
1268  */
1269 void
1270 GNUNET_NAMESTORE_zone_iterator_next (struct GNUNET_NAMESTORE_ZoneIterator *it)
1271 {
1272   struct GNUNET_NAMESTORE_Handle *h;
1273   struct ZoneIterationNextMessage * msg;
1274   struct PendingMessage *pe;
1275   size_t msg_size;
1276
1277   GNUNET_assert (NULL != it);
1278   h = it->h;
1279   msg_size = sizeof (struct ZoneIterationNextMessage);
1280   pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
1281   pe->size = msg_size;
1282   msg = (struct ZoneIterationNextMessage *) &pe[1];
1283   msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT);
1284   msg->gns_header.header.size = htons (msg_size);
1285   msg->gns_header.r_id = htonl (it->op_id);
1286   LOG (GNUNET_ERROR_TYPE_DEBUG,
1287        "Sending `%s' message\n",
1288        "ZONE_ITERATION_NEXT");
1289   GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
1290   do_transmit (h);
1291 }
1292
1293
1294 /**
1295  * Stops iteration and releases the namestore handle for further calls.
1296  *
1297  * @param it the iterator
1298  */
1299 void
1300 GNUNET_NAMESTORE_zone_iteration_stop (struct GNUNET_NAMESTORE_ZoneIterator *it)
1301 {
1302   struct GNUNET_NAMESTORE_Handle *h;
1303   struct PendingMessage *pe;
1304   size_t msg_size;
1305   struct ZoneIterationStopMessage * msg;
1306
1307   GNUNET_assert (NULL != it);
1308   h = it->h;
1309   GNUNET_CONTAINER_DLL_remove (h->z_head,
1310                                h->z_tail,
1311                                it);
1312   msg_size = sizeof (struct ZoneIterationStopMessage);
1313   pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
1314   pe->size = msg_size;
1315   msg = (struct ZoneIterationStopMessage *) &pe[1];
1316   msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP);
1317   msg->gns_header.header.size = htons (msg_size);
1318   msg->gns_header.r_id = htonl (it->op_id);
1319   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1320               "Sending `%s' message\n",
1321               "ZONE_ITERATION_STOP");
1322   GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
1323   do_transmit (h);
1324   GNUNET_free (it);
1325 }
1326
1327
1328 /**
1329  * Cancel a namestore operation.  The final callback from the
1330  * operation must not have been done yet.
1331  *
1332  * @param qe operation to cancel
1333  */
1334 void
1335 GNUNET_NAMESTORE_cancel (struct GNUNET_NAMESTORE_QueueEntry *qe)
1336 {
1337   struct GNUNET_NAMESTORE_Handle *h = qe->nsh;
1338
1339   GNUNET_assert (NULL != qe);
1340   GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, qe);
1341   GNUNET_free(qe);
1342 }
1343
1344
1345 /* end of namestore_api.c */