GNUnet  0.10.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 125 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().

128 {
129  char *dn;
130  char *ret;
132  struct GNUNET_HashCode hc;
134 
135  if (GNUNET_OK !=
136  GNUNET_CONFIGURATION_get_value_filename(h->cfg, "FS", "UPDATE_DIR", &dn))
137  {
139  return NULL;
140  }
142  GNUNET_CRYPTO_hash(&pub, sizeof(pub), &hc);
144  GNUNET_asprintf(&ret,
145  "%s%s%s",
146  dn,
148  (const char *)enc.encoding);
149  GNUNET_free(dn);
150  return ret;
151 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
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:44
#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:69
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:241
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:1060
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 160 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().

161 {
162  unsigned int i;
163  struct NamespaceUpdateNode *nsn;
164 
165  for (i = 0; i < uig->update_node_count; i++)
166  {
167  nsn = uig->update_nodes[i];
170  GNUNET_free(nsn->id);
171  GNUNET_free(nsn->update);
172  GNUNET_free(nsn);
173  }
175  if (NULL != uig->update_map)
177  GNUNET_free(uig);
178 }
struct GNUNET_FS_Uri * uri
URI of this entry in the namespace.
Definition: fs_namespace.c:59
char * id
Identifier for this node.
Definition: fs_namespace.c:44
#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:102
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:49
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:675
struct GNUNET_CONTAINER_MultiHashMap * update_map
Hash map mapping identifiers of update nodes to the update nodes (initialized on-demand).
Definition: fs_namespace.c:97
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:86
struct GNUNET_CONTAINER_MetaData * md
Metadata for this entry.
Definition: fs_namespace.c:54
#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 187 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().

188 {
189  char *fn;
190  struct GNUNET_BIO_WriteHandle *wh;
191  unsigned int i;
192  struct NamespaceUpdateNode *n;
193  char *uris;
194 
195  fn = get_update_information_directory(uig->h, &uig->ns);
196  wh = GNUNET_BIO_write_open(fn);
197  if (NULL == wh)
198  {
200  _("Failed to open `%s' for writing: %s\n"),
201  fn,
202  strerror(errno));
203  GNUNET_free(fn);
204  return;
205  }
207  goto END;
208  for (i = 0; i < uig->update_node_count; i++)
209  {
210  n = uig->update_nodes[i];
211  uris = GNUNET_FS_uri_to_string(n->uri);
212  if ((GNUNET_OK != GNUNET_BIO_write_string(wh, n->id)) ||
213  (GNUNET_OK != GNUNET_BIO_write_meta_data(wh, n->md)) ||
215  (GNUNET_OK != GNUNET_BIO_write_string(wh, uris)))
216  {
217  GNUNET_free(uris);
218  break;
219  }
220  GNUNET_free(uris);
221  }
222 END:
225  _("Failed to write `%s': %s\n"),
226  fn,
227  strerror(errno));
228  GNUNET_free(fn);
229 }
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:542
struct GNUNET_FS_Uri * uri
URI of this entry in the namespace.
Definition: fs_namespace.c:59
int GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *s)
Write a string to a file.
Definition: bio.c:521
struct GNUNET_FS_Handle * h
Handle to the FS service context.
Definition: fs_namespace.c:81
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:2024
char * id
Identifier for this node.
Definition: fs_namespace.c:44
unsigned int update_node_count
Size of the update nodes array.
Definition: fs_namespace.c:102
struct GNUNET_CRYPTO_EcdsaPrivateKey ns
Private key for the namespace.
Definition: fs_namespace.c:91
static char * fn
Filename of the unique file.
char * update
Identifier of children of this node.
Definition: fs_namespace.c:49
Handle for buffered writing.
Definition: bio.c:378
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:86
int GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h)
Close an open file for writing.
Definition: bio.c:436
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:125
struct GNUNET_CONTAINER_MetaData * md
Metadata for this entry.
Definition: fs_namespace.c:54
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open(const char *fn)
Open a file for writing.
Definition: bio.c:408
#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:580
#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 240 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().

242 {
244  char *fn;
245  struct GNUNET_BIO_ReadHandle *rh;
246  unsigned int i;
247  struct NamespaceUpdateNode *n;
248  char *uris;
249  uint32_t count;
250  char *emsg;
251 
253  uig->h = h;
254  uig->ns = *ns;
257  {
258  GNUNET_free(fn);
259  return uig;
260  }
261  rh = GNUNET_BIO_read_open(fn);
262  if (NULL == rh)
263  {
264  GNUNET_free(fn);
265  return uig;
266  }
267  if (GNUNET_OK != GNUNET_BIO_read_int32(rh, &count))
268  {
269  GNUNET_break(0);
270  goto END;
271  }
272  if (count > 1024 * 1024)
273  {
274  GNUNET_break(0);
275  goto END;
276  }
277  if (0 == count)
278  goto END;
279  uig->update_nodes =
280  GNUNET_malloc(count * sizeof(struct NamespaceUpdateNode *));
281 
282  for (i = 0; i < count; i++)
283  {
284  n = GNUNET_new(struct NamespaceUpdateNode);
285  if ((GNUNET_OK !=
286  GNUNET_BIO_read_string(rh, "identifier", &n->id, 1024)) ||
287  (GNUNET_OK != GNUNET_BIO_read_meta_data(rh, "meta", &n->md)) ||
288  (GNUNET_OK !=
289  GNUNET_BIO_read_string(rh, "update-id", &n->update, 1024)) ||
290  (GNUNET_OK != GNUNET_BIO_read_string(rh, "uri", &uris, 1024 * 2)))
291  {
292  GNUNET_break(0);
295  if (n->md != NULL)
297  GNUNET_free(n);
298  break;
299  }
300  n->uri = GNUNET_FS_uri_parse(uris, &emsg);
301  GNUNET_free(uris);
302  if (n->uri == NULL)
303  {
304  GNUNET_break(0);
305  GNUNET_free(emsg);
306  GNUNET_free(n->id);
309  GNUNET_free(n);
310  break;
311  }
312  uig->update_nodes[i] = n;
313  }
314  uig->update_node_count = i;
315 END:
316  if (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg))
317  {
319  _("Failed to read `%s': %s\n"),
320  fn,
321  emsg);
322  GNUNET_free(emsg);
323  }
324  GNUNET_free(fn);
325  return uig;
326 }
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:541
struct GNUNET_FS_Uri * uri
URI of this entry in the namespace.
Definition: fs_namespace.c:59
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:641
struct GNUNET_FS_Handle * h
Handle to the FS service context.
Definition: fs_namespace.c:81
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:118
#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:94
#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:93
char * id
Identifier for this node.
Definition: fs_namespace.c:44
unsigned int update_node_count
Size of the update nodes array.
Definition: fs_namespace.c:102
struct GNUNET_CRYPTO_EcdsaPrivateKey ns
Private key for the namespace.
Definition: fs_namespace.c:91
static char * fn
Filename of the unique file.
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:49
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:232
#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
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
struct NamespaceUpdateNode ** update_nodes
Array with information about nodes in the namespace.
Definition: fs_namespace.c:86
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:125
struct GNUNET_CONTAINER_MetaData * md
Metadata for this entry.
Definition: fs_namespace.c:54
#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:284
#define GNUNET_YES
Definition: gnunet_common.h:77
Handle to update information for a namespace.
Definition: fs_namespace.c:77
#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 384 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().

385 {
386  struct GNUNET_FS_PublishSksContext *psc = cls;
388 
389  psc->uc = NULL;
390  if (NULL != msg)
391  {
392  if (NULL != psc->cont)
393  psc->cont(psc->cont_cls, NULL, msg);
395  return;
396  }
397  if (NULL != psc->nsn)
398  {
399  /* FIXME: this can be done much more
400  * efficiently by simply appending to the
401  * file and overwriting the 4-byte header */
402  uig = read_update_information_graph(psc->h, &psc->ns);
404  psc->nsn = NULL;
407  }
408  if (NULL != psc->cont)
409  psc->cont(psc->cont_cls, psc->uri, NULL);
411 }
GNUNET_FS_PublishContinuation cont
Function to call once we&#39;re done.
Definition: fs_namespace.c:362
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:336
Context for the SKS publication.
Definition: fs_namespace.c:332
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:187
struct GNUNET_FS_Handle * h
Handle to FS.
Definition: fs_namespace.c:357
static void free_update_information_graph(struct GNUNET_FS_UpdateInformationGraph *uig)
Release memory occupied by UIG datastructure.
Definition: fs_namespace.c:160
unsigned int update_node_count
Size of the update nodes array.
Definition: fs_namespace.c:102
struct GNUNET_CRYPTO_EcdsaPrivateKey ns
Namespace we&#39;re publishing to.
Definition: fs_namespace.c:347
void GNUNET_FS_publish_sks_cancel(struct GNUNET_FS_PublishSksContext *psc)
Abort the SKS publishing operation.
Definition: fs_namespace.c:493
struct NamespaceUpdateNode ** update_nodes
Array with information about nodes in the namespace.
Definition: fs_namespace.c:86
#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:342
void * cont_cls
Closure for cont.
Definition: fs_namespace.c:367
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:240
struct GNUNET_FS_PublishUblockContext * uc
Handle for our UBlock operation request.
Definition: fs_namespace.c:372
Handle to update information for a namespace.
Definition: fs_namespace.c:77
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 545 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().

546 {
547  struct ProcessUpdateClosure *pc = cls;
548  struct NamespaceUpdateNode *nsn = value;
549 
550  pc->ip(pc->ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
551  return GNUNET_YES;
552 }
struct GNUNET_FS_Uri * uri
URI of this entry in the namespace.
Definition: fs_namespace.c:59
GNUNET_FS_IdentifierProcessor ip
Function to call for each node.
Definition: fs_namespace.c:525
char * id
Identifier for this node.
Definition: fs_namespace.c:44
static char * value
Value of the record to add/remove.
char * update
Identifier of children of this node.
Definition: fs_namespace.c:49
Closure for &#39;process_update_node&#39;.
Definition: fs_namespace.c:521
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:530
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
struct GNUNET_CONTAINER_MetaData * md
Metadata for this entry.
Definition: fs_namespace.c:54
#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 607 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().

608 {
609  struct FindTreeClosure *fc = cls;
610  struct NamespaceUpdateNode *nsn = value;
611  struct GNUNET_HashCode hc;
612 
613  if (nsn->nug == fc->nug)
614  {
615  if (UINT_MAX == nsn->tree_id)
616  return GNUNET_YES; /* circular */
618  if (fc->tree_array[nsn->tree_id] != nsn)
619  return GNUNET_YES; /* part of "another" (directed) TREE,
620  * and not root of it, end trace */
621  if (nsn->tree_id == fc->id)
622  return GNUNET_YES; /* that's our own root (can this be?) */
623  /* merge existing TREE, we have a root for both */
624  fc->tree_array[nsn->tree_id] = NULL;
625  if (UINT_MAX == fc->id)
626  fc->id = nsn->tree_id; /* take over ID */
627  }
628  else
629  {
630  nsn->nug = fc->nug;
631  nsn->tree_id = UINT_MAX; /* mark as undef */
632  /* trace */
633  GNUNET_CRYPTO_hash(nsn->update, strlen(nsn->update), &hc);
635  &hc,
636  &find_trees,
637  fc);
638  }
639  return GNUNET_YES;
640 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
unsigned int nug
Namespace update generation ID.
Definition: fs_namespace.c:65
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:607
Closure for &#39;find_trees&#39;.
Definition: fs_namespace.c:558
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:572
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
char * update
Identifier of children of this node.
Definition: fs_namespace.c:49
unsigned int tree_id
TREE this entry belongs to (if nug is current).
Definition: fs_namespace.c:70
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:97
Information about an (updateable) node in the namespace.
Definition: fs_namespace.c:40
unsigned int nug
Current generational ID used.
Definition: fs_namespace.c:577
unsigned int id
Identifier for the current TREE, or UINT_MAX for none yet.
Definition: fs_namespace.c:582
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:562
struct NamespaceUpdateNode ** tree_array
Array with &#39;head&#39;s of TREEs.
Definition: fs_namespace.c:567
#define GNUNET_YES
Definition: gnunet_common.h:77
Here is the call graph for this function:
Here is the caller graph for this function: