GNUnet  0.11.x
namestore_api.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2010-2013, 2016 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your 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  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
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"
38 #include "namestore.h"
39 
40 
41 #define LOG(kind, ...) GNUNET_log_from (kind, "namestore-api", __VA_ARGS__)
42 
47 #define NAMESTORE_DELAY_TOLERANCE GNUNET_TIME_UNIT_MINUTES
48 
54 {
59 
64 
69 
74 
78  void *cont_cls;
79 
84 
88  void *proc_cls;
89 
94 
98  void *error_cb_cls;
99 
105 
110 
114  uint32_t op_id;
115 };
116 
117 
122 {
127 
132 
137 
142 
147 
152 
156  void *proc_cls;
157 
162 
167 
173 
178 
182  uint32_t op_id;
183 };
184 
185 
190 {
195 
200 
205 
210 
215 
220 
225 
229  struct GNUNET_TIME_Relative reconnect_delay;
230 
235 
239  uint32_t last_op_id_used;
240 };
241 
242 
248 static void
250 
251 
259 static struct GNUNET_NAMESTORE_QueueEntry *
260 find_qe (struct GNUNET_NAMESTORE_Handle *h, uint32_t rid)
261 {
263 
264  for (qe = h->op_head; qe != NULL; qe = qe->next)
265  if (qe->op_id == rid)
266  return qe;
267  return NULL;
268 }
269 
270 
278 static struct GNUNET_NAMESTORE_ZoneIterator *
279 find_zi (struct GNUNET_NAMESTORE_Handle *h, uint32_t rid)
280 {
282 
283  for (ze = h->z_head; ze != NULL; ze = ze->next)
284  if (ze->op_id == rid)
285  return ze;
286  return NULL;
287 }
288 
289 
295 static void
297 {
298  struct GNUNET_NAMESTORE_Handle *h = qe->h;
299 
301  if (NULL != qe->env)
302  GNUNET_MQ_discard (qe->env);
303  if (NULL != qe->timeout_task)
305  GNUNET_free (qe);
306 }
307 
308 
314 static void
316 {
317  struct GNUNET_NAMESTORE_Handle *h = ze->h;
318 
320  if (NULL != ze->env)
321  GNUNET_MQ_discard (ze->env);
322  GNUNET_free (ze);
323 }
324 
325 
335 static int
336 check_rd (size_t rd_len, const void *rd_buf, unsigned int rd_count)
337 {
338  struct GNUNET_GNSRECORD_Data rd[rd_count];
339 
340  if (GNUNET_OK !=
341  GNUNET_GNSRECORD_records_deserialize (rd_len, rd_buf, rd_count, rd))
342  {
343  GNUNET_break (0);
344  return GNUNET_SYSERR;
345  }
346  return GNUNET_OK;
347 }
348 
349 
357 static void
359  const struct RecordStoreResponseMessage *msg)
360 {
361  struct GNUNET_NAMESTORE_Handle *h = cls;
363  int res;
364  const char *emsg;
365 
366  qe = find_qe (h, ntohl (msg->gns_header.r_id));
367  res = ntohl (msg->op_result);
369  "Received RECORD_STORE_RESPONSE with result %d\n",
370  res);
371  /* TODO: add actual error message from namestore to response... */
372  if (GNUNET_SYSERR == res)
373  emsg = _ ("Namestore failed to store record\n");
374  else
375  emsg = NULL;
376  if (NULL == qe)
377  return;
378  if (NULL != qe->cont)
379  qe->cont (qe->cont_cls, res, emsg);
380  free_qe (qe);
381 }
382 
383 
392 static int
394 {
395  const char *name;
396  size_t exp_msg_len;
397  size_t msg_len;
398  size_t name_len;
399  size_t rd_len;
400 
401  (void) cls;
402  rd_len = ntohs (msg->rd_len);
403  msg_len = ntohs (msg->gns_header.header.size);
404  name_len = ntohs (msg->name_len);
405  exp_msg_len = sizeof(*msg) + name_len + rd_len;
406  if (msg_len != exp_msg_len)
407  {
408  GNUNET_break (0);
409  return GNUNET_SYSERR;
410  }
411  name = (const char *) &msg[1];
412  if ((name_len > 0) && ('\0' != name[name_len - 1]))
413  {
414  GNUNET_break (0);
415  return GNUNET_SYSERR;
416  }
417  if (GNUNET_NO == ntohs (msg->found))
418  {
419  if (0 != ntohs (msg->rd_count))
420  {
421  GNUNET_break (0);
422  return GNUNET_SYSERR;
423  }
424  return GNUNET_OK;
425  }
426  return check_rd (rd_len, &name[name_len], ntohs (msg->rd_count));
427 }
428 
429 
437 static void
439 {
440  struct GNUNET_NAMESTORE_Handle *h = cls;
442  const char *name;
443  const char *rd_tmp;
444  size_t name_len;
445  size_t rd_len;
446  unsigned int rd_count;
447 
448  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_LOOKUP_RESULT\n");
449  qe = find_qe (h, ntohl (msg->gns_header.r_id));
450  if (NULL == qe)
451  return;
452  rd_len = ntohs (msg->rd_len);
453  rd_count = ntohs (msg->rd_count);
454  name_len = ntohs (msg->name_len);
455  name = (const char *) &msg[1];
456  if (GNUNET_NO == ntohs (msg->found))
457  {
458  /* label was not in namestore */
459  if (NULL != qe->proc)
460  qe->proc (qe->proc_cls, &msg->private_key, name, 0, NULL);
461  free_qe (qe);
462  return;
463  }
464 
465  rd_tmp = &name[name_len];
466  {
467  struct GNUNET_GNSRECORD_Data rd[rd_count];
468 
469  GNUNET_assert (
470  GNUNET_OK ==
471  GNUNET_GNSRECORD_records_deserialize (rd_len, rd_tmp, rd_count, rd));
472  if (0 == name_len)
473  name = NULL;
474  if (NULL != qe->proc)
475  qe->proc (qe->proc_cls,
476  &msg->private_key,
477  name,
478  rd_count,
479  (rd_count > 0) ? rd : NULL);
480  }
481  free_qe (qe);
482 }
483 
484 
493 static int
494 check_record_result (void *cls, const struct RecordResultMessage *msg)
495 {
496  static struct GNUNET_IDENTITY_PrivateKey priv_dummy;
497  const char *name;
498  size_t msg_len;
499  size_t name_len;
500  size_t rd_len;
501 
502  (void) cls;
503  rd_len = ntohs (msg->rd_len);
504  msg_len = ntohs (msg->gns_header.header.size);
505  name_len = ntohs (msg->name_len);
506  if (0 != ntohs (msg->reserved))
507  {
508  GNUNET_break (0);
509  return GNUNET_SYSERR;
510  }
511  if (msg_len != sizeof(struct RecordResultMessage) + name_len + rd_len)
512  {
513  GNUNET_break (0);
514  return GNUNET_SYSERR;
515  }
516  name = (const char *) &msg[1];
517  if ((0 == name_len) || ('\0' != name[name_len - 1]))
518  {
519  GNUNET_break (0);
520  return GNUNET_SYSERR;
521  }
522  if (0 == GNUNET_memcmp (&msg->private_key, &priv_dummy))
523  {
524  GNUNET_break (0);
525  return GNUNET_SYSERR;
526  }
527  return check_rd (rd_len, &name[name_len], ntohs (msg->rd_count));
528 }
529 
530 
538 static void
539 handle_record_result (void *cls, const struct RecordResultMessage *msg)
540 {
541  struct GNUNET_NAMESTORE_Handle *h = cls;
544  const char *name;
545  const char *rd_tmp;
546  size_t name_len;
547  size_t rd_len;
548  unsigned int rd_count;
549 
550  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_RESULT\n");
551  rd_len = ntohs (msg->rd_len);
552  rd_count = ntohs (msg->rd_count);
553  name_len = ntohs (msg->name_len);
554  ze = find_zi (h, ntohl (msg->gns_header.r_id));
555  qe = find_qe (h, ntohl (msg->gns_header.r_id));
556  if ((NULL == ze) && (NULL == qe))
557  return; /* rid not found */
558  if ((NULL != ze) && (NULL != qe))
559  {
560  GNUNET_break (0); /* rid ambiguous */
561  force_reconnect (h);
562  return;
563  }
564  name = (const char *) &msg[1];
565  rd_tmp = &name[name_len];
566  {
567  struct GNUNET_GNSRECORD_Data rd[rd_count];
568 
569  GNUNET_assert (
570  GNUNET_OK ==
571  GNUNET_GNSRECORD_records_deserialize (rd_len, rd_tmp, rd_count, rd));
572  if (0 == name_len)
573  name = NULL;
574  if (NULL != qe)
575  {
576  if (NULL != qe->proc)
577  qe->proc (qe->proc_cls,
578  &msg->private_key,
579  name,
580  rd_count,
581  (rd_count > 0) ? rd : NULL);
582  free_qe (qe);
583  return;
584  }
585  if (NULL != ze)
586  {
587  if (NULL != ze->proc)
588  ze->proc (ze->proc_cls, &msg->private_key, name, rd_count, rd);
589  return;
590  }
591  }
592  GNUNET_assert (0);
593 }
594 
595 
603 static void
605 {
606  struct GNUNET_NAMESTORE_Handle *h = cls;
609 
610  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_RESULT_END\n");
611  ze = find_zi (h, ntohl (msg->r_id));
612  qe = find_qe (h, ntohl (msg->r_id));
613  if ((NULL == ze) && (NULL == qe))
614  return; /* rid not found */
615  if ((NULL != ze) && (NULL != qe))
616  {
617  GNUNET_break (0); /* rid ambiguous */
618  force_reconnect (h);
619  return;
620  }
621  LOG (GNUNET_ERROR_TYPE_DEBUG, "Zone iteration completed!\n");
622  if (NULL == ze)
623  {
624  GNUNET_break (0);
625  force_reconnect (h);
626  return;
627  }
628  if (NULL != ze->finish_cb)
629  ze->finish_cb (ze->finish_cb_cls);
630  free_ze (ze);
631 }
632 
633 
642 static int
644  const struct ZoneToNameResponseMessage *msg)
645 {
646  size_t name_len;
647  size_t rd_ser_len;
648  const char *name_tmp;
649 
650  (void) cls;
651  if (GNUNET_OK != ntohs (msg->res))
652  return GNUNET_OK;
653  name_len = ntohs (msg->name_len);
654  rd_ser_len = ntohs (msg->rd_len);
655  if (ntohs (msg->gns_header.header.size) !=
656  sizeof(struct ZoneToNameResponseMessage) + name_len + rd_ser_len)
657  {
658  GNUNET_break (0);
659  return GNUNET_SYSERR;
660  }
661  name_tmp = (const char *) &msg[1];
662  if ((name_len > 0) && ('\0' != name_tmp[name_len - 1]))
663  {
664  GNUNET_break (0);
665  return GNUNET_SYSERR;
666  }
667  return check_rd (rd_ser_len, &name_tmp[name_len], ntohs (msg->rd_count));
668 }
669 
670 
678 static void
680  const struct ZoneToNameResponseMessage *msg)
681 {
682  struct GNUNET_NAMESTORE_Handle *h = cls;
684  int res;
685  size_t name_len;
686  size_t rd_ser_len;
687  unsigned int rd_count;
688  const char *name_tmp;
689  const char *rd_tmp;
690 
691  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_TO_NAME_RESPONSE\n");
692  qe = find_qe (h, ntohl (msg->gns_header.r_id));
693  if (NULL == qe)
694  {
696  "Response queue already gone...\n");
697  return;
698  }
699  res = ntohs (msg->res);
700  switch (res)
701  {
702  case GNUNET_SYSERR:
704  "An error occurred during zone to name operation\n");
705  break;
706 
707  case GNUNET_NO:
709  "Namestore has no result for zone to name mapping \n");
710  if (NULL != qe->proc)
711  qe->proc (qe->proc_cls, &msg->zone, NULL, 0, NULL);
712  free_qe (qe);
713  return;
714 
715  case GNUNET_YES:
717  "Namestore has result for zone to name mapping \n");
718  name_len = ntohs (msg->name_len);
719  rd_count = ntohs (msg->rd_count);
720  rd_ser_len = ntohs (msg->rd_len);
721  name_tmp = (const char *) &msg[1];
722  rd_tmp = &name_tmp[name_len];
723  {
724  struct GNUNET_GNSRECORD_Data rd[rd_count];
725 
728  rd_tmp,
729  rd_count,
730  rd));
731  /* normal end, call continuation with result */
732  if (NULL != qe->proc)
733  qe->proc (qe->proc_cls, &msg->zone, name_tmp, rd_count, rd);
734  /* return is important here: break would call continuation with error! */
735  free_qe (qe);
736  return;
737  }
738 
739  default:
740  GNUNET_break (0);
741  force_reconnect (h);
742  return;
743  }
744  /* error case, call continuation with error */
745  if (NULL != qe->error_cb)
746  qe->error_cb (qe->error_cb_cls);
747  free_qe (qe);
748 }
749 
750 
759 static void
760 mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
761 {
762  struct GNUNET_NAMESTORE_Handle *h = cls;
763 
764  (void) error;
765  force_reconnect (h);
766 }
767 
768 
774 static void
776 {
777  struct GNUNET_MQ_MessageHandler handlers[] =
778  { GNUNET_MQ_hd_fixed_size (record_store_response,
781  h),
782  GNUNET_MQ_hd_var_size (zone_to_name_response,
785  h),
786  GNUNET_MQ_hd_var_size (record_result,
788  struct RecordResultMessage,
789  h),
790  GNUNET_MQ_hd_fixed_size (record_result_end,
793  h),
794  GNUNET_MQ_hd_var_size (lookup_result,
797  h),
801 
802  GNUNET_assert (NULL == h->mq);
803  h->mq =
804  GNUNET_CLIENT_connect (h->cfg, "namestore", handlers, &mq_error_handler, h);
805  if (NULL == h->mq)
806  return;
807  /* re-transmit pending requests that waited for a reconnect... */
808  for (it = h->z_head; NULL != it; it = it->next)
809  {
810  GNUNET_MQ_send (h->mq, it->env);
811  it->env = NULL;
812  }
813  for (qe = h->op_head; NULL != qe; qe = qe->next)
814  {
815  GNUNET_MQ_send (h->mq, qe->env);
816  qe->env = NULL;
817  }
818 }
819 
820 
826 static void
827 reconnect_task (void *cls)
828 {
829  struct GNUNET_NAMESTORE_Handle *h = cls;
830 
831  h->reconnect_task = NULL;
832  reconnect (h);
833 }
834 
835 
841 static void
843 {
846 
847  GNUNET_MQ_destroy (h->mq);
848  h->mq = NULL;
849  while (NULL != (ze = h->z_head))
850  {
851  if (NULL != ze->error_cb)
852  ze->error_cb (ze->error_cb_cls);
853  free_ze (ze);
854  }
855  while (NULL != (qe = h->op_head))
856  {
857  if (NULL != qe->error_cb)
858  qe->error_cb (qe->error_cb_cls);
859  if (NULL != qe->cont)
860  qe->cont (qe->cont_cls,
862  "failure in communication with namestore service");
863  free_qe (qe);
864  }
865 
866  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting to namestore\n");
868  h->reconnect_task =
870 }
871 
872 
879 static uint32_t
881 {
882  return h->last_op_id_used++;
883 }
884 
885 
894 {
895  struct GNUNET_NAMESTORE_Handle *h;
896 
897  h = GNUNET_new (struct GNUNET_NAMESTORE_Handle);
898  h->cfg = cfg;
899  reconnect (h);
900  if (NULL == h->mq)
901  {
902  GNUNET_free (h);
903  return NULL;
904  }
905  return h;
906 }
907 
908 
915 void
917 {
920 
921  LOG (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
922  GNUNET_break (NULL == h->op_head);
923  while (NULL != (q = h->op_head))
924  {
926  GNUNET_free (q);
927  }
928  GNUNET_break (NULL == h->z_head);
929  while (NULL != (z = h->z_head))
930  {
932  GNUNET_free (z);
933  }
934  if (NULL != h->mq)
935  {
936  GNUNET_MQ_destroy (h->mq);
937  h->mq = NULL;
938  }
939  if (NULL != h->reconnect_task)
940  {
942  h->reconnect_task = NULL;
943  }
944  GNUNET_free (h);
945 }
946 
947 
954 static void
955 warn_delay (void *cls)
956 {
957  struct GNUNET_NAMESTORE_QueueEntry *qe = cls;
958 
959  qe->timeout_task = NULL;
961  "Did not receive response from namestore after %s!\n",
963  GNUNET_YES));
964  if (NULL != qe->cont)
965  {
966  qe->cont (qe->cont_cls, GNUNET_SYSERR, "timeout");
967  qe->cont = NULL;
968  }
970 }
971 
972 
989  struct GNUNET_NAMESTORE_Handle *h,
990  const struct GNUNET_IDENTITY_PrivateKey *pkey,
991  const char *label,
992  unsigned int rd_count,
993  const struct GNUNET_GNSRECORD_Data *rd,
995  void *cont_cls)
996 {
998  struct GNUNET_MQ_Envelope *env;
999  char *name_tmp;
1000  char *rd_ser;
1001  ssize_t rd_ser_len;
1002  size_t name_len;
1003  uint32_t rid;
1004  struct RecordStoreMessage *msg;
1005  ssize_t sret;
1006 
1007  name_len = strlen (label) + 1;
1008  if (name_len > MAX_NAME_LEN)
1009  {
1010  GNUNET_break (0);
1011  return NULL;
1012  }
1013  rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
1014  if (rd_ser_len < 0)
1015  {
1016  GNUNET_break (0);
1017  return NULL;
1018  }
1019  if (rd_ser_len > UINT16_MAX)
1020  {
1021  GNUNET_break (0);
1022  return NULL;
1023  }
1024  rid = get_op_id (h);
1026  qe->h = h;
1027  qe->cont = cont;
1028  qe->cont_cls = cont_cls;
1029  qe->op_id = rid;
1031 
1032  /* setup msg */
1033  env = GNUNET_MQ_msg_extra (msg,
1034  name_len + rd_ser_len,
1036  msg->gns_header.r_id = htonl (rid);
1037  msg->name_len = htons (name_len);
1038  msg->rd_count = htons (rd_count);
1039  msg->rd_len = htons (rd_ser_len);
1040  msg->reserved = htons (0);
1041  msg->private_key = *pkey;
1042 
1043  name_tmp = (char *) &msg[1];
1044  GNUNET_memcpy (name_tmp, label, name_len);
1045  rd_ser = &name_tmp[name_len];
1046  sret = GNUNET_GNSRECORD_records_serialize (rd_count, rd, rd_ser_len, rd_ser);
1047  if ((0 > sret) || (sret != rd_ser_len))
1048  {
1049  GNUNET_break (0);
1050  GNUNET_free (env);
1051  return NULL;
1052  }
1053  GNUNET_assert (rd_ser_len == sret);
1055  "Sending NAMESTORE_RECORD_STORE message for name `%s' with %u records\n",
1056  label,
1057  rd_count);
1058  qe->timeout_task =
1060  if (NULL == h->mq)
1061  {
1062  qe->env = env;
1064  "Delaying NAMESTORE_RECORD_STORE message as namestore is not ready!\n");
1065  }
1066  else
1067  {
1068  GNUNET_MQ_send (h->mq, env);
1069  }
1070  return qe;
1071 }
1072 
1073 
1088  struct GNUNET_NAMESTORE_Handle *h,
1089  const struct GNUNET_IDENTITY_PrivateKey *pkey,
1090  const char *label,
1092  void *error_cb_cls,
1094  void *rm_cls)
1095 {
1097  struct GNUNET_MQ_Envelope *env;
1098  struct LabelLookupMessage *msg;
1099  size_t label_len;
1100 
1101  if (1 == (label_len = strlen (label) + 1))
1102  {
1103  GNUNET_break (0);
1104  return NULL;
1105  }
1106 
1108  qe->h = h;
1109  qe->error_cb = error_cb;
1110  qe->error_cb_cls = error_cb_cls;
1111  qe->proc = rm;
1112  qe->proc_cls = rm_cls;
1113  qe->op_id = get_op_id (h);
1115 
1116  env = GNUNET_MQ_msg_extra (msg,
1117  label_len,
1119  msg->gns_header.r_id = htonl (qe->op_id);
1120  msg->zone = *pkey;
1121  msg->label_len = htonl (label_len);
1122  GNUNET_memcpy (&msg[1], label, label_len);
1123  if (NULL == h->mq)
1124  qe->env = env;
1125  else
1126  GNUNET_MQ_send (h->mq, env);
1127  return qe;
1128 }
1129 
1130 
1148  struct GNUNET_NAMESTORE_Handle *h,
1149  const struct GNUNET_IDENTITY_PrivateKey *zone,
1150  const struct GNUNET_IDENTITY_PublicKey *value_zone,
1152  void *error_cb_cls,
1154  void *proc_cls)
1155 {
1157  struct GNUNET_MQ_Envelope *env;
1158  struct ZoneToNameMessage *msg;
1159  uint32_t rid;
1160 
1161  rid = get_op_id (h);
1163  qe->h = h;
1164  qe->error_cb = error_cb;
1165  qe->error_cb_cls = error_cb_cls;
1166  qe->proc = proc;
1167  qe->proc_cls = proc_cls;
1168  qe->op_id = rid;
1170 
1172  msg->gns_header.r_id = htonl (rid);
1173  msg->zone = *zone;
1174  msg->value_zone = *value_zone;
1175  if (NULL == h->mq)
1176  qe->env = env;
1177  else
1178  GNUNET_MQ_send (h->mq, env);
1179  return qe;
1180 }
1181 
1182 
1204  struct GNUNET_NAMESTORE_Handle *h,
1205  const struct GNUNET_IDENTITY_PrivateKey *zone,
1207  void *error_cb_cls,
1209  void *proc_cls,
1211  void *finish_cb_cls)
1212 {
1213  struct GNUNET_NAMESTORE_ZoneIterator *it;
1214  struct GNUNET_MQ_Envelope *env;
1216  uint32_t rid;
1217 
1218  LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending ZONE_ITERATION_START message\n");
1219  rid = get_op_id (h);
1221  it->h = h;
1222  it->error_cb = error_cb;
1223  it->error_cb_cls = error_cb_cls;
1224  it->finish_cb = finish_cb;
1225  it->finish_cb_cls = finish_cb_cls;
1226  it->proc = proc;
1227  it->proc_cls = proc_cls;
1228  it->op_id = rid;
1229  if (NULL != zone)
1230  it->zone = *zone;
1233  msg->gns_header.r_id = htonl (rid);
1234  if (NULL != zone)
1235  msg->zone = *zone;
1236  if (NULL == h->mq)
1237  it->env = env;
1238  else
1239  GNUNET_MQ_send (h->mq, env);
1240  return it;
1241 }
1242 
1243 
1252 void
1254  uint64_t limit)
1255 {
1256  struct GNUNET_NAMESTORE_Handle *h = it->h;
1257  struct ZoneIterationNextMessage *msg;
1258  struct GNUNET_MQ_Envelope *env;
1259 
1261  "Sending ZONE_ITERATION_NEXT message with limit %llu\n",
1262  (unsigned long long) limit);
1264  msg->gns_header.r_id = htonl (it->op_id);
1265  msg->limit = GNUNET_htonll (limit);
1266  GNUNET_MQ_send (h->mq, env);
1267 }
1268 
1269 
1275 void
1277 {
1278  struct GNUNET_NAMESTORE_Handle *h = it->h;
1279  struct GNUNET_MQ_Envelope *env;
1280  struct ZoneIterationStopMessage *msg;
1281 
1282  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ZONE_ITERATION_STOP message\n");
1283  if (NULL != h->mq)
1284  {
1285  env =
1287  msg->gns_header.r_id = htonl (it->op_id);
1288  GNUNET_MQ_send (h->mq, env);
1289  }
1290  free_ze (it);
1291 }
1292 
1293 
1300 void
1302 {
1303  free_qe (qe);
1304 }
1305 
1306 
1307 /* end of namestore_api.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_NAMESTORE_Handle * h
Main handle to access the namestore.
Definition: namestore_api.c:68
struct GNUNET_IDENTITY_PrivateKey private_key
The private key of the authority.
Definition: namestore.h:179
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE.
Definition: namestore.h:110
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE.
Definition: namestore.h:63
void(* GNUNET_NAMESTORE_RecordMonitor)(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Process a record that was stored in the namestore.
static struct GNUNET_DATASTORE_QueueEntry * qe
Current operation.
GNUNET_SCHEDULER_TaskCallback error_cb
Function to call on errors.
GNUNET_NETWORK_STRUCT_END ssize_t GNUNET_GNSRECORD_records_get_size(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Calculate how many bytes we will need to serialize the given records.
struct GNUNET_MQ_Envelope * env
Envelope of the message to send to the service, if not yet sent.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
void(* GNUNET_NAMESTORE_ContinuationWithStatus)(void *cls, int32_t success, const char *emsg)
Continuation called to notify client about result of the operation.
uint32_t label_len
Length of the name.
Definition: namestore.h:132
static char * pkey
Public key of the zone to look in, in ASCII.
static void handle_lookup_result(void *cls, const struct LabelLookupResponseMessage *msg)
Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE.
#define GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE
Service to client: result of zone-to-name lookup.
GNUNET_SCHEDULER_TaskCallback finish_cb
Function to call on completion.
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1063
static int check_zone_to_name_response(void *cls, const struct ZoneToNameResponseMessage *msg)
Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE.
GNUNET_NAMESTORE_RecordMonitor proc
Function to call with the records we get back; or NULL.
Definition: namestore_api.c:83
Ask for next result of zone iteration for the given operation.
Definition: namestore.h:362
uint16_t rd_len
Length of serialized record data.
Definition: namestore.h:163
GNUNET_MQ_Error
Error codes for the queue.
ssize_t GNUNET_GNSRECORD_records_serialize(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, size_t dest_size, char *dest)
Serialize the given records to the given destination buffer.
GNUNET_NAMESTORE_RecordMonitor proc
The continuation to call with the results.
uint16_t reserved
always zero (for alignment)
Definition: namestore.h:281
uint32_t r_id
Request ID in NBO.
Definition: namestore.h:51
uint16_t rd_count
Number of records contained.
Definition: namestore.h:168
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
GNUNET_SCHEDULER_TaskCallback error_cb
Function to call on errors.
Definition: namestore_api.c:93
struct GNUNET_NAMESTORE_QueueEntry * prev
Kept in a DLL.
Definition: namestore_api.c:63
uint32_t op_id
The operation id this zone iteration operation has.
Start a zone iteration for the given zone.
Definition: namestore.h:345
void * proc_cls
Closure for proc.
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME.
Definition: namestore.h:196
uint16_t name_len
Length of the name.
Definition: namestore.h:223
A private key for an identity as per LSD0001.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
static void handle_record_store_response(void *cls, const struct RecordStoreResponseMessage *msg)
Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
int16_t res
result in NBO: GNUNET_OK on success, GNUNET_NO if there were no results, GNUNET_SYSERR on error ...
Definition: namestore.h:239
struct GNUNET_IDENTITY_PrivateKey private_key
The private key of the authority.
Definition: namestore.h:286
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_store(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *pkey, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the namestore.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GNUNET_NAMESTORE_zone_iterator_next(struct GNUNET_NAMESTORE_ZoneIterator *it, uint64_t limit)
Calls the record processor specified in GNUNET_NAMESTORE_zone_iteration_start for the next record...
static void handle_record_result_end(void *cls, const struct GNUNET_NAMESTORE_Header *msg)
Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END.
#define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END
Service to client: end of list of results.
int GNUNET_GNSRECORD_records_deserialize(size_t len, const char *src, unsigned int rd_count, struct GNUNET_GNSRECORD_Data *dest)
Deserialize the given records to the given destination.
void * error_cb_cls
Closure for error_cb.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
struct GNUNET_IDENTITY_PrivateKey zone
Zone key.
Definition: namestore.h:355
#define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP
Client to service: lookup label.
void * proc_cls
Closure for proc.
Definition: namestore_api.c:88
void * error_cb_cls
Closure for error_cb.
Definition: namestore_api.c:98
#define GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP
Client to service: stop iterating.
uint16_t reserved
always zero (for alignment)
Definition: namestore.h:88
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint32_t last_op_id_used
The last operation id used for a NAMESTORE operation.
void(* GNUNET_SCHEDULER_TaskCallback)(void *cls)
Signature of the main function of a task.
static int check_record_result(void *cls, const struct RecordResultMessage *msg)
Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT.
void GNUNET_NAMESTORE_cancel(struct GNUNET_NAMESTORE_QueueEntry *qe)
Cancel a namestore operation.
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
static void free_ze(struct GNUNET_NAMESTORE_ZoneIterator *ze)
Free ze.
uint16_t name_len
Name length.
Definition: namestore.h:266
common internal definitions for namestore service
static char * zone
Name of the zone being managed.
uint16_t rd_count
Number of records contained.
Definition: namestore.h:233
int32_t op_result
GNUNET_SYSERR on failure, GNUNET_OK on success
Definition: namestore.h:115
struct GNUNET_MessageHeader header
header.type will be GNUNET_MESSAGE_TYPE_NAMESTORE_* header.size will be message size ...
Definition: namestore.h:46
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
cryptographic primitives for GNUnet
struct GNUNET_IDENTITY_PrivateKey zone
The private key of the zone to look up in.
Definition: namestore.h:137
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
Handle for a zone iterator operation.
struct GNUNET_NAMESTORE_QueueEntry * next
Kept in a DLL.
Definition: namestore_api.c:58
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
struct GNUNET_TIME_Relative reconnect_delay
Delay introduced before we reconnect.
static int check_rd(size_t rd_len, const void *rd_buf, unsigned int rd_count)
Check that rd_buf of length rd_len contains rd_count records.
uint16_t rd_len
Length of serialized record data.
Definition: namestore.h:78
uint16_t rd_count
Number of records contained.
Definition: namestore.h:276
#define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE
Client to service: store records (as authority)
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
static void handle_record_result(void *cls, const struct RecordResultMessage *msg)
Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT.
Connection to the NAMESTORE service.
struct GNUNET_MQ_Handle * mq
Connection to the service (if available).
static void force_reconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from service and then reconnect.
static struct GNUNET_NAMESTORE_ZoneIterator * find_zi(struct GNUNET_NAMESTORE_Handle *h, uint32_t rid)
Find the zone iteration entry that matches the rid.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:557
#define NAMESTORE_DELAY_TOLERANCE
We grant the namestore up to 1 minute of latency, if it is slower than that, store queries will fail...
Definition: namestore_api.c:47
Stop zone iteration for the given operation.
Definition: namestore.h:381
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_zone_to_name(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *zone, const struct GNUNET_IDENTITY_PublicKey *value_zone, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor proc, void *proc_cls)
Look for an existing PKEY delegation record for a given public key.
uint16_t name_len
Name length.
Definition: namestore.h:73
struct GNUNET_MQ_Envelope * env
Envelope of the message to send to the service, if not yet sent.
uint16_t name_len
Name length.
Definition: namestore.h:158
struct GNUNET_NAMESTORE_ZoneIterator * GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *zone, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
Starts a new zone iteration (used to periodically PUT all of our records into our DHT)...
void GNUNET_NAMESTORE_zone_iteration_stop(struct GNUNET_NAMESTORE_ZoneIterator *it)
Stops iteration and releases the namestore handle for further calls.
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START.
Definition: namestore.h:350
Message handler for a specific message type.
static int res
static void warn_delay(void *cls)
Task launched to warn the user that the namestore is excessively slow and that a query was thus dropp...
uint16_t rd_count
Number of records contained.
Definition: namestore.h:83
static struct GNUNET_REVOCATION_Query * q
Handle for revocation query.
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:323
#define GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME
Client to service: "reverse" lookup for zone name based on zone key.
struct GNUNET_IDENTITY_PrivateKey private_key
The private key of the authority.
Definition: namestore.h:93
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:36
struct GNUNET_NAMESTORE_QueueEntry * op_tail
Tail of pending namestore queue entries.
struct GNUNET_NAMESTORE_ZoneIterator * next
Kept in a DLL.
#define GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START
Client to service: please start iteration; receives "GNUNET_MESSAGE_TYPE_NAMESTORE_LOOKUP_NAME_RESPON...
#define GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT
Client to service: next record(s) in iteration please.
An QueueEntry used to store information for a pending NAMESTORE record operation. ...
Definition: namestore_api.c:53
struct GNUNET_NAMESTORE_Handle * h
Main handle to access the namestore.
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the connection with the NAMESTORE service.
struct GNUNET_NAMESTORE_ZoneIterator * prev
Kept in a DLL.
uint32_t op_id
The operation id this zone iteration operation has.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
uint16_t found
Was the label found in the database?? GNUNET_YES or GNUNET_NO.
Definition: namestore.h:174
uint16_t rd_len
Length of serialized record data.
Definition: namestore.h:271
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
GNUNET_NAMESTORE_ContinuationWithStatus cont
Continuation to call.
Definition: namestore_api.c:73
static void reconnect(struct GNUNET_NAMESTORE_Handle *h)
Reconnect to namestore service.
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT.
Definition: namestore.h:261
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
static void free_qe(struct GNUNET_NAMESTORE_QueueEntry *qe)
Free qe.
#define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE
Service to client: lookup label.
int reconnect
Should we reconnect to service due to some serious error?
#define LOG(kind,...)
Definition: namestore_api.c:41
Handle to a message queue.
Definition: mq.c:85
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE.
Definition: namestore.h:218
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_lookup(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *pkey, const char *label, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor rm, void *rm_cls)
Lookup an item in the namestore.
void * finish_cb_cls
Closure for error_cb.
Store a record to the namestore (as authority).
Definition: namestore.h:58
Respone for zone to name lookup.
Definition: namestore.h:213
void * cont_cls
Closure for cont.
Definition: namestore_api.c:78
An identity key as per LSD0001.
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE.
Definition: namestore.h:153
struct GNUNET_IDENTITY_PrivateKey zone
The private key of the zone that contained the name.
Definition: namestore.h:244
configuration data
Definition: configuration.c:84
const char * name
Response to a record storage request.
Definition: namestore.h:105
struct GNUNET_NAMESTORE_QueueEntry * op_head
Head of pending namestore queue entries.
struct GNUNET_NAMESTORE_ZoneIterator * z_head
Head of pending namestore zone iterator entries.
#define MAX_NAME_LEN
Maximum length of any name, including 0-termination.
Definition: namecache.h:33
struct GNUNET_IDENTITY_PublicKey value_zone
The public key of the target zone.
Definition: namestore.h:206
static uint32_t get_op_id(struct GNUNET_NAMESTORE_Handle *h)
Get a fresh operation id to distinguish between namestore requests.
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
Generic namestore message with op id.
Definition: namestore.h:40
static void handle_zone_to_name_response(void *cls, const struct ZoneToNameResponseMessage *msg)
Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE.
struct GNUNET_SCHEDULER_Task * timeout_task
Task scheduled to warn us if the namestore is way too slow.
uint16_t rd_len
Length of serialized record data.
Definition: namestore.h:228
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP.
Definition: namestore.h:127
Lookup a name for a zone hash.
Definition: namestore.h:191
Lookup a label.
Definition: namestore.h:122
struct GNUNET_IDENTITY_PrivateKey zone
The private key of the zone to look up in.
Definition: namestore.h:201
struct GNUNET_SCHEDULER_Task * reconnect_task
Reconnect task.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
#define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT
Service to client: here is a (plaintext) record you requested.
struct GNUNET_NAMESTORE_ZoneIterator * z_tail
Tail of pending namestore zone iterator entries.
Record is returned from the namestore (as authority).
Definition: namestore.h:256
uint64_t limit
Number of records to return to the iterator in one shot (before GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_IT...
Definition: namestore.h:374
static struct GNUNET_NAMESTORE_QueueEntry * find_qe(struct GNUNET_NAMESTORE_Handle *h, uint32_t rid)
Find the queue entry that matches the rid.
static void mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
struct GNUNET_IDENTITY_PrivateKey zone
Private key of the zone.
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT.
Definition: namestore.h:367
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
struct GNUNET_NAMESTORE_Header gns_header
Type will be GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP.
Definition: namestore.h:386
Lookup a label.
Definition: namestore.h:148
static int check_lookup_result(void *cls, const struct LabelLookupResponseMessage *msg)
Check validity of an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE.
static void reconnect_task(void *cls)
Re-establish the connection to the service.
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
#define GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE
Service to client: result of store operation.