GNUnet  0.11.x
Typedefs | Functions
fs_tree.h File Reference

Merkle-tree-ish-CHK file encoding for GNUnet. More...

#include "fs_api.h"
Include dependency graph for fs_tree.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_TreeBlockProcessor) (void *cls, const struct ContentHashKey *chk, uint64_t offset, unsigned int depth, enum GNUNET_BLOCK_Type type, const void *block, uint16_t block_size)
 Function called asking for the current (encoded) block to be processed. More...
 
typedef void(* GNUNET_FS_TreeProgressCallback) (void *cls, uint64_t offset, const void *pt_block, size_t pt_size, unsigned int depth)
 Function called with information about our progress in computing the tree encoding. More...
 

Functions

unsigned int GNUNET_FS_compute_depth (uint64_t flen)
 Compute the depth of the CHK tree. More...
 
uint64_t GNUNET_FS_tree_compute_tree_size (unsigned int depth)
 Calculate how many bytes of payload a block tree of the given depth MAY correspond to at most (this function ignores the fact that some blocks will only be present partially due to the total file size cutting some blocks off at the end). More...
 
size_t GNUNET_FS_tree_calculate_block_size (uint64_t fsize, uint64_t offset, unsigned int depth)
 Compute how many bytes of data should be stored in the specified block. More...
 
struct GNUNET_FS_TreeEncoderGNUNET_FS_tree_encoder_create (struct GNUNET_FS_Handle *h, uint64_t size, void *cls, GNUNET_FS_DataReader reader, GNUNET_FS_TreeBlockProcessor proc, GNUNET_FS_TreeProgressCallback progress, GNUNET_SCHEDULER_TaskCallback cont)
 Initialize a tree encoder. More...
 
void GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder *te)
 Encrypt the next block of the file (and call proc and progress accordingly; or of course "cont" if we have already completed encoding of the entire file). More...
 
struct GNUNET_FS_UriGNUNET_FS_tree_encoder_get_uri (struct GNUNET_FS_TreeEncoder *te)
 Get the resulting URI from the encoding. More...
 
void GNUNET_FS_tree_encoder_finish (struct GNUNET_FS_TreeEncoder *te, char **emsg)
 Clean up a tree encoder and return information about possible errors. More...
 

Detailed Description

Merkle-tree-ish-CHK file encoding for GNUnet.

See also
https://gnunet.org/encoding
Author
Krista Bennett
Christian Grothoff

TODO:

Definition in file fs_tree.h.

Typedef Documentation

◆ GNUNET_FS_TreeBlockProcessor

typedef void(* GNUNET_FS_TreeBlockProcessor) (void *cls, const struct ContentHashKey *chk, uint64_t offset, unsigned int depth, enum GNUNET_BLOCK_Type type, const void *block, uint16_t block_size)

Function called asking for the current (encoded) block to be processed.

After processing the client should either call "GNUNET_FS_tree_encode_next" or (on error) "GNUNET_FS_tree_encode_finish".

Parameters
clsclosure
chkcontent hash key for the block
offsetoffset of the block
depthdepth of the block, 0 for DBLOCKs
typetype of the block (IBLOCK or DBLOCK)
blockthe (encrypted) block
block_sizesize of block (in bytes)

Definition at line 97 of file fs_tree.h.

◆ GNUNET_FS_TreeProgressCallback

typedef void(* GNUNET_FS_TreeProgressCallback) (void *cls, uint64_t offset, const void *pt_block, size_t pt_size, unsigned int depth)

Function called with information about our progress in computing the tree encoding.

Parameters
clsclosure
offsetwhere are we in the file
pt_blockplaintext of the currently processed block
pt_sizesize of pt_block
depthdepth of the block in the tree, 0 for DBLOCKS

Definition at line 116 of file fs_tree.h.

Function Documentation

◆ GNUNET_FS_compute_depth()

unsigned int GNUNET_FS_compute_depth ( uint64_t  flen)

Compute the depth of the CHK tree.

Parameters
flenfile length for which to compute the depth
Returns
depth of the tree, always > 0. A depth of 1 means only a DBLOCK.

Definition at line 125 of file fs_tree.c.

References CHK_PER_INODE, and DBLOCK_SIZE.

Referenced by create_download_context(), deserialize_download(), encode_cont(), and GNUNET_FS_tree_encoder_create().

126 {
127  unsigned int treeDepth;
128  uint64_t fl;
129 
130  treeDepth = 1;
131  fl = DBLOCK_SIZE;
132  while (fl < flen)
133  {
134  treeDepth++;
135  if (fl * CHK_PER_INODE < fl)
136  {
137  /* integer overflow, this is a HUGE file... */
138  return treeDepth;
139  }
140  fl = fl * CHK_PER_INODE;
141  }
142  return treeDepth;
143 }
#define CHK_PER_INODE
Pick a multiple of 2 here to achive 8-byte alignment! We also probably want DBlocks to have (roughly)...
Definition: fs_api.h:43
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:40
Here is the caller graph for this function:

◆ GNUNET_FS_tree_compute_tree_size()

uint64_t GNUNET_FS_tree_compute_tree_size ( unsigned int  depth)

Calculate how many bytes of payload a block tree of the given depth MAY correspond to at most (this function ignores the fact that some blocks will only be present partially due to the total file size cutting some blocks off at the end).

Parameters
depthdepth of the block. depth==0 is a DBLOCK.
Returns
number of bytes of payload a subtree of this depth may correspond to

Definition at line 156 of file fs_tree.c.

References CHK_PER_INODE, and DBLOCK_SIZE.

Referenced by compute_chk_offset(), create_download_request(), GNUNET_FS_tree_calculate_block_size(), GNUNET_FS_tree_compute_iblock_size(), reconstruct_cb(), and try_top_down_reconstruction().

157 {
158  uint64_t rsize;
159  unsigned int i;
160 
161  rsize = DBLOCK_SIZE;
162  for (i = 0; i < depth; i++)
163  rsize *= CHK_PER_INODE;
164  return rsize;
165 }
#define CHK_PER_INODE
Pick a multiple of 2 here to achive 8-byte alignment! We also probably want DBlocks to have (roughly)...
Definition: fs_api.h:43
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:40
Here is the caller graph for this function:

◆ GNUNET_FS_tree_calculate_block_size()

size_t GNUNET_FS_tree_calculate_block_size ( uint64_t  fsize,
uint64_t  offset,
unsigned int  depth 
)

Compute how many bytes of data should be stored in the specified block.

Parameters
fsizeoverall file size, must be > 0.
offsetoffset in the original data corresponding to the beginning of the tree induced by the block; must be < fsize
depthdepth of the node in the tree, 0 for DBLOCK
Returns
number of bytes stored in this node
Parameters
fsizeoverall file size, must be > 0.
offsetoffset in the original data corresponding to the beginning of the tree induced by the block; must be <= fsize
depthdepth of the node in the tree, 0 for DBLOCK
Returns
number of bytes stored in this node

Definition at line 222 of file fs_tree.c.

References CHK_PER_INODE, DBLOCK_SIZE, GNUNET_assert, GNUNET_FS_tree_compute_tree_size(), and ret.

Referenced by process_result_with_request(), and try_top_down_reconstruction().

224 {
225  size_t ret;
226  uint64_t rsize;
227  uint64_t epos;
228  unsigned int chks;
229 
230  GNUNET_assert (fsize > 0);
231  GNUNET_assert (offset <= fsize);
232  if (depth == 0)
233  {
234  ret = DBLOCK_SIZE;
235  if ((offset + ret > fsize) || (offset + ret < offset))
236  ret = (size_t) (fsize - offset);
237  return ret;
238  }
239 
240  rsize = GNUNET_FS_tree_compute_tree_size (depth - 1);
241  epos = offset + rsize * CHK_PER_INODE;
242  if ((epos < offset) || (epos > fsize))
243  epos = fsize;
244  /* round up when computing #CHKs in our IBlock */
245  chks = (epos - offset + rsize - 1) / rsize;
246  GNUNET_assert (chks <= CHK_PER_INODE);
247  return chks * sizeof(struct ContentHashKey);
248 }
content hash key
Definition: fs.h:53
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
uint64_t GNUNET_FS_tree_compute_tree_size(unsigned int depth)
Calculate how many bytes of payload a block tree of the given depth MAY correspond to at most (this f...
Definition: fs_tree.c:156
#define CHK_PER_INODE
Pick a multiple of 2 here to achive 8-byte alignment! We also probably want DBlocks to have (roughly)...
Definition: fs_api.h:43
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:40
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_tree_encoder_create()

struct GNUNET_FS_TreeEncoder* GNUNET_FS_tree_encoder_create ( struct GNUNET_FS_Handle h,
uint64_t  size,
void *  cls,
GNUNET_FS_DataReader  reader,
GNUNET_FS_TreeBlockProcessor  proc,
GNUNET_FS_TreeProgressCallback  progress,
GNUNET_SCHEDULER_TaskCallback  cont 
)

Initialize a tree encoder.

This function will call "proc" and "progress" on each block in the tree. Once all blocks have been processed, "cont" will be scheduled. The "reader" will be called to obtain the (plaintext) blocks for the file. Note that this function will actually never call "proc"; the "proc" function must be triggered by calling "GNUNET_FS_tree_encoder_next" to trigger encryption (and calling of "proc") for each block.

Parameters
hthe global FS context
sizeoverall size of the file to encode
clsclosure for reader, proc, progress and cont
readerfunction to call to read plaintext data
procfunction to call on each encrypted block
progressfunction to call with progress information
contfunction to call when done
Returns
tree encoder context

This function will call proc and "progress" on each block in the tree. Once all blocks have been processed, "cont" will be scheduled. The reader will be called to obtain the (plaintext) blocks for the file. Note that this function will not actually call proc. The client must call GNUNET_FS_tree_encoder_next to trigger encryption (and calling of proc) for the each block.

Parameters
hthe global FS context
sizeoverall size of the file to encode
clsclosure for reader, proc, progress and cont
readerfunction to call to read plaintext data
procfunction to call on each encrypted block
progressfunction to call with progress information
contfunction to call when done

Definition at line 269 of file fs_tree.c.

References CHK_PER_INODE, GNUNET_FS_TreeEncoder::chk_tree, GNUNET_FS_TreeEncoder::chk_tree_depth, GNUNET_FS_TreeEncoder::cls, GNUNET_FS_TreeEncoder::cont, GNUNET_ERROR_TYPE_DEBUG, GNUNET_FS_compute_depth(), GNUNET_log, GNUNET_new, GNUNET_new_array, GNUNET_FS_TreeEncoder::h, GNUNET_FS_TreeEncoder::proc, GNUNET_FS_TreeEncoder::progress, GNUNET_FS_TreeEncoder::reader, and GNUNET_FS_TreeEncoder::size.

Referenced by GNUNET_FS_download_start_task_(), GNUNET_FS_unindex_do_remove_(), and publish_content().

275 {
276  struct GNUNET_FS_TreeEncoder *te;
277 
278  te = GNUNET_new (struct GNUNET_FS_TreeEncoder);
279  te->h = h;
280  te->size = size;
281  te->cls = cls;
282  te->reader = reader;
283  te->proc = proc;
284  te->progress = progress;
285  te->cont = cont;
287  te->chk_tree
289  struct ContentHashKey);
291  "Created tree encoder for file with %llu bytes and depth %u\n",
292  (unsigned long long) size,
293  te->chk_tree_depth);
294  return te;
295 }
uint64_t size
Overall file size.
Definition: fs_tree.c:80
Context for an ECRS-based file encoder that computes the Merkle-ish-CHK tree.
Definition: fs_tree.c:35
GNUNET_FS_DataReader reader
Function to call to receive input data.
Definition: fs_tree.c:60
content hash key
Definition: fs.h:53
void * cls
Closure for all callbacks.
Definition: fs_tree.c:45
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
unsigned int GNUNET_FS_compute_depth(uint64_t flen)
Compute the depth of the CHK tree.
Definition: fs_tree.c:125
GNUNET_FS_TreeBlockProcessor proc
Function to call on encrypted blocks.
Definition: fs_tree.c:50
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_tree.c:40
GNUNET_SCHEDULER_TaskCallback cont
Function to call once we&#39;re done with processing.
Definition: fs_tree.c:65
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
#define CHK_PER_INODE
Pick a multiple of 2 here to achive 8-byte alignment! We also probably want DBlocks to have (roughly)...
Definition: fs_api.h:43
struct ContentHashKey * chk_tree
In-memory cache of the current CHK tree.
Definition: fs_tree.c:108
static unsigned int size
Size of the "table".
Definition: peer.c:67
unsigned int chk_tree_depth
How deep is the tree? Always > 0.
Definition: fs_tree.c:95
#define GNUNET_log(kind,...)
GNUNET_FS_TreeProgressCallback progress
Function to call with progress information.
Definition: fs_tree.c:55
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_tree_encoder_next()

void GNUNET_FS_tree_encoder_next ( struct GNUNET_FS_TreeEncoder te)

Encrypt the next block of the file (and call proc and progress accordingly; or of course "cont" if we have already completed encoding of the entire file).

Parameters
tetree encoder to use

Definition at line 331 of file fs_tree.c.

References GNUNET_FS_Uri::chk, FileIdentifier::chk, CHK_PER_INODE, GNUNET_FS_TreeEncoder::chk_tree, GNUNET_FS_TreeEncoder::chk_tree_depth, GNUNET_FS_TreeEncoder::cls, compute_chk_offset(), GNUNET_FS_TreeEncoder::cont, GNUNET_FS_TreeEncoder::current_depth, GNUNET_FS_Uri::data, DBLOCK_SIZE, GNUNET_FS_TreeEncoder::emsg, enc, FileIdentifier::file_length, GNUNET_assert, GNUNET_BLOCK_TYPE_FS_DBLOCK, GNUNET_BLOCK_TYPE_FS_IBLOCK, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hash_to_aes_key(), GNUNET_CRYPTO_symmetric_encrypt(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_FS_tree_compute_iblock_size(), GNUNET_FS_URI_CHK, GNUNET_h2s(), GNUNET_htonll(), GNUNET_log, GNUNET_MIN, GNUNET_new, GNUNET_NO, GNUNET_YES, GNUNET_FS_TreeEncoder::in_next, ContentHashKey::key, GNUNET_FS_TreeEncoder::proc, GNUNET_FS_TreeEncoder::progress, GNUNET_FS_TreeEncoder::publish_offset, ContentHashKey::query, GNUNET_FS_TreeEncoder::reader, GNUNET_FS_TreeEncoder::size, GNUNET_FS_Uri::type, and GNUNET_FS_TreeEncoder::uri.

Referenced by get_next_block(), GNUNET_FS_unindex_do_remove_(), process_cont(), and publish_content().

332 {
333  struct ContentHashKey *mychk;
334  const void *pt_block;
335  uint16_t pt_size;
336  char iob[DBLOCK_SIZE];
337  char enc[DBLOCK_SIZE];
340  unsigned int off;
341 
343  te->in_next = GNUNET_YES;
344  if (te->chk_tree_depth == te->current_depth)
345  {
346  off = CHK_PER_INODE * (te->chk_tree_depth - 1);
347  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "TE done, reading CHK `%s' from %u\n",
348  GNUNET_h2s (&te->chk_tree[off].query), off);
349  te->uri = GNUNET_new (struct GNUNET_FS_Uri);
350  te->uri->type = GNUNET_FS_URI_CHK;
351  te->uri->data.chk.chk = te->chk_tree[off];
352  te->uri->data.chk.file_length = GNUNET_htonll (te->size);
353  te->in_next = GNUNET_NO;
354  te->cont (te->cls);
355  return;
356  }
357  if (0 == te->current_depth)
358  {
359  /* read DBLOCK */
360  pt_size = GNUNET_MIN (DBLOCK_SIZE, te->size - te->publish_offset);
361  if (pt_size !=
362  te->reader (te->cls, te->publish_offset, pt_size, iob, &te->emsg))
363  {
364  te->in_next = GNUNET_NO;
365  te->cont (te->cls);
366  return;
367  }
368  pt_block = iob;
369  }
370  else
371  {
372  pt_size =
374  te->publish_offset);
375  pt_block = &te->chk_tree[(te->current_depth - 1) * CHK_PER_INODE];
376  }
379  "TE is at offset %llu and depth %u with block size %u and target-CHK-offset %u\n",
380  (unsigned long long) te->publish_offset, te->current_depth,
381  (unsigned int) pt_size, (unsigned int) off);
382  mychk = &te->chk_tree[te->current_depth * CHK_PER_INODE + off];
383  GNUNET_CRYPTO_hash (pt_block, pt_size, &mychk->key);
384  GNUNET_CRYPTO_hash_to_aes_key (&mychk->key, &sk, &iv);
385  GNUNET_CRYPTO_symmetric_encrypt (pt_block, pt_size, &sk, &iv, enc);
386  GNUNET_CRYPTO_hash (enc, pt_size, &mychk->query);
388  "TE calculates query to be `%s', stored at %u\n",
389  GNUNET_h2s (&mychk->query),
390  te->current_depth * CHK_PER_INODE + off);
391  if (NULL != te->proc)
392  te->proc (te->cls, mychk, te->publish_offset, te->current_depth,
393  (0 ==
395  GNUNET_BLOCK_TYPE_FS_IBLOCK, enc, pt_size);
396  if (NULL != te->progress)
397  te->progress (te->cls, te->publish_offset, pt_block, pt_size,
398  te->current_depth);
399  if (0 == te->current_depth)
400  {
401  te->publish_offset += pt_size;
402  if ((te->publish_offset == te->size) ||
403  (0 == te->publish_offset % (CHK_PER_INODE * DBLOCK_SIZE)))
404  te->current_depth++;
405  }
406  else
407  {
408  if ((off == CHK_PER_INODE) || (te->publish_offset == te->size))
409  te->current_depth++;
410  else
411  te->current_depth = 0;
412  }
413  te->in_next = GNUNET_NO;
414 }
uint64_t size
Overall file size.
Definition: fs_tree.c:80
struct ContentHashKey chk
Query and key of the top GNUNET_EC_IBlock.
Definition: fs_api.h:103
GNUNET_FS_DataReader reader
Function to call to receive input data.
Definition: fs_tree.c:60
struct FileIdentifier chk
Information needed to retrieve a file (content-hash-key plus file size).
Definition: fs_api.h:211
struct GNUNET_FS_Uri * uri
Set to the URI (upon successful completion)
Definition: fs_tree.c:75
static unsigned int compute_chk_offset(unsigned int depth, uint64_t end_offset)
Compute the offset of the CHK for the current block in the IBlock above.
Definition: fs_tree.c:310
uint64_t publish_offset
How far are we?
Definition: fs_tree.c:85
content hash key
Definition: fs.h:53
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void * cls
Closure for all callbacks.
Definition: fs_tree.c:45
unsigned int current_depth
How deep are we? Depth 0 is for the DBLOCKs.
Definition: fs_tree.c:90
#define GNUNET_NO
Definition: gnunet_common.h:78
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static uint16_t GNUNET_FS_tree_compute_iblock_size(unsigned int depth, uint64_t end_offset)
Compute the size of the current IBLOCK.
Definition: fs_tree.c:183
GNUNET_FS_TreeBlockProcessor proc
Function to call on encrypted blocks.
Definition: fs_tree.c:50
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
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.
GNUNET_SCHEDULER_TaskCallback cont
Function to call once we&#39;re done with processing.
Definition: fs_tree.c:65
struct GNUNET_HashCode query
Hash of the encrypted content, used for querying.
Definition: fs.h:63
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:80
Inner block in the CHK tree.
#define CHK_PER_INODE
Pick a multiple of 2 here to achive 8-byte alignment! We also probably want DBlocks to have (roughly)...
Definition: fs_api.h:43
int in_next
Are we currently in &#39;GNUNET_FS_tree_encoder_next&#39;? Flag used to prevent recursion.
Definition: fs_tree.c:114
struct ContentHashKey * chk_tree
In-memory cache of the current CHK tree.
Definition: fs_tree.c:108
void GNUNET_CRYPTO_hash_to_aes_key(const struct GNUNET_HashCode *hc, struct GNUNET_CRYPTO_SymmetricSessionKey *skey, struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
Convert a hashcode into a key.
Definition: crypto_hash.c:222
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:40
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:35
Content-hash-key (simple file).
Definition: fs_api.h:143
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:170
union GNUNET_FS_Uri::@13 data
char * emsg
Set to an error message (if we had an error).
Definition: fs_tree.c:70
struct GNUNET_HashCode key
Hash of the original content, used for encryption.
Definition: fs.h:58
unsigned int chk_tree_depth
How deep is the tree? Always > 0.
Definition: fs_tree.c:95
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:165
uint64_t file_length
Total size of the file in bytes.
Definition: fs_api.h:98
static OpusEncoder * enc
OPUS encoder.
#define GNUNET_log(kind,...)
GNUNET_FS_TreeProgressCallback progress
Function to call with progress information.
Definition: fs_tree.c:55
Data block (leaf) in the CHK tree.
#define GNUNET_YES
Definition: gnunet_common.h:77
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_tree_encoder_get_uri()

struct GNUNET_FS_Uri* GNUNET_FS_tree_encoder_get_uri ( struct GNUNET_FS_TreeEncoder te)

Get the resulting URI from the encoding.

Parameters
tethe tree encoder to clean up
Returns
uri set to the resulting URI (if encoding finished), NULL otherwise

Definition at line 424 of file fs_tree.c.

References GNUNET_FS_uri_dup(), and GNUNET_FS_TreeEncoder::uri.

Referenced by encode_cont().

425 {
426  if (NULL != te->uri)
427  return GNUNET_FS_uri_dup (te->uri);
428  return NULL;
429 }
struct GNUNET_FS_Uri * uri
Set to the URI (upon successful completion)
Definition: fs_tree.c:75
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:998
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_tree_encoder_finish()

void GNUNET_FS_tree_encoder_finish ( struct GNUNET_FS_TreeEncoder te,
char **  emsg 
)

Clean up a tree encoder and return information about possible errors.

Parameters
tethe tree encoder to clean up
emsgset to an error message (if an error occured within the tree encoder; if this function is called prior to completion and prior to an internal error, both "*emsg" will be set to NULL).

Definition at line 443 of file fs_tree.c.

References GNUNET_FS_TreeEncoder::chk_tree, GNUNET_FS_TreeEncoder::cls, GNUNET_FS_TreeEncoder::emsg, GNUNET_assert, GNUNET_free, GNUNET_free_non_null, GNUNET_FS_uri_destroy(), GNUNET_NO, GNUNET_FS_TreeEncoder::in_next, GNUNET_FS_TreeEncoder::reader, and GNUNET_FS_TreeEncoder::uri.

Referenced by encode_cont(), GNUNET_FS_download_signal_suspend_(), GNUNET_FS_download_stop(), GNUNET_FS_file_information_destroy(), GNUNET_FS_unindex_signal_suspend_(), GNUNET_FS_unindex_stop(), and unindex_finish().

445 {
446  if (NULL != te->reader)
447  {
448  (void) te->reader (te->cls, UINT64_MAX, 0, 0, NULL);
449  te->reader = NULL;
450  }
452  if (NULL != te->uri)
454  if (emsg != NULL)
455  *emsg = te->emsg;
456  else
458  GNUNET_free (te->chk_tree);
459  GNUNET_free (te);
460 }
GNUNET_FS_DataReader reader
Function to call to receive input data.
Definition: fs_tree.c:60
struct GNUNET_FS_Uri * uri
Set to the URI (upon successful completion)
Definition: fs_tree.c:75
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void * cls
Closure for all callbacks.
Definition: fs_tree.c:45
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:678
int in_next
Are we currently in &#39;GNUNET_FS_tree_encoder_next&#39;? Flag used to prevent recursion.
Definition: fs_tree.c:114
struct ContentHashKey * chk_tree
In-memory cache of the current CHK tree.
Definition: fs_tree.c:108
char * emsg
Set to an error message (if we had an error).
Definition: fs_tree.c:70
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function: