fs_publish_ublock.h File Reference

publish a UBLOCK in GNUnet More...

#include "gnunet_util_lib.h"
#include "gnunet_datastore_service.h"
#include "gnunet_fs_service.h"
#include "gnunet_identity_service.h"

Include dependency graph for fs_publish_ublock.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef void(*	GNUNET_FS_UBlockContinuation) (void *cls, const char *emsg)
	Signature of a function called as the continuation of a UBlock publication.

Functions
void	GNUNET_FS_ublock_decrypt_ (const void *input, size_t input_len, const struct GNUNET_CRYPTO_EcdsaPublicKey *ns, const char *label, void *output)
	Decrypt the given UBlock, storing the result in output.
struct GNUNET_FS_PublishUblockContext *	GNUNET_FS_publish_ublock_ (struct GNUNET_FS_Handle *h, struct GNUNET_DATASTORE_Handle *dsh, const char *label, const char *ulabel, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const struct GNUNET_FS_MetaData *meta, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_BlockOptions *bo, enum GNUNET_FS_PublishOptions options, GNUNET_FS_UBlockContinuation cont, void *cont_cls)
	Publish a UBlock.
void	GNUNET_FS_publish_ublock_cancel_ (struct GNUNET_FS_PublishUblockContext *uc)
	Abort UBlock publishing operation.

Detailed Description

publish a UBLOCK in GNUnet

See also

https://gnunet.org/encoding and #2564

Author

Krista Bennett

Christian Grothoff

Definition in file fs_publish_ublock.h.

Typedef Documentation

GNUNET_FS_UBlockContinuation

typedef void(* GNUNET_FS_UBlockContinuation) (void *cls, const char *emsg)

Signature of a function called as the continuation of a UBlock publication.

Parameters

cls	closure
emsg	error message, NULL on success

Definition at line 68 of file fs_publish_ublock.h.

Function Documentation

GNUNET_FS_ublock_decrypt_()

void GNUNET_FS_ublock_decrypt_	(	const void *	input,
		size_t	input_len,
		const struct GNUNET_CRYPTO_EcdsaPublicKey *	ns,
		const char *	label,
		void *	output
	)

Decrypt the given UBlock, storing the result in output.

Parameters

input	input data
input_len	number of bytes in input
ns	public key under which the UBlock was stored
label	label under which the UBlock was stored
output	where to write the result, has input_len bytes

Definition at line 66 of file fs_publish_ublock.c.

{
  struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
  struct GNUNET_CRYPTO_SymmetricSessionKey skey;
 
  derive_ublock_encryption_key (&skey, &iv,
                                label, ns);
  GNUNET_CRYPTO_symmetric_decrypt (input, input_len,
                                   &skey, &iv,
                                   output);
}

References derive_ublock_encryption_key(), GNUNET_CRYPTO_symmetric_decrypt(), and ns.

Referenced by decrypt_block_with_keyword(), process_kblock_for_unindex(), and process_sblock().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_publish_ublock_()

struct GNUNET_FS_PublishUblockContext * GNUNET_FS_publish_ublock_	(	struct GNUNET_FS_Handle *	h,
		struct GNUNET_DATASTORE_Handle *	dsh,
		const char *	label,
		const char *	ulabel,
		const struct GNUNET_CRYPTO_EcdsaPrivateKey *	ns,
		const struct GNUNET_FS_MetaData *	meta,
		const struct GNUNET_FS_Uri *	uri,
		const struct GNUNET_FS_BlockOptions *	bo,
		enum GNUNET_FS_PublishOptions	options,
		GNUNET_FS_UBlockContinuation	cont,
		void *	cont_cls
	)

Publish a UBlock.

Parameters

h	handle to the file sharing subsystem
dsh	datastore handle to use for storage operation
label	identifier to use
ulabel	update label to use, may be an empty string for none
ns	namespace to publish in
meta	metadata to use
uri	URI to refer to in the UBlock
bo	per-block options
options	publication options
cont	continuation
cont_cls	closure for cont

Returns

NULL on error (cont will still be called)

Definition at line 153 of file fs_publish_ublock.c.

{
  struct GNUNET_FS_PublishUblockContext *uc;
  struct GNUNET_HashCode query;
  struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
  struct GNUNET_CRYPTO_SymmetricSessionKey skey;
  struct GNUNET_CRYPTO_EcdsaPrivateKey *nsd;
  struct GNUNET_CRYPTO_EcdsaPublicKey pub;
  char *uris;
  size_t size;
  char *kbe;
  char *sptr;
  ssize_t mdsize;
  size_t slen;
  size_t ulen;
  struct UBlock *ub_plain;
  struct UBlock *ub_enc;
 
  /* compute ublock to publish */
  if (NULL == meta)
    mdsize = 0;
  else
    mdsize = GNUNET_FS_meta_data_get_serialized_size (meta);
  GNUNET_assert (mdsize >= 0);
  uris = GNUNET_FS_uri_to_string (uri);
  slen = strlen (uris) + 1;
  if (NULL == ulabel)
    ulen = 1;
  else
    ulen = strlen (ulabel) + 1;
  size = mdsize + sizeof(struct UBlock) + slen + ulen;
  if (size > MAX_UBLOCK_SIZE)
  {
    size = MAX_UBLOCK_SIZE;
    mdsize = size - sizeof(struct UBlock) - (slen + ulen);
  }
  ub_plain = GNUNET_malloc (size);
  kbe = (char *) &ub_plain[1];
  if (NULL != ulabel)
    GNUNET_memcpy (kbe, ulabel, ulen);
  kbe += ulen;
  GNUNET_memcpy (kbe, uris, slen);
  kbe += slen;
  GNUNET_free (uris);
  sptr = kbe;
  if (NULL != meta)
    mdsize =
      GNUNET_FS_meta_data_serialize (meta, &sptr, mdsize,
                                     GNUNET_FS_META_DATA_SERIALIZE_PART);
  if (-1 == mdsize)
  {
    GNUNET_break (0);
    GNUNET_free (ub_plain);
    cont (cont_cls, _ ("Internal error."));
    return NULL;
  }
  size = sizeof(struct UBlock) + slen + mdsize + ulen;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Publishing under identifier `%s'\n",
              label);
  /* get public key of the namespace */
  GNUNET_CRYPTO_ecdsa_key_get_public (ns,
                                      &pub);
  derive_ublock_encryption_key (&skey, &iv,
                                label, &pub);
 
  /* encrypt ublock */
  ub_enc = GNUNET_malloc (size);
  GNUNET_CRYPTO_symmetric_encrypt (&ub_plain[1],
                                   ulen + slen + mdsize,
                                   &skey, &iv,
                                   &ub_enc[1]);
  GNUNET_free (ub_plain);
  ub_enc->purpose.size = htonl (ulen + slen + mdsize
                                + sizeof(struct UBlock)
                                - sizeof(struct GNUNET_CRYPTO_EcdsaSignature));
  ub_enc->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_FS_UBLOCK);
 
  /* derive signing-key from 'label' and public key of the namespace */
  nsd = GNUNET_CRYPTO_ecdsa_private_key_derive (ns, label, "fs-ublock");
  GNUNET_CRYPTO_ecdsa_key_get_public (nsd,
                                      &ub_enc->verification_key);
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CRYPTO_ecdsa_sign_ (nsd,
                                            &ub_enc->purpose,
                                            &ub_enc->signature));
  GNUNET_CRYPTO_hash (&ub_enc->verification_key,
                      sizeof(ub_enc->verification_key),
                      &query);
  GNUNET_free (nsd);
 
  uc = GNUNET_new (struct GNUNET_FS_PublishUblockContext);
  uc->cont = cont;
  uc->cont_cls = cont_cls;
  if (NULL != dsh)
  {
    uc->qre =
      GNUNET_DATASTORE_put (dsh,
                            0,
                            &query,
                            ulen + slen + mdsize + sizeof(struct UBlock),
                            ub_enc,
                            GNUNET_BLOCK_TYPE_FS_UBLOCK,
                            bo->content_priority,
                            bo->anonymity_level,
                            bo->replication_level,
                            bo->expiration_time,
                            -2, 1,
                            &ublock_put_cont, uc);
  }
  else
  {
    uc->task = GNUNET_SCHEDULER_add_now (&run_cont,
                                         uc);
  }
  GNUNET_free (ub_enc);
  return uc;
}

References _, GNUNET_FS_BlockOptions::anonymity_level, bo, GNUNET_FS_BlockOptions::content_priority, derive_ublock_encryption_key(), dsh, GNUNET_FS_BlockOptions::expiration_time, GNUNET_assert, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_break, GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_CRYPTO_ecdsa_private_key_derive(), GNUNET_CRYPTO_ecdsa_sign_(), GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_symmetric_encrypt(), GNUNET_DATASTORE_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_FS_meta_data_get_serialized_size(), GNUNET_FS_meta_data_serialize(), GNUNET_FS_META_DATA_SERIALIZE_PART, GNUNET_FS_uri_to_string(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SIGNATURE_PURPOSE_FS_UBLOCK, MAX_UBLOCK_SIZE, meta, ns, pub, UBlock::purpose, GNUNET_CRYPTO_SignaturePurpose::purpose, GNUNET_FS_BlockOptions::replication_level, run_cont(), UBlock::signature, GNUNET_CRYPTO_SignaturePurpose::size, size, ublock_put_cont(), uc, uri, and UBlock::verification_key.

Referenced by GNUNET_FS_publish_sks(), and publish_ksk_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_publish_ublock_cancel_()

void GNUNET_FS_publish_ublock_cancel_

(

struct GNUNET_FS_PublishUblockContext *

uc

)

Abort UBlock publishing operation.

Parameters

uc	operation to abort.

Definition at line 289 of file fs_publish_ublock.c.

{
  if (NULL != uc->qre)
    GNUNET_DATASTORE_cancel (uc->qre);
  if (NULL != uc->task)
    GNUNET_SCHEDULER_cancel (uc->task);
  GNUNET_free (uc);
}

References GNUNET_DATASTORE_cancel(), GNUNET_free, GNUNET_SCHEDULER_cancel(), and uc.

Referenced by GNUNET_FS_publish_ksk_cancel(), and GNUNET_FS_publish_sks_cancel().

Here is the call graph for this function:

Here is the caller graph for this function: