GNUnet  0.11.x
Data Structures | Functions
fs_namespace.c File Reference

publishing to namespaces, and tracking updateable entries for our namespaces More...

#include "platform.h"
#include "gnunet_constants.h"
#include "gnunet_signatures.h"
#include "gnunet_util_lib.h"
#include "gnunet_fs_service.h"
#include "fs_api.h"
#include "fs_publish_ublock.h"
Include dependency graph for fs_namespace.c:

Go to the source code of this file.

Data Structures

struct  NamespaceUpdateNode
 Information about an (updateable) node in the namespace. More...
 
struct  GNUNET_FS_UpdateInformationGraph
 Handle to update information for a namespace. More...
 
struct  GNUNET_FS_PublishSksContext
 Context for the SKS publication. More...
 
struct  ProcessUpdateClosure
 Closure for 'process_update_node'. More...
 
struct  FindTreeClosure
 Closure for 'find_trees'. More...
 

Functions

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 namespace. More...
 
static void free_update_information_graph (struct GNUNET_FS_UpdateInformationGraph *uig)
 Release memory occupied by UIG datastructure. More...
 
static void write_update_information_graph (struct GNUNET_FS_UpdateInformationGraph *uig)
 Write a namespace's update node graph to a file. More...
 
static struct GNUNET_FS_UpdateInformationGraphread_update_information_graph (struct GNUNET_FS_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns)
 Read the namespace update node graph from a file. More...
 
static void sks_publish_cont (void *cls, const char *msg)
 Function called by the UBlock construction with the result from the PUT (UBlock) request. More...
 
struct GNUNET_FS_PublishSksContextGNUNET_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. More...
 
void GNUNET_FS_publish_sks_cancel (struct GNUNET_FS_PublishSksContext *psc)
 Abort the SKS publishing operation. More...
 
static int process_update_node (void *cls, const struct GNUNET_HashCode *key, void *value)
 Call the iterator in the closure for each node. More...
 
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). More...
 
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. More...
 

Detailed Description

publishing to namespaces, and tracking updateable entries for our namespaces

Author
Christian Grothoff

Definition in file fs_namespace.c.

Function Documentation

◆ get_update_information_directory()

static char* get_update_information_directory ( struct GNUNET_FS_Handle h,
const struct GNUNET_CRYPTO_EcdsaPrivateKey ns 
)
static

Return the name of the directory in which we store the update information graph for the given local namespace.

Parameters
hfile-sharing handle
nsnamespace handle
Returns
NULL on error, otherwise the name of the directory

Definition at line 127 of file fs_namespace.c.

