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_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. 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_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_FS_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

h	file-sharing handle
ns	namespace handle

Returns

NULL on error, otherwise the name of the directory

Definition at line 128 of file fs_namespace.c.

{
  char *dn;
  char *ret;
  struct GNUNET_CRYPTO_EcdsaPublicKey pub;
  struct GNUNET_HashCode hc;
  struct GNUNET_CRYPTO_HashAsciiEncoded enc;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (h->cfg, "FS", "UPDATE_DIR", &dn))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "fs", "UPDATE_DIR");
    return NULL;
  }
  GNUNET_CRYPTO_ecdsa_key_get_public (ns, &pub);
  GNUNET_CRYPTO_hash (&pub, sizeof(pub), &hc);
  GNUNET_CRYPTO_hash_to_enc (&hc, &enc);
  GNUNET_asprintf (&ret,
                   "%s%s%s",
                   dn,
                   DIR_SEPARATOR_STR,
                   (const char *) enc.encoding);
  GNUNET_free (dn);
  return ret;
}

References GNUNET_ARM_Handle::cfg, DIR_SEPARATOR_STR, enc, 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, h, ns, pub, and ret.

Referenced by read_update_information_graph(), and write_update_information_graph().

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

uig	data structure to free

Definition at line 163 of file fs_namespace.c.

{
  unsigned int i;
  struct NamespaceUpdateNode *nsn;
 
  for (i = 0; i < uig->update_node_count; i++)
  {
    nsn = uig->update_nodes[i];
    GNUNET_FS_meta_data_destroy (nsn->md);
    GNUNET_FS_uri_destroy (nsn->uri);
    GNUNET_free (nsn->id);
    GNUNET_free (nsn->update);
    GNUNET_free (nsn);
  }
  GNUNET_array_grow (uig->update_nodes, uig->update_node_count, 0);
  if (NULL != uig->update_map)
    GNUNET_CONTAINER_multihashmap_destroy (uig->update_map);
  GNUNET_free (uig);
}

References GNUNET_array_grow, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_free, GNUNET_FS_meta_data_destroy(), 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().

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

uig	update information graph to dump

Definition at line 190 of file fs_namespace.c.

{
  char *fn;
  struct GNUNET_BIO_WriteHandle *wh;
  unsigned int i;
  struct NamespaceUpdateNode *n;
  char *uris;
 
  fn = get_update_information_directory (uig->h, &uig->ns);
  wh = GNUNET_BIO_write_open_file (fn);
  if (NULL == wh)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to open `%s' for writing: %s\n"),
                fn,
                strerror (errno));
    GNUNET_free (fn);
    return;
  }
  if (GNUNET_OK != GNUNET_BIO_write_int32 (wh,
                                           "fs-namespace-node-count",
                                           uig->update_node_count))
    goto END;
  for (i = 0; i < uig->update_node_count; i++)
  {
    n = uig->update_nodes[i];
    uris = GNUNET_FS_uri_to_string (n->uri);
    {
      struct GNUNET_BIO_WriteSpec ws[] = {
        GNUNET_BIO_write_spec_string ("fs-namespace-node-id", n->id),
        GNUNET_FS_write_spec_meta_data ("fs-namespace-node-meta", n->md),
        GNUNET_BIO_write_spec_string ("fs-namespace-node-update", n->update),
        GNUNET_BIO_write_spec_string ("fs-namespace-uris", uris),
        GNUNET_BIO_write_spec_end (),
      };
      if (GNUNET_OK != GNUNET_BIO_write_spec_commit (wh, ws))
      {
        GNUNET_free (uris);
        break;
      }
    }
    GNUNET_free (uris);
  }
END:
  if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to write `%s': %s\n"),
                fn,
                strerror (errno));
  GNUNET_free (fn);
}

References _, END, 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_string(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_FS_uri_to_string(), GNUNET_FS_write_spec_meta_data(), 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 GNUNET_BIO_WriteSpec::wh.

Referenced by sks_publish_cont().

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

h	FS handle to use
ns	namespace to read

Returns

update graph, never NULL

Definition at line 251 of file fs_namespace.c.

{
  struct GNUNET_FS_UpdateInformationGraph *uig;
  char *fn;
  struct GNUNET_BIO_ReadHandle *rh;
  unsigned int i;
  struct NamespaceUpdateNode *n;
  char *uris;
  uint32_t count;
  char *emsg;
 
  uig = GNUNET_new (struct GNUNET_FS_UpdateInformationGraph);
  uig->h = h;
  uig->ns = *ns;
  fn = get_update_information_directory (h, ns);
  if (GNUNET_YES != GNUNET_DISK_file_test (fn))
  {
    GNUNET_free (fn);
    return uig;
  }
  rh = GNUNET_BIO_read_open_file (fn);
  if (NULL == rh)
  {
    GNUNET_free (fn);
    return uig;
  }
  if (GNUNET_OK != GNUNET_BIO_read_int32 (rh, "fs-namespace-count",
                                          (int32_t *) &count))
  {
    GNUNET_break (0);
    goto END;
  }
  if (count > 1024 * 1024)
  {
    GNUNET_break (0);
    goto END;
  }
  if (0 == count)
    goto END;
  uig->update_nodes =
    GNUNET_malloc (count * sizeof(struct NamespaceUpdateNode *));
 
  for (i = 0; i < count; i++)
  {
    n = GNUNET_new (struct NamespaceUpdateNode);
    {
      struct GNUNET_BIO_ReadSpec rs[] = {
        GNUNET_BIO_read_spec_string ("identifier", &n->id, 1024),
        GNUNET_FS_read_spec_meta_data ("meta", &n->md),
        GNUNET_BIO_read_spec_string ("update-id", &n->update, 1024),
        GNUNET_BIO_read_spec_string ("uri", &uris, 1024 * 2),
        GNUNET_BIO_read_spec_end (),
      };
      if (GNUNET_OK != GNUNET_BIO_read_spec_commit (rh, rs))
      {
        GNUNET_break (0);
        GNUNET_free (n->id);
        GNUNET_free (n->update);
        if (n->md != NULL)
          GNUNET_FS_meta_data_destroy (n->md);
        GNUNET_free (n);
        break;
      }
    }
    n->uri = GNUNET_FS_uri_parse (uris, &emsg);
    GNUNET_free (uris);
    if (n->uri == NULL)
    {
      GNUNET_break (0);
      GNUNET_free (emsg);
      GNUNET_free (n->id);
      GNUNET_free (n->update);
      GNUNET_FS_meta_data_destroy (n->md);
      GNUNET_free (n);
      break;
    }
    uig->update_nodes[i] = n;
  }
  uig->update_node_count = i;
END:
  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to read `%s': %s\n"),
                fn,
                emsg);
    GNUNET_free (emsg);
  }
  GNUNET_free (fn);
  return uig;
}

References _, END, 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_string(), GNUNET_break, GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_FS_meta_data_destroy(), GNUNET_FS_read_spec_meta_data(), GNUNET_FS_uri_parse(), GNUNET_log, GNUNET_malloc, GNUNET_new, GNUNET_OK, GNUNET_YES, h, GNUNET_FS_UpdateInformationGraph::h, NamespaceUpdateNode::id, NamespaceUpdateNode::md, ns, GNUNET_FS_UpdateInformationGraph::ns, GNUNET_BIO_ReadSpec::rh, 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().

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

cls	closure of type "struct GNUNET_FS_PublishSksContext*"
msg	error message (or NULL)

Definition at line 401 of file fs_namespace.c.

{
  struct GNUNET_FS_PublishSksContext *psc = cls;
  struct GNUNET_FS_UpdateInformationGraph *uig;
 
  psc->uc = NULL;
  if (NULL != msg)
  {
    if (NULL != psc->cont)
      psc->cont (psc->cont_cls, NULL, msg);
    GNUNET_FS_publish_sks_cancel (psc);
    return;
  }
  if (NULL != psc->nsn)
  {
    /* FIXME: this can be done much more
     * efficiently by simply appending to the
     * file and overwriting the 4-byte header */
    uig = read_update_information_graph (psc->h, &psc->ns);
    GNUNET_array_append (uig->update_nodes, uig->update_node_count, psc->nsn);
    psc->nsn = NULL;
    write_update_information_graph (uig);
    free_update_information_graph (uig);
  }
  if (NULL != psc->cont)
    psc->cont (psc->cont_cls, psc->uri, NULL);
  GNUNET_FS_publish_sks_cancel (psc);
}

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, msg, 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().

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

cls	closure (of type 'struct ProcessUpdateClosure *')
key	current key code
value	value in the hash map (of type 'struct NamespaceUpdateNode *')

Returns

GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 548 of file fs_namespace.c.

{
  struct ProcessUpdateClosure *pc = cls;
  struct NamespaceUpdateNode *nsn = value;
 
  pc->ip (pc->ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
  return GNUNET_YES;
}

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

Referenced by GNUNET_FS_namespace_list_updateable().

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

cls	closure (of type 'struct FindTreeClosure')
key	current key code
value	value in the hash map

Returns

GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 611 of file fs_namespace.c.

{
  struct FindTreeClosure *fc = cls;
  struct NamespaceUpdateNode *nsn = value;
  struct GNUNET_HashCode hc;
 
  if (nsn->nug == fc->nug)
  {
    if (UINT_MAX == nsn->tree_id)
      return GNUNET_YES;   /* circular */
    GNUNET_assert (nsn->tree_id < fc->tree_array_size);
    if (fc->tree_array[nsn->tree_id] != nsn)
      return GNUNET_YES;   /* part of "another" (directed) TREE,
                            * and not root of it, end trace */
    if (nsn->tree_id == fc->id)
      return GNUNET_YES;   /* that's our own root (can this be?) */
    /* merge existing TREE, we have a root for both */
    fc->tree_array[nsn->tree_id] = NULL;
    if (UINT_MAX == fc->id)
      fc->id = nsn->tree_id;   /* take over ID */
  }
  else
  {
    nsn->nug = fc->nug;
    nsn->tree_id = UINT_MAX;   /* mark as undef */
    /* trace */
    GNUNET_CRYPTO_hash (nsn->update, strlen (nsn->update), &hc);
    GNUNET_CONTAINER_multihashmap_get_multiple (fc->uig->update_map,
                                                &hc,
                                                &find_trees,
                                                fc);
  }
  return GNUNET_YES;
}

References find_trees(), 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 find_trees(), and GNUNET_FS_namespace_list_updateable().

Here is the call graph for this function:

Here is the caller graph for this function: