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
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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:168
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:239
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_meta_data(), GNUNET_BIO_write_open(), GNUNET_BIO_write_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 (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  goto END;
210  for (i = 0; i < uig->update_node_count; i++)
211  {
212  n = uig->update_nodes[i];
213  uris = GNUNET_FS_uri_to_string (n->uri);
214  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, n->id)) ||
215  (GNUNET_OK != GNUNET_BIO_write_meta_data (wh, n->md)) ||
216  (GNUNET_OK != GNUNET_BIO_write_string (wh, n->update)) ||
217  (GNUNET_OK != GNUNET_BIO_write_string (wh, uris)))
218  {
219  GNUNET_free (uris);
220  break;
221  }
222  GNUNET_free (uris);
223  }
224 END:
225  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
227  _ ("Failed to write `%s': %s\n"),
228  fn,
229  strerror (errno));
230  GNUNET_free (fn);
231 }
int GNUNET_BIO_write_meta_data(struct GNUNET_BIO_WriteHandle *h, const struct GNUNET_CONTAINER_MetaData *m)
Write metadata container to a file.
Definition: bio.c:544
struct GNUNET_FS_Uri * uri
URI of this entry in the namespace.
Definition: fs_namespace.c:60
int GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *s)
Write a string to a file.
Definition: bio.c:523
struct GNUNET_FS_Handle * h
Handle to the FS service context.
Definition: fs_namespace.c:83
We&#39;re done processing.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:2028
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:379
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_close(struct GNUNET_BIO_WriteHandle *h)
Close an open file for writing.
Definition: bio.c:438
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
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open(const char *fn)
Open a file for writing.
Definition: bio.c:410
#define GNUNET_log(kind,...)
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, int32_t i)
Write an (u)int32_t.
Definition: bio.c:582
#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 242 of file fs_namespace.c.

References _, END, fn, get_update_information_directory(), GNUNET_BIO_read_close(), GNUNET_BIO_read_int32, GNUNET_BIO_read_meta_data(), GNUNET_BIO_read_open(), GNUNET_BIO_read_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().

244 {
246  char *fn;
247  struct GNUNET_BIO_ReadHandle *rh;
248  unsigned int i;
249  struct NamespaceUpdateNode *n;
250  char *uris;
251  uint32_t count;
252  char *emsg;
253 
255  uig->h = h;
256  uig->ns = *ns;
258  if (GNUNET_YES != GNUNET_DISK_file_test (fn))
259  {
260  GNUNET_free (fn);
261  return uig;
262  }
263  rh = GNUNET_BIO_read_open (fn);
264  if (NULL == rh)
265  {
266  GNUNET_free (fn);
267  return uig;
268  }
269  if (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &count))
270  {
271  GNUNET_break (0);
272  goto END;
273  }
274  if (count > 1024 * 1024)
275  {
276  GNUNET_break (0);
277  goto END;
278  }
279  if (0 == count)
280  goto END;
281  uig->update_nodes =
282  GNUNET_malloc (count * sizeof(struct NamespaceUpdateNode *));
283 
284  for (i = 0; i < count; i++)
285  {
286  n = GNUNET_new (struct NamespaceUpdateNode);
287  if ((GNUNET_OK !=
288  GNUNET_BIO_read_string (rh, "identifier", &n->id, 1024)) ||
289  (GNUNET_OK != GNUNET_BIO_read_meta_data (rh, "meta", &n->md)) ||
290  (GNUNET_OK !=
291  GNUNET_BIO_read_string (rh, "update-id", &n->update, 1024)) ||
292  (GNUNET_OK != GNUNET_BIO_read_string (rh, "uri", &uris, 1024 * 2)))
293  {
294  GNUNET_break (0);
297  if (n->md != NULL)
299  GNUNET_free (n);
300  break;
301  }
302  n->uri = GNUNET_FS_uri_parse (uris, &emsg);
303  GNUNET_free (uris);
304  if (n->uri == NULL)
305  {
306  GNUNET_break (0);
307  GNUNET_free (emsg);
308  GNUNET_free (n->id);
311  GNUNET_free (n);
312  break;
313  }
314  uig->update_nodes[i] = n;
315  }
316  uig->update_node_count = i;
317 END:
318  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
319  {
321  _ ("Failed to read `%s': %s\n"),
322  fn,
323  emsg);
324  GNUNET_free (emsg);
325  }
326  GNUNET_free (fn);
327  return uig;
328 }
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
struct GNUNET_FS_Uri * uri
URI of this entry in the namespace.
Definition: fs_namespace.c:60
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.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#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 file.
Definition: bio.c:119
#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:181
struct GNUNET_BIO_ReadHandle * GNUNET_BIO_read_open(const char *fn)
Open a file for reading.
Definition: bio.c:94
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.
char * update
Identifier of children of this node.
Definition: fs_namespace.c:50
int GNUNET_BIO_read_string(struct GNUNET_BIO_ReadHandle *h, const char *what, char **result, size_t max_length)
Read 0-terminated string from a file.
Definition: bio.c:233
#define GNUNET_BIO_read_int32(h, i)
Read an (u)int32_t.
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,...)
int GNUNET_BIO_read_meta_data(struct GNUNET_BIO_ReadHandle *h, const char *what, struct GNUNET_CONTAINER_MetaData **result)
Read metadata container from a file.
Definition: bio.c:285
#define GNUNET_YES
Definition: gnunet_common.h:77
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:53
#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 387 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().

388 {
389  struct GNUNET_FS_PublishSksContext *psc = cls;
391 
392  psc->uc = NULL;
393  if (NULL != msg)
394  {
395  if (NULL != psc->cont)
396  psc->cont (psc->cont_cls, NULL, msg);
398  return;
399  }
400  if (NULL != psc->nsn)
401  {
402  /* FIXME: this can be done much more
403  * efficiently by simply appending to the
404  * file and overwriting the 4-byte header */
405  uig = read_update_information_graph (psc->h, &psc->ns);
407  psc->nsn = NULL;
410  }
411  if (NULL != psc->cont)
412  psc->cont (psc->cont_cls, psc->uri, NULL);
414 }
GNUNET_FS_PublishContinuation cont
Function to call once we&#39;re done.
Definition: fs_namespace.c:365
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_FS_Uri * uri
URI of the new entry in the namespace.
Definition: fs_namespace.c:339
Context for the SKS publication.
Definition: fs_namespace.c:334
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:360
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:350
void GNUNET_FS_publish_sks_cancel(struct GNUNET_FS_PublishSksContext *psc)
Abort the SKS publishing operation.
Definition: fs_namespace.c:496
struct NamespaceUpdateNode ** update_nodes
Array with information about nodes in the namespace.
Definition: fs_namespace.c:88
#define GNUNET_array_append(arr, size, element)
Append an element to a list (growing the list by one).
struct NamespaceUpdateNode * nsn
Namespace update node to add to namespace on success (or to be deleted if publishing failed)...
Definition: fs_namespace.c:345
void * cont_cls
Closure for cont.
Definition: fs_namespace.c:370
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:242
struct GNUNET_FS_PublishUblockContext * uc
Handle for our UBlock operation request.
Definition: fs_namespace.c:375
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 549 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().

550 {
551  struct ProcessUpdateClosure *pc = cls;
552  struct NamespaceUpdateNode *nsn = value;
553 
554  pc->ip (pc->ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
555  return GNUNET_YES;
556 }
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:529
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:524
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:534
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
#define GNUNET_YES
Definition: gnunet_common.h:77
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 612 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().

613 {
614  struct FindTreeClosure *fc = cls;
615  struct NamespaceUpdateNode *nsn = value;
616  struct GNUNET_HashCode hc;
617 
618  if (nsn->nug == fc->nug)
619  {
620  if (UINT_MAX == nsn->tree_id)
621  return GNUNET_YES; /* circular */
623  if (fc->tree_array[nsn->tree_id] != nsn)
624  return GNUNET_YES; /* part of "another" (directed) TREE,
625  * and not root of it, end trace */
626  if (nsn->tree_id == fc->id)
627  return GNUNET_YES; /* that's our own root (can this be?) */
628  /* merge existing TREE, we have a root for both */
629  fc->tree_array[nsn->tree_id] = NULL;
630  if (UINT_MAX == fc->id)
631  fc->id = nsn->tree_id; /* take over ID */
632  }
633  else
634  {
635  nsn->nug = fc->nug;
636  nsn->tree_id = UINT_MAX; /* mark as undef */
637  /* trace */
638  GNUNET_CRYPTO_hash (nsn->update, strlen (nsn->update), &hc);
640  &hc,
641  &find_trees,
642  fc);
643  }
644  return GNUNET_YES;
645 }
#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:612
Closure for &#39;find_trees&#39;.
Definition: fs_namespace.c:562
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:577
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:582
unsigned int id
Identifier for the current TREE, or UINT_MAX for none yet.
Definition: fs_namespace.c:587
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:567
struct NamespaceUpdateNode ** tree_array
Array with &#39;head&#39;s of TREEs.
Definition: fs_namespace.c:572
#define GNUNET_YES
Definition: gnunet_common.h:77
Here is the call graph for this function:
Here is the caller graph for this function: