GNUnet  0.17.6
Typedefs | Functions
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.


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


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. More...
struct GNUNET_FS_PublishUblockContextGNUNET_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_CONTAINER_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. More...
void GNUNET_FS_publish_ublock_cancel_ (struct GNUNET_FS_PublishUblockContext *uc)
 Abort UBlock publishing operation. More...

Detailed Description

publish a UBLOCK in GNUnet

See also and #2564
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.

emsgerror message, NULL on success

Definition at line 67 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.

inputinput data
input_lennumber of bytes in input
nspublic key under which the UBlock was stored
labellabel under which the UBlock was stored
outputwhere to write the result, has input_len bytes

Definition at line 66 of file fs_publish_ublock.c.

71 {
75  derive_ublock_encryption_key (&skey, &iv,
76  label, ns);
77  GNUNET_CRYPTO_symmetric_decrypt (input, input_len,
78  &skey, &iv,
79  output);
80 }
static void derive_ublock_encryption_key(struct GNUNET_CRYPTO_SymmetricSessionKey *skey, struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, const char *label, const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Derive the key for symmetric encryption/decryption from the public key and the label.
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
Definition: gnunet-abd.c:41
ssize_t GNUNET_CRYPTO_symmetric_decrypt(const void *block, size_t size, const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey, const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, void *result)
Decrypt a given block using a symmetric sessionkey.

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_CONTAINER_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.

hhandle to the file sharing subsystem
dshdatastore handle to use for storage operation
labelidentifier to use
ulabelupdate label to use, may be an empty string for none
nsnamespace to publish in
metametadata to use
uriURI to refer to in the UBlock
boper-block options
optionspublication options
cont_clsclosure for cont
NULL on error (cont will still be called)

Definition at line 153 of file fs_publish_ublock.c.

163 {
165  struct GNUNET_HashCode query;
168  struct GNUNET_CRYPTO_EcdsaPrivateKey *nsd;
170  char *uris;
171  size_t size;
172  char *kbe;
173  char *sptr;
174  ssize_t mdsize;
175  size_t slen;
176  size_t ulen;
177  struct UBlock *ub_plain;
178  struct UBlock *ub_enc;
180  /* compute ublock to publish */
181  if (NULL == meta)
182  mdsize = 0;
183  else
185  GNUNET_assert (mdsize >= 0);
186  uris = GNUNET_FS_uri_to_string (uri);
187  slen = strlen (uris) + 1;
188  if (NULL == ulabel)
189  ulen = 1;
190  else
191  ulen = strlen (ulabel) + 1;
192  size = mdsize + sizeof(struct UBlock) + slen + ulen;
193  if (size > MAX_UBLOCK_SIZE)
194  {
196  mdsize = size - sizeof(struct UBlock) - (slen + ulen);
197  }
198  ub_plain = GNUNET_malloc (size);
199  kbe = (char *) &ub_plain[1];
200  if (NULL != ulabel)
201  GNUNET_memcpy (kbe, ulabel, ulen);
202  kbe += ulen;
203  GNUNET_memcpy (kbe, uris, slen);
204  kbe += slen;
205  GNUNET_free (uris);
206  sptr = kbe;
207  if (NULL != meta)
208  mdsize =
211  if (-1 == mdsize)
212  {
213  GNUNET_break (0);
214  GNUNET_free (ub_plain);
215  cont (cont_cls, _ ("Internal error."));
216  return NULL;
217  }
218  size = sizeof(struct UBlock) + slen + mdsize + ulen;
221  "Publishing under identifier `%s'\n",
222  label);
223  /* get public key of the namespace */
225  &pub);
226  derive_ublock_encryption_key (&skey, &iv,
227  label, &pub);
229  /* encrypt ublock */
230  ub_enc = GNUNET_malloc (size);
231  GNUNET_CRYPTO_symmetric_encrypt (&ub_plain[1],
232  ulen + slen + mdsize,
233  &skey, &iv,
234  &ub_enc[1]);
235  GNUNET_free (ub_plain);
236  ub_enc->purpose.size = htonl (ulen + slen + mdsize
237  + sizeof(struct UBlock)
238  - sizeof(struct GNUNET_CRYPTO_EcdsaSignature));
241  /* derive signing-key from 'label' and public key of the namespace */
242  nsd = GNUNET_CRYPTO_ecdsa_private_key_derive (ns, label, "fs-ublock");
244  &ub_enc->verification_key);
247  &ub_enc->purpose,
248  &ub_enc->signature));
250  sizeof(ub_enc->verification_key),
251  &query);
252  GNUNET_free (nsd);
255  uc->cont = cont;
256  uc->cont_cls = cont_cls;
257  if (NULL != dsh)
258  {
259  uc->qre =
261  0,
262  &query,
263  ulen + slen + mdsize + sizeof(struct UBlock),
264  ub_enc,
270  -2, 1,
271  &ublock_put_cont, uc);
272  }
273  else
274  {
276  uc);
277  }
278  GNUNET_free (ub_enc);
279  return uc;
280 }
Type of a block representing any type of search result (universal).
UBlock Signature, done using DSS, not ECC (GNUnet-FS)
static void run_cont(void *cls)
Run the continuation.
static void ublock_put_cont(void *cls, int32_t success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
Continuation of GNUNET_FS_publish_ublock_().
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
static struct GNUNET_FS_BlockOptions bo
Options we set for published blocks.
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.
static struct GNUNET_CRYPTO_EddsaPublicKey pub
Definition: gnunet-scrypt.c:46
static struct GNUNET_DATASTORE_Handle * dsh
Datastore handle.
static struct GNUNET_FS_UnindexContext * uc
Maximum legal size for a ublock.
Definition: block_fs.h:41
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdsa_sign_(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EcdsaSignature *sig)
ECDSA Sign a given block.
Definition: crypto_ecc.c:549
ssize_t GNUNET_CRYPTO_symmetric_encrypt(const void *block, size_t size, const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey, const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, void *result)
Encrypt a block using a symmetric sessionkey.
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:186
struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_CRYPTO_ecdsa_private_key_derive(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, const char *label, const char *context)
Derive a private key from a given private key and a label.
struct GNUNET_DATASTORE_QueueEntry * GNUNET_DATASTORE_put(struct GNUNET_DATASTORE_Handle *h, uint32_t rid, const struct GNUNET_HashCode *key, size_t size, const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority, uint32_t anonymity, uint32_t replication, struct GNUNET_TIME_Absolute expiration, unsigned int queue_priority, unsigned int max_queue_size, GNUNET_DATASTORE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the datastore.
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:2033
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Definition: gnunet_common.h:99
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
ssize_t GNUNET_CONTAINER_meta_data_serialize(const struct GNUNET_CONTAINER_MetaData *md, char **target, size_t max, enum GNUNET_CONTAINER_MetaDataSerializationOptions opt)
Serialize meta-data to target.
ssize_t GNUNET_CONTAINER_meta_data_get_serialized_size(const struct GNUNET_CONTAINER_MetaData *md)
Get the size of the full meta-data in serialized form.
If not enough space is available, it is acceptable to only serialize some of the metadata.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1281
static unsigned int size
Size of the "table".
Definition: peer.c:67
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!...
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
Private ECC key encoded for transmission.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
an ECC signature using ECDSA
uint32_t anonymity_level
At which anonymity level should the block be shared? (0: no anonymity, 1: normal GAP,...
uint32_t content_priority
How important is it for us to store the block? If we run out of space, the highest-priority,...
uint32_t replication_level
How often should we try to migrate the block to other peers? Only used if "CONTENT_PUSHING" is set to...
struct GNUNET_TIME_Absolute expiration_time
At what time should the block expire? Data blocks (DBLOCKS and IBLOCKS) may still be used even if the...
Context for 'ublock_put_cont'.
A 512-bit hashcode.
universal block for keyword and namespace search results
Definition: block_fs.h:50
struct GNUNET_CRYPTO_EcdsaPublicKey verification_key
Public key used to sign this block.
Definition: block_fs.h:64
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
What is being signed and why?
Definition: block_fs.h:59
struct GNUNET_CRYPTO_EcdsaSignature signature
Signature using pseudonym and search keyword / identifier.
Definition: block_fs.h:54

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_CONTAINER_meta_data_get_serialized_size(), GNUNET_CONTAINER_meta_data_serialize(), GNUNET_CONTAINER_META_DATA_SERIALIZE_PART, 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_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_EccSignaturePurpose::purpose, GNUNET_FS_BlockOptions::replication_level, run_cont(), UBlock::signature, GNUNET_CRYPTO_EccSignaturePurpose::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.

ucoperation to abort.

Definition at line 289 of file fs_publish_ublock.c.

290 {
291  if (NULL != uc->qre)
293  if (NULL != uc->task)
294  GNUNET_SCHEDULER_cancel (uc->task);
295  GNUNET_free (uc);
296 }
void GNUNET_DATASTORE_cancel(struct GNUNET_DATASTORE_QueueEntry *qe)
Cancel a datastore operation.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:957

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: