GNUnet  0.11.x
fs_namespace.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2003-2013 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 
27 #include "platform.h"
28 #include "gnunet_constants.h"
29 #include "gnunet_signatures.h"
30 #include "gnunet_util_lib.h"
31 #include "gnunet_fs_service.h"
32 #include "fs_api.h"
33 #include "fs_publish_ublock.h"
34 
35 
41 {
45  char *id;
46 
50  char *update;
51 
56 
60  struct GNUNET_FS_Uri *uri;
61 
66  unsigned int nug;
67 
71  unsigned int tree_id;
72 };
73 
74 
79 {
84 
89 
94 
100 
104  unsigned int update_node_count;
105 
109  unsigned int rc;
110 
114  unsigned int nug_gen;
115 };
116 
117 
126 static char *
128  struct GNUNET_FS_Handle *h,
129  const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns)
130 {
131  char *dn;
132  char *ret;
133  struct GNUNET_CRYPTO_EcdsaPublicKey pub;
134  struct GNUNET_HashCode hc;
136 
137  if (GNUNET_OK !=
138  GNUNET_CONFIGURATION_get_value_filename (h->cfg, "FS", "UPDATE_DIR", &dn))
139  {
141  return NULL;
142  }
144  GNUNET_CRYPTO_hash (&pub, sizeof(pub), &hc);
145  GNUNET_CRYPTO_hash_to_enc (&hc, &enc);
146  GNUNET_asprintf (&ret,
147  "%s%s%s",
148  dn,
150  (const char *) enc.encoding);
151  GNUNET_free (dn);
152  return ret;
153 }
154 
155 
161 static void
163 {
164  unsigned int i;
165  struct NamespaceUpdateNode *nsn;
166 
167  for (i = 0; i < uig->update_node_count; i++)
168  {
169  nsn = uig->update_nodes[i];
171  GNUNET_FS_uri_destroy (nsn->uri);
172  GNUNET_free (nsn->id);
173  GNUNET_free (nsn->update);
174  GNUNET_free (nsn);
175  }
177  if (NULL != uig->update_map)
179  GNUNET_free (uig);
180 }
181 
182 
188 static void
190 {
191  char *fn;
192  struct GNUNET_BIO_WriteHandle *wh;
193  unsigned int i;
194  struct NamespaceUpdateNode *n;
195  char *uris;
196 
197  fn = get_update_information_directory (uig->h, &uig->ns);
198  wh = GNUNET_BIO_write_open_file (fn);
199  if (NULL == wh)
200  {
202  _ ("Failed to open `%s' for writing: %s\n"),
203  fn,
204  strerror (errno));
205  GNUNET_free (fn);
206  return;
207  }
209  "fs-namespace-node-count",
210  uig->update_node_count))
211  goto END;
212  for (i = 0; i < uig->update_node_count; i++)
213  {
214  n = uig->update_nodes[i];
215  uris = GNUNET_FS_uri_to_string (n->uri);
216  struct GNUNET_BIO_WriteSpec ws[] = {
217  GNUNET_BIO_write_spec_string ("fs-namespace-node-id", n->id),
218  GNUNET_BIO_write_spec_meta_data ("fs-namespace-node-meta", n->md),
219  GNUNET_BIO_write_spec_string ("fs-namespace-node-update", n->update),
220  GNUNET_BIO_write_spec_string ("fs-namespace-uris", uris),
222  };
223  if (GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws))
224  {
225  GNUNET_free (uris);
226  break;
227  }
228  GNUNET_free (uris);
229  }
230 END:
231  if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
233  _ ("Failed to write `%s': %s\n"),
234  fn,
235  strerror (errno));
236  GNUNET_free (fn);
237 }
238 
239 
247 static struct GNUNET_FS_UpdateInformationGraph *
249  const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns)
250 {
252  char *fn;
253  struct GNUNET_BIO_ReadHandle *rh;
254  unsigned int i;
255  struct NamespaceUpdateNode *n;
256  char *uris;
257  uint32_t count;
258  char *emsg;
259 
261  uig->h = h;
262  uig->ns = *ns;
264  if (GNUNET_YES != GNUNET_DISK_file_test (fn))
265  {
266  GNUNET_free (fn);
267  return uig;
268  }
269  rh = GNUNET_BIO_read_open_file (fn);
270  if (NULL == rh)
271  {
272  GNUNET_free (fn);
273  return uig;
274  }
275  if (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "fs-namespace-count",
276  (int32_t *) &count))
277  {
278  GNUNET_break (0);
279  goto END;
280  }
281  if (count > 1024 * 1024)
282  {
283  GNUNET_break (0);
284  goto END;
285  }
286  if (0 == count)
287  goto END;
288  uig->update_nodes =
289  GNUNET_malloc (count * sizeof(struct NamespaceUpdateNode *));
290 
291  for (i = 0; i < count; i++)
292  {
293  n = GNUNET_new (struct NamespaceUpdateNode);
294  struct GNUNET_BIO_ReadSpec rs[] = {
295  GNUNET_BIO_read_spec_string ("identifier", &n->id, 1024),
296  GNUNET_BIO_read_spec_meta_data ("meta", &n->md),
297  GNUNET_BIO_read_spec_string ("update-id", &n->update, 1024),
298  GNUNET_BIO_read_spec_string ("uri", &uris, 1024 * 2),
300  };
301  if (GNUNET_OK != GNUNET_BIO_read_spec_commit (rh, rs))
302  {
303  GNUNET_break (0);
304  GNUNET_free (n->id);
305  GNUNET_free (n->update);
306  if (n->md != NULL)
308  GNUNET_free (n);
309  break;
310  }
311  n->uri = GNUNET_FS_uri_parse (uris, &emsg);
312  GNUNET_free (uris);
313  if (n->uri == NULL)
314  {
315  GNUNET_break (0);
316  GNUNET_free (emsg);
317  GNUNET_free (n->id);
318  GNUNET_free (n->update);
320  GNUNET_free (n);
321  break;
322  }
323  uig->update_nodes[i] = n;
324  }
325  uig->update_node_count = i;
326 END:
327  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
328  {
330  _ ("Failed to read `%s': %s\n"),
331  fn,
332  emsg);
333  GNUNET_free (emsg);
334  }
335  GNUNET_free (fn);
336  return uig;
337 }
338 
339 
344 {
349 
355 
360 
365 
370 
375 
379  void *cont_cls;
380 
385 };
386 
387 
395 static void
396 sks_publish_cont (void *cls, const char *msg)
397 {
398  struct GNUNET_FS_PublishSksContext *psc = cls;
400 
401  psc->uc = NULL;
402  if (NULL != msg)
403  {
404  if (NULL != psc->cont)
405  psc->cont (psc->cont_cls, NULL, msg);
407  return;
408  }
409  if (NULL != psc->nsn)
410  {
411  /* FIXME: this can be done much more
412  * efficiently by simply appending to the
413  * file and overwriting the 4-byte header */
414  uig = read_update_information_graph (psc->h, &psc->ns);
416  psc->nsn = NULL;
419  }
420  if (NULL != psc->cont)
421  psc->cont (psc->cont_cls, psc->uri, NULL);
423 }
424 
425 
443  const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
444  const char *identifier,
445  const char *update,
446  const struct GNUNET_CONTAINER_MetaData *meta,
447  const struct GNUNET_FS_Uri *uri,
448  const struct GNUNET_FS_BlockOptions *bo,
451  void *cont_cls)
452 {
453  struct GNUNET_FS_PublishSksContext *psc;
454  struct GNUNET_FS_Uri *sks_uri;
455 
456  sks_uri = GNUNET_new (struct GNUNET_FS_Uri);
457  sks_uri->type = GNUNET_FS_URI_SKS;
458  sks_uri->data.sks.identifier = GNUNET_strdup (identifier);
459  GNUNET_CRYPTO_ecdsa_key_get_public (ns, &sks_uri->data.sks.ns);
460 
462  psc->h = h;
463  psc->uri = sks_uri;
464  psc->cont = cont;
465  psc->cont_cls = cont_cls;
466  psc->ns = *ns;
467  if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
468  {
469  psc->dsh = GNUNET_DATASTORE_connect (h->cfg);
470  if (NULL == psc->dsh)
471  {
472  sks_publish_cont (psc, _ ("Failed to connect to datastore."));
473  return NULL;
474  }
475  }
476  if (NULL != update)
477  {
478  psc->nsn = GNUNET_new (struct NamespaceUpdateNode);
479  psc->nsn->id = GNUNET_strdup (identifier);
480  psc->nsn->update = GNUNET_strdup (update);
482  psc->nsn->uri = GNUNET_FS_uri_dup (uri);
483  }
484  psc->uc = GNUNET_FS_publish_ublock_ (h,
485  psc->dsh,
486  identifier,
487  update,
488  ns,
489  meta,
490  uri,
491  bo,
492  options,
494  psc);
495  return psc;
496 }
497 
498 
504 void
506 {
507  if (NULL != psc->uc)
508  {
510  psc->uc = NULL;
511  }
512  if (NULL != psc->dsh)
513  {
515  psc->dsh = NULL;
516  }
517  GNUNET_FS_uri_destroy (psc->uri);
518  if (NULL != psc->nsn)
519  {
521  GNUNET_FS_uri_destroy (psc->nsn->uri);
522  GNUNET_free (psc->nsn->id);
523  GNUNET_free (psc->nsn->update);
524  GNUNET_free (psc->nsn);
525  }
526  GNUNET_free (psc);
527 }
528 
529 
534 {
539 
543  void *ip_cls;
544 };
545 
546 
557 static int
558 process_update_node (void *cls, const struct GNUNET_HashCode *key, void *value)
559 {
560  struct ProcessUpdateClosure *pc = cls;
561  struct NamespaceUpdateNode *nsn = value;
562 
563  pc->ip (pc->ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
564  return GNUNET_YES;
565 }
566 
567 
572 {
577 
582 
586  unsigned int tree_array_size;
587 
591  unsigned int nug;
592 
596  unsigned int id;
597 };
598 
599 
620 static int
621 find_trees (void *cls, const struct GNUNET_HashCode *key, void *value)
622 {
623  struct FindTreeClosure *fc = cls;
624  struct NamespaceUpdateNode *nsn = value;
625  struct GNUNET_HashCode hc;
626 
627  if (nsn->nug == fc->nug)
628  {
629  if (UINT_MAX == nsn->tree_id)
630  return GNUNET_YES; /* circular */
632  if (fc->tree_array[nsn->tree_id] != nsn)
633  return GNUNET_YES; /* part of "another" (directed) TREE,
634  * and not root of it, end trace */
635  if (nsn->tree_id == fc->id)
636  return GNUNET_YES; /* that's our own root (can this be?) */
637  /* merge existing TREE, we have a root for both */
638  fc->tree_array[nsn->tree_id] = NULL;
639  if (UINT_MAX == fc->id)
640  fc->id = nsn->tree_id; /* take over ID */
641  }
642  else
643  {
644  nsn->nug = fc->nug;
645  nsn->tree_id = UINT_MAX; /* mark as undef */
646  /* trace */
647  GNUNET_CRYPTO_hash (nsn->update, strlen (nsn->update), &hc);
649  &hc,
650  &find_trees,
651  fc);
652  }
653  return GNUNET_YES;
654 }
655 
656 
680 void
682  struct GNUNET_FS_Handle *h,
683  const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
684  const char *next_id,
686  void *ip_cls)
687 {
688  unsigned int i;
689  unsigned int nug;
690  struct GNUNET_HashCode hc;
691  struct NamespaceUpdateNode *nsn;
692  struct ProcessUpdateClosure pc;
693  struct FindTreeClosure fc;
695 
696  uig = read_update_information_graph (h, ns);
697  if (NULL == uig->update_nodes)
698  {
700  "No updateable nodes found for ID `%s'\n",
701  next_id);
703  return; /* no nodes */
704  }
705  uig->update_map =
707  GNUNET_NO);
708  for (i = 0; i < uig->update_node_count; i++)
709  {
710  nsn = uig->update_nodes[i];
711  GNUNET_CRYPTO_hash (nsn->id, strlen (nsn->id), &hc);
713  uig->update_map,
714  &hc,
715  nsn,
717  }
718  if (NULL != next_id)
719  {
720  GNUNET_CRYPTO_hash (next_id, strlen (next_id), &hc);
721  pc.ip = ip;
722  pc.ip_cls = ip_cls;
724  &hc,
726  &pc);
728  return;
729  }
731  "Calculating TREEs to find roots of update trees\n");
732  /* Find heads of TREEs in update graph */
733  nug = ++uig->nug_gen;
734  fc.tree_array = NULL;
735  fc.tree_array_size = 0;
736 
737  for (i = 0; i < uig->update_node_count; i++)
738  {
739  nsn = uig->update_nodes[i];
740  if (nsn->nug == nug)
741  {
743  "TREE of node `%s' is %u\n",
744  nsn->id,
745  nsn->nug);
746  continue; /* already placed in TREE */
747  }
748  GNUNET_CRYPTO_hash (nsn->update, strlen (nsn->update), &hc);
749  nsn->nug = nug;
750  nsn->tree_id = UINT_MAX;
751  fc.id = UINT_MAX;
752  fc.nug = nug;
753  fc.uig = uig;
755  &hc,
756  &find_trees,
757  &fc);
758  if (UINT_MAX == fc.id)
759  {
760  /* start new TREE */
761  for (fc.id = 0; fc.id < fc.tree_array_size; fc.id++)
762  {
763  if (NULL == fc.tree_array[fc.id])
764  {
765  fc.tree_array[fc.id] = nsn;
766  nsn->tree_id = fc.id;
767  break;
768  }
769  }
770  if (fc.id == fc.tree_array_size)
771  {
773  nsn->tree_id = fc.id;
774  }
776  "Starting new TREE %u with node `%s'\n",
777  nsn->tree_id,
778  nsn->id);
779  /* put all nodes with same identifier into this TREE */
780  GNUNET_CRYPTO_hash (nsn->id, strlen (nsn->id), &hc);
781  fc.id = nsn->tree_id;
782  fc.nug = nug;
783  fc.uig = uig;
785  &hc,
786  &find_trees,
787  &fc);
788  }
789  else
790  {
791  /* make head of TREE "id" */
792  fc.tree_array[fc.id] = nsn;
793  nsn->tree_id = fc.id;
794  }
796  "TREE of node `%s' is %u\n",
797  nsn->id,
798  fc.id);
799  }
800  for (i = 0; i < fc.tree_array_size; i++)
801  {
802  nsn = fc.tree_array[i];
803  if (NULL != nsn)
804  {
806  "Root of TREE %u is node `%s'\n",
807  i,
808  nsn->id);
809  ip (ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
810  }
811  }
813  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Done processing TREEs\n");
815 }
816 
817 
818 /* end of fs_namespace.c */
int GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory)...
Definition: disk.c:544
Structure specifying a writing operation on an IO handle.
#define GNUNET_BIO_read_spec_end()
End of specifications marker.
GNUNET_FS_PublishContinuation cont
Function to call once we&#39;re done.
Definition: fs_namespace.c:374
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
int GNUNET_BIO_read_int32(struct GNUNET_BIO_ReadHandle *h, const char *what, int32_t *i)
Read an (u)int32_t.
Definition: bio.c:478
#define GNUNET_array_append(arr, len, element)
Append an element to an array (growing the array by one).
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_FS_Uri * uri
URI of the new entry in the namespace.
Definition: fs_namespace.c:348
struct GNUNET_FS_Uri::@13::@15 sks
Context for the SKS publication.
Definition: fs_namespace.c:343
struct GNUNET_FS_Uri * uri
URI of this entry in the namespace.
Definition: fs_namespace.c:60
static void write_update_information_graph(struct GNUNET_FS_UpdateInformationGraph *uig)
Write a namespace&#39;s update node graph to a file.
Definition: fs_namespace.c:189
struct GNUNET_BIO_ReadHandle * GNUNET_BIO_read_open_file(const char *fn)
Open a file for reading.
Definition: bio.c:119
struct GNUNET_FS_Uri * GNUNET_FS_uri_parse(const char *uri, char **emsg)
Convert a UTF-8 String to a URI.
Definition: fs_uri.c:644
Master context for most FS operations.
Definition: fs_api.h:1068
struct GNUNET_FS_Handle * h
Handle to the FS service context.
Definition: fs_namespace.c:83
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
unsigned int nug
Namespace update generation ID.
Definition: fs_namespace.c:66
struct GNUNET_FS_Handle * h
Handle to FS.
Definition: fs_namespace.c:369
struct GNUNET_FS_PublishSksContext * GNUNET_FS_publish_sks(struct GNUNET_FS_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const char *identifier, const char *update, const struct GNUNET_CONTAINER_MetaData *meta, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_BlockOptions *bo, enum GNUNET_FS_PublishOptions options, GNUNET_FS_PublishContinuation cont, void *cont_cls)
Publish an SBlock on GNUnet.
Definition: fs_namespace.c:442
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
We&#39;re done processing.
int GNUNET_BIO_read_spec_commit(struct GNUNET_BIO_ReadHandle *h, struct GNUNET_BIO_ReadSpec *rs)
Execute the read specifications in order.
Definition: bio.c:1242
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Private ECC key encoded for transmission.
void GNUNET_FS_namespace_list_updateable(struct GNUNET_FS_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const char *next_id, GNUNET_FS_IdentifierProcessor ip, void *ip_cls)
List all of the identifiers in the namespace for which we could produce an update.
Definition: fs_namespace.c:681
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
static void sks_publish_cont(void *cls, const char *msg)
Function called by the UBlock construction with the result from the PUT (UBlock) request.
Definition: fs_namespace.c:396
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:997
Internal representation of the hash map.
int GNUNET_BIO_read_close(struct GNUNET_BIO_ReadHandle *h, char **emsg)
Close an open handle.
Definition: bio.c:166
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static int find_trees(void *cls, const struct GNUNET_HashCode *key, void *value)
Find all nodes reachable from the current node (including the current node itself).
Definition: fs_namespace.c:621
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
GNUNET_FS_IdentifierProcessor ip
Function to call for each node.
Definition: fs_namespace.c:538
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:2027
#define GNUNET_BIO_write_spec_end()
End of specifications marker.
unsigned int rc
Reference counter.
Definition: fs_namespace.c:109
static void free_update_information_graph(struct GNUNET_FS_UpdateInformationGraph *uig)
Release memory occupied by UIG datastructure.
Definition: fs_namespace.c:162
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_string(const char *what, const char *s)
Create the specification to write a 0-terminated string.
Definition: bio.c:1335
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
Meta data to associate with a file, directory or namespace.
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_meta_data(const char *what, struct GNUNET_CONTAINER_MetaData **result)
Create the specification to read a metadata container.
Definition: bio.c:1091
char * id
Identifier for this node.
Definition: fs_namespace.c:45
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
Closure for &#39;find_trees&#39;.
Definition: fs_namespace.c:571
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
static char * value
Value of the record to add/remove.
unsigned int update_node_count
Size of the update nodes array.
Definition: fs_namespace.c:104
unsigned int tree_array_size
Size of &#39;tree_array&#39;.
Definition: fs_namespace.c:586
struct GNUNET_CRYPTO_EcdsaPrivateKey ns
Private key for the namespace.
Definition: fs_namespace.c:93
static char * fn
Filename of the unique file.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_CRYPTO_EcdsaPrivateKey ns
Namespace we&#39;re publishing to.
Definition: fs_namespace.c:359
#define DIR_SEPARATOR_STR
Definition: platform.h:171
static int process_update_node(void *cls, const struct GNUNET_HashCode *key, void *value)
Call the iterator in the closure for each node.
Definition: fs_namespace.c:558
void(* GNUNET_FS_IdentifierProcessor)(void *cls, const char *last_id, const struct GNUNET_FS_Uri *last_uri, const struct GNUNET_CONTAINER_MetaData *last_meta, const char *next_id)
Function called on updateable identifiers.
void GNUNET_FS_publish_sks_cancel(struct GNUNET_FS_PublishSksContext *psc)
Abort the SKS publishing operation.
Definition: fs_namespace.c:505
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
Definition: gnunet-abd.c:41
void(* GNUNET_FS_PublishContinuation)(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
Signature of a function called as the continuation of a KBlock or SBlock publication.
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
GNUNET_FS_PublishOptions
Options for publishing.
Structure specifying a reading operation on an IO handle.
char * update
Identifier of children of this node.
Definition: fs_namespace.c:50
Handle for buffered writing.
Definition: bio.c:516
unsigned int tree_id
TREE this entry belongs to (if nug is current).
Definition: fs_namespace.c:71
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:678
A 512-bit hashcode.
void GNUNET_FS_publish_ublock_cancel_(struct GNUNET_FS_PublishUblockContext *uc)
Abort UBlock publishing operation.
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_string(const char *what, char **result, size_t max_length)
Create the specification to read a 0-terminated string.
Definition: bio.c:1045
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_meta_data(const char *what, const struct GNUNET_CONTAINER_MetaData *m)
Create the specification to write a metadata container.
Definition: bio.c:1381
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open_file(const char *fn)
Open a file for writing.
Definition: bio.c:559
struct GNUNET_CONTAINER_MultiHashMap * update_map
Hash map mapping identifiers of update nodes to the update nodes (initialized on-demand).
Definition: fs_namespace.c:99
struct GNUNET_HashCode key
The key used in the DHT.
void GNUNET_CRYPTO_hash_to_enc(const struct GNUNET_HashCode *block, struct GNUNET_CRYPTO_HashAsciiEncoded *result)
Convert hash to ASCII encoding.
Definition: crypto_hash.c:73
void GNUNET_CRYPTO_ecdsa_key_get_public(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:176
Closure for &#39;process_update_node&#39;.
Definition: fs_namespace.c:533
struct GNUNET_FS_PublishUblockContext * GNUNET_FS_publish_ublock_(struct GNUNET_FS_Handle *h, struct GNUNET_DATASTORE_Handle *dsh, const char *label, const char *ulabel, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const struct GNUNET_CONTAINER_MetaData *meta, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_BlockOptions *bo, enum GNUNET_FS_PublishOptions options, GNUNET_FS_UBlockContinuation cont, void *cont_cls)
Publish a UBlock.
Settings for publishing a block (which may of course also apply to an entire directory or file)...
int GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h, char **emsg)
Close an IO handle.
Definition: bio.c:608
Information about an (updateable) node in the namespace.
Definition: fs_namespace.c:40
static struct GNUNET_TESTBED_BarrierWaitHandle * wh
Our barrier wait handle.
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:170
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct NamespaceUpdateNode ** update_nodes
Array with information about nodes in the namespace.
Definition: fs_namespace.c:88
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, const char *what, int32_t i)
Write an (u)int32_t.
Definition: bio.c:936
unsigned int nug
Current generational ID used.
Definition: fs_namespace.c:591
union GNUNET_FS_Uri::@13 data
0-terminated ASCII encoding of a struct GNUNET_HashCode.
Allow multiple values with the same key.
unsigned int id
Identifier for the current TREE, or UINT_MAX for none yet.
Definition: fs_namespace.c:596
Signed key space (file in namespace).
Definition: fs_api.h:148
void * ip_cls
Closure for &#39;ip&#39;.
Definition: fs_namespace.c:543
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
int GNUNET_BIO_write_spec_commit(struct GNUNET_BIO_WriteHandle *h, struct GNUNET_BIO_WriteSpec *ws)
Execute the write specifications in order.
Definition: bio.c:1539
int GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
static char * next_id
Command-line option for namespace publishing: identifier for updates to this publication.
static char * get_update_information_directory(struct GNUNET_FS_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns)
Return the name of the directory in which we store the update information graph for the given local n...
Definition: fs_namespace.c:127
struct GNUNET_FS_UpdateInformationGraph * uig
UIG we are operating on.
Definition: fs_namespace.c:576
struct GNUNET_CONTAINER_MetaData * md
Metadata for this entry.
Definition: fs_namespace.c:55
shared definitions for the FS library
void GNUNET_DATASTORE_disconnect(struct GNUNET_DATASTORE_Handle *h, int drop)
Disconnect from the datastore service (and free associated resources).
Context for &#39;ublock_put_cont&#39;.
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:165
Handle to the datastore service.
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
#define GNUNET_log(kind,...)
unsigned int nug_gen
Generator for unique nug numbers.
Definition: fs_namespace.c:114
struct NamespaceUpdateNode * nsn
Namespace update node to add to namespace on success (or to be deleted if publishing failed)...
Definition: fs_namespace.c:354
struct GNUNET_DATASTORE_Handle * dsh
Handle to the datastore.
Definition: fs_namespace.c:364
int GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
struct NamespaceUpdateNode ** tree_array
Array with &#39;head&#39;s of TREEs.
Definition: fs_namespace.c:581
void * cont_cls
Closure for cont.
Definition: fs_namespace.c:379
static struct GNUNET_FS_UpdateInformationGraph * read_update_information_graph(struct GNUNET_FS_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns)
Read the namespace update node graph from a file.
Definition: fs_namespace.c:248
struct GNUNET_FS_PublishUblockContext * uc
Handle for our UBlock operation request.
Definition: fs_namespace.c:384
struct GNUNET_DATASTORE_Handle * GNUNET_DATASTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the datastore service.
Handle to update information for a namespace.
Definition: fs_namespace.c:78
#define GNUNET_malloc(size)
Wrapper around malloc.
Handle for buffered reading.
Definition: bio.c:73
static struct GNUNET_FS_BlockOptions bo
Options we set for published blocks.
#define GNUNET_free(ptr)
Wrapper around free.
publish a UBLOCK in GNUnet
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_duplicate(const struct GNUNET_CONTAINER_MetaData *md)
Duplicate a MetaData token.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: fs_api.h:1073