References GNUNET_FS_Handle::cfg, DIR_SEPARATOR_STR, GNUNET_CRYPTO_HashAsciiEncoded::encoding, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hash_to_enc(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_config_missing(), GNUNET_OK, and ret.

Referenced by read_update_information_graph(), and write_update_information_graph().

130 {
131  char *dn;
132  char *ret;
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);
146  GNUNET_asprintf (&ret,
147  "%s%s%s",
148  dn,
150  (const char *) enc.encoding);
151  GNUNET_free (dn);
152  return ret;
153 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
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
#define DIR_SEPARATOR_STR
Definition: platform.h:171
A 512-bit hashcode.
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
0-terminated ASCII encoding of a struct GNUNET_HashCode.
static struct GNUNET_CRYPTO_EddsaPublicKey pub
Definition: gnunet-scrypt.c:39
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
static OpusEncoder * enc
OPUS encoder.
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.
#define GNUNET_free(ptr)
Wrapper around free.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: fs_api.h:1073
Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_update_information_graph()

static void free_update_information_graph ( struct GNUNET_FS_UpdateInformationGraph uig)
static

Release memory occupied by UIG datastructure.

Parameters
uigdata structure to free

Definition at line 162 of file fs_namespace.c.

References GNUNET_array_grow, GNUNET_CONTAINER_meta_data_destroy(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_free, GNUNET_FS_uri_destroy(), NamespaceUpdateNode::id, NamespaceUpdateNode::md, NamespaceUpdateNode::update, GNUNET_FS_UpdateInformationGraph::update_map, GNUNET_FS_UpdateInformationGraph::update_node_count, GNUNET_FS_UpdateInformationGraph::update_nodes, and NamespaceUpdateNode::uri.

Referenced by GNUNET_FS_namespace_list_updateable(), and sks_publish_cont().

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 }
struct GNUNET_FS_Uri * uri
URI of this entry in the namespace.
Definition: fs_namespace.c:60
char * id
Identifier for this node.
Definition: fs_namespace.c:45
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
unsigned int update_node_count
Size of the update nodes array.
Definition: fs_namespace.c:104
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
char * update
Identifier of children of this node.
Definition: fs_namespace.c:50
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:678
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
Information about an (updateable) node in the namespace.
Definition: fs_namespace.c:40
struct NamespaceUpdateNode ** update_nodes
Array with information about nodes in the namespace.
Definition: fs_namespace.c:88
struct GNUNET_CONTAINER_MetaData * md
Metadata for this entry.
Definition: fs_namespace.c:55
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ write_update_information_graph()

static void write_update_information_graph ( struct GNUNET_FS_UpdateInformationGraph uig)
static

Write a namespace's update node graph to a file.

Parameters
uigupdate information graph to dump

Definition at line 189 of file fs_namespace.c.

References _, END, fn, get_update_information_directory(), GNUNET_BIO_write_close(), GNUNET_BIO_write_int32(), GNUNET_BIO_write_open_file(), GNUNET_BIO_write_spec_commit(), GNUNET_BIO_write_spec_end, GNUNET_BIO_write_spec_meta_data(), GNUNET_BIO_write_spec_string(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_FS_uri_to_string(), GNUNET_log, GNUNET_OK, GNUNET_FS_UpdateInformationGraph::h, NamespaceUpdateNode::id, NamespaceUpdateNode::md, GNUNET_FS_UpdateInformationGraph::ns, NamespaceUpdateNode::update, GNUNET_FS_UpdateInformationGraph::update_node_count, GNUNET_FS_UpdateInformationGraph::update_nodes, NamespaceUpdateNode::uri, and wh.

Referenced by sks_publish_cont().

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  };
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 }
Structure specifying a writing operation on an IO handle.
struct GNUNET_FS_Uri * uri
URI of this entry in the namespace.
Definition: fs_namespace.c:60
struct GNUNET_FS_Handle * h
Handle to the FS service context.
Definition: fs_namespace.c:83
We&#39;re done processing.
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
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.
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:1334
char * id
Identifier for this node.
Definition: fs_namespace.c:45
unsigned int update_node_count
Size of the update nodes array.
Definition: fs_namespace.c:104
struct GNUNET_CRYPTO_EcdsaPrivateKey ns
Private key for the namespace.
Definition: fs_namespace.c:93
static char * fn
Filename of the unique file.
char * update
Identifier of children of this node.
Definition: fs_namespace.c:50
Handle for buffered writing.
Definition: bio.c:515
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:1380
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open_file(const char *fn)
Open a file for writing.
Definition: bio.c:558
int GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h, char **emsg)
Close an IO handle.
Definition: bio.c:607
Information about an (updateable) node in the namespace.
Definition: fs_namespace.c:40
static struct GNUNET_TESTBED_BarrierWaitHandle * wh
Our barrier wait handle.
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:935
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:1538
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_CONTAINER_MetaData * md
Metadata for this entry.
Definition: fs_namespace.c:55
#define GNUNET_log(kind,...)
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ read_update_information_graph()

static struct GNUNET_FS_UpdateInformationGraph* read_update_information_graph ( struct GNUNET_FS_Handle h,
const struct GNUNET_CRYPTO_EcdsaPrivateKey ns 
)
static

Read the namespace update node graph from a file.

Parameters
hFS handle to use
nsnamespace to read
Returns
update graph, never NULL

Definition at line 248 of file fs_namespace.c.

References _, END, fn, get_update_information_directory(), GNUNET_BIO_read_close(), GNUNET_BIO_read_int32(), GNUNET_BIO_read_open_file(), GNUNET_BIO_read_spec_commit(), GNUNET_BIO_read_spec_end, GNUNET_BIO_read_spec_meta_data(), GNUNET_BIO_read_spec_string(), GNUNET_break, GNUNET_CONTAINER_meta_data_destroy(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_free_non_null, GNUNET_FS_uri_parse(), GNUNET_log, GNUNET_malloc, GNUNET_new, GNUNET_OK, GNUNET_YES, GNUNET_FS_UpdateInformationGraph::h, h, NamespaceUpdateNode::id, NamespaceUpdateNode::md, ns, GNUNET_FS_UpdateInformationGraph::ns, NamespaceUpdateNode::update, GNUNET_FS_UpdateInformationGraph::update_node_count, GNUNET_FS_UpdateInformationGraph::update_nodes, and NamespaceUpdateNode::uri.

Referenced by GNUNET_FS_namespace_list_updateable(), and sks_publish_cont().

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);
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);
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 }
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
#define GNUNET_BIO_read_spec_end()
End of specifications marker.
int GNUNET_BIO_read_int32(struct GNUNET_BIO_ReadHandle *h, const char *what, int32_t *i)
Read an (u)int32_t.
Definition: bio.c:477
struct GNUNET_FS_Uri * uri
URI of this entry in the namespace.
Definition: fs_namespace.c:60
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
struct GNUNET_FS_Handle * h
Handle to the FS service context.
Definition: fs_namespace.c:83
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:1241
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
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
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
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:1090
char * id
Identifier for this node.
Definition: fs_namespace.c:45
unsigned int update_node_count
Size of the update nodes array.
Definition: fs_namespace.c:104
struct GNUNET_CRYPTO_EcdsaPrivateKey ns
Private key for the namespace.
Definition: fs_namespace.c:93
static char * fn
Filename of the unique file.
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
Definition: gnunet-abd.c:41
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
Structure specifying a reading operation on an IO handle.
char * update
Identifier of children of this node.
Definition: fs_namespace.c:50
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:1044
Information about an (updateable) node in the namespace.
Definition: fs_namespace.c:40
struct NamespaceUpdateNode ** update_nodes
Array with information about nodes in the namespace.
Definition: fs_namespace.c:88
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_CONTAINER_MetaData * md
Metadata for this entry.
Definition: fs_namespace.c:55
#define GNUNET_log(kind,...)
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
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ sks_publish_cont()

static void sks_publish_cont ( void *  cls,
const char *  msg 
)
static

Function called by the UBlock construction with the result from the PUT (UBlock) request.

Parameters
clsclosure of type "struct GNUNET_FS_PublishSksContext*"
msgerror message (or NULL)

Definition at line 396 of file fs_namespace.c.

References GNUNET_FS_PublishSksContext::cont, GNUNET_FS_PublishSksContext::cont_cls, free_update_information_graph(), GNUNET_array_append, GNUNET_FS_publish_sks_cancel(), GNUNET_FS_PublishSksContext::h, GNUNET_FS_PublishSksContext::ns, GNUNET_FS_PublishSksContext::nsn, read_update_information_graph(), GNUNET_FS_PublishSksContext::uc, GNUNET_FS_UpdateInformationGraph::update_node_count, GNUNET_FS_UpdateInformationGraph::update_nodes, GNUNET_FS_PublishSksContext::uri, and write_update_information_graph().

Referenced by GNUNET_FS_publish_sks().

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 }
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
#define GNUNET_array_append(arr, len, element)
Append an element to an array (growing the array by one).
struct GNUNET_FS_Uri * uri
URI of the new entry in the namespace.
Definition: fs_namespace.c:348
Context for the SKS publication.
Definition: fs_namespace.c:343
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_FS_Handle * h
Handle to FS.
Definition: fs_namespace.c:369
static void free_update_information_graph(struct GNUNET_FS_UpdateInformationGraph *uig)
Release memory occupied by UIG datastructure.
Definition: fs_namespace.c:162
unsigned int update_node_count
Size of the update nodes array.
Definition: fs_namespace.c:104
struct GNUNET_CRYPTO_EcdsaPrivateKey ns
Namespace we&#39;re publishing to.
Definition: fs_namespace.c:359
void GNUNET_FS_publish_sks_cancel(struct GNUNET_FS_PublishSksContext *psc)
Abort the SKS publishing operation.
Definition: fs_namespace.c:505
struct NamespaceUpdateNode ** update_nodes
Array with information about nodes in the namespace.
Definition: fs_namespace.c:88
struct NamespaceUpdateNode * nsn
Namespace update node to add to namespace on success (or to be deleted if publishing failed)...
Definition: fs_namespace.c:354
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
Handle to update information for a namespace.
Definition: fs_namespace.c:78
Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_update_node()

static int process_update_node ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Call the iterator in the closure for each node.

Parameters
clsclosure (of type 'struct ProcessUpdateClosure *')
keycurrent key code
valuevalue in the hash map (of type 'struct NamespaceUpdateNode *')
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 558 of file fs_namespace.c.

References GNUNET_YES, NamespaceUpdateNode::id, ProcessUpdateClosure::ip, ProcessUpdateClosure::ip_cls, NamespaceUpdateNode::md, pc, NamespaceUpdateNode::update, NamespaceUpdateNode::uri, and value.

Referenced by GNUNET_FS_namespace_list_updateable().

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 }
struct GNUNET_FS_Uri * uri
URI of this entry in the namespace.
Definition: fs_namespace.c:60
GNUNET_FS_IdentifierProcessor ip
Function to call for each node.
Definition: fs_namespace.c:538
char * id
Identifier for this node.
Definition: fs_namespace.c:45
static char * value
Value of the record to add/remove.
char * update
Identifier of children of this node.
Definition: fs_namespace.c:50
Closure for &#39;process_update_node&#39;.
Definition: fs_namespace.c:533
Information about an (updateable) node in the namespace.
Definition: fs_namespace.c:40
void * ip_cls
Closure for &#39;ip&#39;.
Definition: fs_namespace.c:543
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
struct GNUNET_CONTAINER_MetaData * md
Metadata for this entry.
Definition: fs_namespace.c:55
Here is the caller graph for this function:

◆ find_trees()

static int find_trees ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Find all nodes reachable from the current node (including the current node itself).

If they are in no tree, add them to the current one. If they are the head of another tree, merge the trees. If they are in the middle of another tree, let them be. We can tell that a node is already in an tree by checking if its 'nug' field is set to the current 'nug' value. It is the head of an tree if it is in the 'tree_array' under its respective 'tree_id'.

In short, we're trying to find the smallest number of tree to cover a directed graph.

Parameters
clsclosure (of type 'struct FindTreeClosure')
keycurrent key code
valuevalue in the hash map
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 621 of file fs_namespace.c.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CRYPTO_hash(), GNUNET_YES, FindTreeClosure::id, NamespaceUpdateNode::nug, FindTreeClosure::nug, FindTreeClosure::tree_array, FindTreeClosure::tree_array_size, NamespaceUpdateNode::tree_id, FindTreeClosure::uig, NamespaceUpdateNode::update, GNUNET_FS_UpdateInformationGraph::update_map, and value.

Referenced by GNUNET_FS_namespace_list_updateable().

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 }
#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
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
Closure for &#39;find_trees&#39;.
Definition: fs_namespace.c:571
static char * value
Value of the record to add/remove.
unsigned int tree_array_size
Size of &#39;tree_array&#39;.
Definition: fs_namespace.c:586
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
char * update
Identifier of children of this node.
Definition: fs_namespace.c:50
unsigned int tree_id
TREE this entry belongs to (if nug is current).
Definition: fs_namespace.c:71
A 512-bit hashcode.
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
Information about an (updateable) node in the namespace.
Definition: fs_namespace.c:40
unsigned int nug
Current generational ID used.
Definition: fs_namespace.c:591
unsigned int id
Identifier for the current TREE, or UINT_MAX for none yet.
Definition: fs_namespace.c:596
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.
struct GNUNET_FS_UpdateInformationGraph * uig
UIG we are operating on.
Definition: fs_namespace.c:576
struct NamespaceUpdateNode ** tree_array
Array with &#39;head&#39;s of TREEs.
Definition: fs_namespace.c:581
Here is the call graph for this function:
Here is the caller graph for this function: