GNUnet  0.11.x
Data Structures | Macros | Typedefs | Functions
BIO library

Buffered binary disk IO (with endianness conversion) More...

Data Structures

struct  GNUNET_BIO_ReadSpec
 Structure specifying a reading operation on an IO handle. More...
 
struct  GNUNET_BIO_WriteSpec
 Structure specifying a writing operation on an IO handle. More...
 

Macros

#define GNUNET_BIO_read_spec_end()    { NULL, NULL, NULL, NULL, 0 }
 End of specifications marker. More...
 
#define GNUNET_BIO_write_spec_end()    { NULL, NULL, NULL, NULL, 0 }
 End of specifications marker. More...
 

Typedefs

typedef int(* GNUNET_BIO_ReadHandler) (void *cls, struct GNUNET_BIO_ReadHandle *h, const char *what, void *target, size_t target_size)
 Function used to deserialize data read from h and store it into target. More...
 
typedef int(* GNUNET_BIO_WriteHandler) (void *cls, struct GNUNET_BIO_WriteHandle *h, const char *what, void *source, size_t source_size)
 Function used to serialize data from a buffer and write it to h. More...
 

Functions

struct GNUNET_BIO_ReadHandleGNUNET_BIO_read_open_file (const char *fn)
 Open a file for reading. More...
 
struct GNUNET_BIO_ReadHandleGNUNET_BIO_read_open_buffer (void *buffer, size_t size)
 Create a handle from an existing allocated buffer. More...
 
int GNUNET_BIO_read_close (struct GNUNET_BIO_ReadHandle *h, char **emsg)
 Close an open handle. More...
 
int GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h, const char *what, void *result, size_t len)
 Read some contents into a buffer. More...
 
int GNUNET_BIO_read_string (struct GNUNET_BIO_ReadHandle *h, const char *what, char **result, size_t max_length)
 Read 0-terminated string. More...
 
int GNUNET_BIO_read_meta_data (struct GNUNET_BIO_ReadHandle *h, const char *what, struct GNUNET_CONTAINER_MetaData **result)
 Read a metadata container. More...
 
int GNUNET_BIO_read_float (struct GNUNET_BIO_ReadHandle *h, const char *what, float *f)
 Read a float. More...
 
int GNUNET_BIO_read_double (struct GNUNET_BIO_ReadHandle *h, const char *what, double *f)
 Read a double. More...
 
int GNUNET_BIO_read_int32 (struct GNUNET_BIO_ReadHandle *h, const char *what, int32_t *i)
 Read an (u)int32_t. More...
 
int GNUNET_BIO_read_int64 (struct GNUNET_BIO_ReadHandle *h, const char *what, int64_t *i)
 Read an (u)int64_t. More...
 
struct GNUNET_BIO_WriteHandleGNUNET_BIO_write_open_file (const char *fn)
 Open a file for writing. More...
 
struct GNUNET_BIO_WriteHandleGNUNET_BIO_write_open_buffer (void)
 Create a handle backed by an in-memory buffer. More...
 
int GNUNET_BIO_flush (struct GNUNET_BIO_WriteHandle *h)
 Force a file-based buffered writer to flush its buffer. More...
 
int GNUNET_BIO_get_buffer_contents (struct GNUNET_BIO_WriteHandle *h, char **emsg, void **contents, size_t *size)
 Get the IO handle's contents. More...
 
int GNUNET_BIO_write_close (struct GNUNET_BIO_WriteHandle *h, char **emsg)
 Close an IO handle. More...
 
int GNUNET_BIO_write (struct GNUNET_BIO_WriteHandle *h, const char *what, const void *buffer, size_t n)
 Write a buffer to a handle. More...
 
int GNUNET_BIO_write_string (struct GNUNET_BIO_WriteHandle *h, const char *what, const char *s)
 Write a 0-terminated string. More...
 
int GNUNET_BIO_write_meta_data (struct GNUNET_BIO_WriteHandle *h, const char *what, const struct GNUNET_CONTAINER_MetaData *m)
 Write a metadata container. More...
 
int GNUNET_BIO_write_float (struct GNUNET_BIO_WriteHandle *h, const char *what, float f)
 Write a float. More...
 
int GNUNET_BIO_write_double (struct GNUNET_BIO_WriteHandle *h, const char *what, double f)
 Write a double. More...
 
int GNUNET_BIO_write_int32 (struct GNUNET_BIO_WriteHandle *h, const char *what, int32_t i)
 Write an (u)int32_t. More...
 
int GNUNET_BIO_write_int64 (struct GNUNET_BIO_WriteHandle *h, const char *what, int64_t i)
 Write an (u)int64_t. More...
 
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_object (const char *what, void *result, size_t size)
 Create the specification to read a certain amount of bytes. More...
 
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_string (const char *what, char **result, size_t max_length)
 Create the specification to read a 0-terminated string. More...
 
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_meta_data (const char *what, struct GNUNET_CONTAINER_MetaData **result)
 Create the specification to read a metadata container. More...
 
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_int32 (const char *what, int32_t *i)
 Create the specification to read an (u)int32_t. More...
 
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_int64 (const char *what, int64_t *i)
 Create the specification to read an (u)int64_t. More...
 
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_float (const char *what, float *f)
 Create the specification to read a float. More...
 
struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_double (const char *what, double *f)
 Create the specification to read a double. More...
 
int GNUNET_BIO_read_spec_commit (struct GNUNET_BIO_ReadHandle *h, struct GNUNET_BIO_ReadSpec *rs)
 Execute the read specifications in order. More...
 
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_object (const char *what, void *source, size_t size)
 Create the specification to read some bytes. More...
 
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_string (const char *what, const char *s)
 Create the specification to write a 0-terminated string. More...
 
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_meta_data (const char *what, const struct GNUNET_CONTAINER_MetaData *m)
 Create the specification to write a metadata container. More...
 
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_int32 (const char *what, int32_t *i)
 Create the specification to write an (u)int32_t. More...
 
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_int64 (const char *what, int64_t *i)
 Create the specification to write an (u)int64_t. More...
 
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_float (const char *what, float *f)
 Create the specification to write a float. More...
 
struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_double (const char *what, double *f)
 Create the specification to write an double. More...
 
int GNUNET_BIO_write_spec_commit (struct GNUNET_BIO_WriteHandle *h, struct GNUNET_BIO_WriteSpec *ws)
 Execute the write specifications in order. More...
 

Detailed Description

Buffered binary disk IO (with endianness conversion)

Macro Definition Documentation

◆ GNUNET_BIO_read_spec_end

#define GNUNET_BIO_read_spec_end ( )     { NULL, NULL, NULL, NULL, 0 }

End of specifications marker.

Definition at line 414 of file gnunet_bio_lib.h.

◆ GNUNET_BIO_write_spec_end

#define GNUNET_BIO_write_spec_end ( )     { NULL, NULL, NULL, NULL, 0 }

End of specifications marker.

Definition at line 573 of file gnunet_bio_lib.h.

Typedef Documentation

◆ GNUNET_BIO_ReadHandler

typedef int(* GNUNET_BIO_ReadHandler) (void *cls, struct GNUNET_BIO_ReadHandle *h, const char *what, void *target, size_t target_size)

Function used to deserialize data read from h and store it into target.

Parameters
clsclosure (can be NULL)
hthe IO handle to read from
whatwhat is being read (for error message creation)
targetwhere to store the data
target_sizehow many bytes can be written in target can be 0 if the size is unknown or is not fixed
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 370 of file gnunet_bio_lib.h.

◆ GNUNET_BIO_WriteHandler

typedef int(* GNUNET_BIO_WriteHandler) (void *cls, struct GNUNET_BIO_WriteHandle *h, const char *what, void *source, size_t source_size)

Function used to serialize data from a buffer and write it to h.

Parameters
clsclosure (can be NULL)
hthe IO handle to write to
whatwhat is being written (for error message creation)
sourcethe data to write
source_sizehow many bytes should be written
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 529 of file gnunet_bio_lib.h.

Function Documentation

◆ GNUNET_BIO_read_open_file()

struct GNUNET_BIO_ReadHandle* GNUNET_BIO_read_open_file ( const char *  fn)

Open a file for reading.

Parameters
fnfile name to be opened
Returns
IO handle on success, NULL on error

Definition at line 119 of file bio.c.

120 {
121  struct GNUNET_DISK_FileHandle *fd;
122  struct GNUNET_BIO_ReadHandle *h;
123 
125  if (NULL == fd)
126  return NULL;
128  h->type = IO_FILE;
129  h->buffer = (char *) &h[1];
130  h->size = BIO_BUFFER_SIZE;
131  h->fd = fd;
132  return h;
133 }
#define BIO_BUFFER_SIZE
Size for I/O buffers.
Definition: bio.c:41
@ IO_FILE
The handle uses a file to read/write data.
Definition: bio.c:61
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1235
@ GNUNET_DISK_OPEN_READ
Open the file for reading.
@ GNUNET_DISK_PERM_NONE
Nobody is allowed to do anything to the file.
#define GNUNET_malloc(size)
Wrapper around malloc.
Handle for buffered reading.
Definition: bio.c:74
struct GNUNET_DISK_FileHandle * fd
Handle to a file on disk, if type is IO_FILE.
Definition: bio.c:83
Handle used to access files (and pipes).
int fd
File handle on Unix-like systems.

References BIO_BUFFER_SIZE, GNUNET_DISK_FileHandle::fd, GNUNET_BIO_ReadHandle::fd, GNUNET_DISK_file_open(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_malloc, h, and IO_FILE.

Referenced by deserialize_download_file(), deserialize_publish_file(), deserialize_search_file(), deserialize_search_result(), deserialize_subdownload(), deserialize_unindex_file(), get_read_handle(), load(), load_hostlist_file(), load_state(), read_index_list(), and read_update_information_graph().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read_open_buffer()

struct GNUNET_BIO_ReadHandle* GNUNET_BIO_read_open_buffer ( void *  buffer,
size_t  size 
)

Create a handle from an existing allocated buffer.

Parameters
bufferthe buffer to use as source
sizethe total size in bytes of the buffer
Returns
IO handle on success, NULL on error

Definition at line 144 of file bio.c.

145 {
146  struct GNUNET_BIO_ReadHandle *h;
147 
149  h->type = IO_BUFFER;
150  h->buffer = buffer;
151  h->size = size;
152  return h;
153 }
@ IO_BUFFER
The data is stored entirely in memory.
Definition: bio.c:66
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static unsigned int size
Size of the "table".
Definition: peer.c:67
char * buffer
I/O buffer.
Definition: bio.c:93

References GNUNET_BIO_ReadHandle::buffer, GNUNET_new, h, IO_BUFFER, and size.

◆ GNUNET_BIO_read_close()

int GNUNET_BIO_read_close ( struct GNUNET_BIO_ReadHandle h,
char **  emsg 
)

Close an open handle.

Reports if any errors reading from the file were encountered.

Parameters
hfile handle
emsgset to the error message
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Reports if any errors reading from the file were encountered.

Parameters
hfile handle
emsgset to the (allocated) error message if the handle has an error message, the return value is GNUNET_SYSERR
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 166 of file bio.c.

167 {
168  int err;
169 
170  err = (NULL == h->emsg) ? GNUNET_OK : GNUNET_SYSERR;
171  if (NULL != emsg)
172  *emsg = h->emsg;
173  else
174  GNUNET_free (h->emsg);
175  switch (h->type)
176  {
177  case IO_FILE:
179  break;
180  case IO_BUFFER:
181  break;
182  default:
183  break;
184  }
185  GNUNET_free (h);
186  return err;
187 }
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1306
#define GNUNET_free(ptr)
Wrapper around free.

References GNUNET_BIO_ReadHandle::emsg, GNUNET_DISK_file_close(), GNUNET_free, GNUNET_OK, GNUNET_SYSERR, h, IO_BUFFER, and IO_FILE.

Referenced by deserialize_download_file(), deserialize_file_information(), deserialize_publish_file(), deserialize_search_file(), deserialize_search_result(), deserialize_subdownload(), deserialize_unindex_file(), load(), load_hostlist_file(), load_state(), read_index_list(), and read_update_information_graph().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read()

int GNUNET_BIO_read ( struct GNUNET_BIO_ReadHandle h,
const char *  what,
void *  result,
size_t  len 
)

Read some contents into a buffer.

Parameters
hthe IO handle to read from
whatdescribes what is being read (for error message creation)
resultthe buffer to write the result to
lenthe number of bytes to read
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 287 of file bio.c.

291 {
292  char *dst = result;
293 
294  if (NULL != h->emsg)
295  return GNUNET_SYSERR;
296 
297  if (0 == len)
298  return GNUNET_OK;
299 
300  switch (h->type)
301  {
302  case IO_FILE:
303  return read_from_file (h, what, dst, len);
304  case IO_BUFFER:
305  return read_from_buffer (h, what, dst, len);
306  default:
307  GNUNET_asprintf (&h->emsg,
308  _ ("Invalid handle type while reading `%s'"),
309  what);
310  return GNUNET_SYSERR;
311  }
312 }
static int read_from_buffer(struct GNUNET_BIO_ReadHandle *h, const char *what, char *result, size_t len)
Function used internally to read the content of a buffer into a buffer.
Definition: bio.c:258
static int read_from_file(struct GNUNET_BIO_ReadHandle *h, const char *what, char *result, size_t len)
Function used internally to read the contents of a file into a buffer.
Definition: bio.c:200
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
static int result
Global testing status.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define _(String)
GNU gettext support macro.
Definition: platform.h:177

References _, GNUNET_asprintf(), GNUNET_OK, GNUNET_SYSERR, h, IO_BUFFER, IO_FILE, len, read_from_buffer(), read_from_file(), and result.

Referenced by deserialize_fi_node(), deserialize_publish_file(), deserialize_search(), deserialize_search_result(), deserialize_unindex_file(), GNUNET_BIO_read_int32(), GNUNET_BIO_read_int64(), GNUNET_BIO_read_meta_data(), GNUNET_BIO_read_spec_object(), GNUNET_BIO_read_string(), load(), read_download_request(), and read_index_list().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read_string()

int GNUNET_BIO_read_string ( struct GNUNET_BIO_ReadHandle h,
const char *  what,
char **  result,
size_t  max_length 
)

Read 0-terminated string.

Parameters
hthe IO handle to read from
whatdescribes what is being read (for error message creation)
resultwhere to store the pointer to the (allocated) string (note that *result could be set to NULL as well)
max_lengthmaximum allowed length for the string
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 326 of file bio.c.

330 {
331  char *buf;
332  uint32_t big;
333 
335  _ ("string length"),
336  (int32_t *) &big))
337  {
338  char *tmp = h->emsg;
339  if (NULL != tmp)
340  GNUNET_asprintf (&h->emsg,
341  _ ("%s (while reading `%s')"),
342  tmp,
343  what);
344  else
345  GNUNET_asprintf (&h->emsg,
346  _ ("Error reading length of string `%s'"),
347  what);
348  GNUNET_free (tmp);
349  return GNUNET_SYSERR;
350  }
351  if (0 == big)
352  {
353  *result = NULL;
354  return GNUNET_OK;
355  }
356  if (big > max_length)
357  {
358  GNUNET_asprintf (&h->emsg,
359  _ ("String `%s' longer than allowed (%u > %lu)"),
360  what,
361  big,
362  (unsigned long) max_length);
363  return GNUNET_SYSERR;
364  }
365  buf = GNUNET_malloc (big);
366  *result = buf;
367  buf[--big] = '\0';
368  if (0 == big)
369  return GNUNET_OK;
370  if (GNUNET_OK != GNUNET_BIO_read (h, what, buf, big))
371  {
372  GNUNET_free (buf);
373  *result = NULL;
374  return GNUNET_SYSERR;
375  }
376  return GNUNET_OK;
377 }
static char buf[2048]
int GNUNET_BIO_read_int32(struct GNUNET_BIO_ReadHandle *h, const char *what, int32_t *i)
Read an (u)int32_t.
Definition: bio.c:478
int GNUNET_BIO_read(struct GNUNET_BIO_ReadHandle *h, const char *what, void *result, size_t len)
Read some contents into a buffer.
Definition: bio.c:287

References _, buf, GNUNET_asprintf(), GNUNET_BIO_read(), GNUNET_BIO_read_int32(), GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_SYSERR, h, and result.

Referenced by deserialize_download(), deserialize_fi_node(), deserialize_search(), deserialize_search_result(), deserialize_unindex_file(), GNUNET_BIO_read_spec_string(), load_hostlist_file(), and read_index_list().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read_meta_data()

int GNUNET_BIO_read_meta_data ( struct GNUNET_BIO_ReadHandle h,
const char *  what,
struct GNUNET_CONTAINER_MetaData **  result 
)

Read a metadata container.

Parameters
hhandle to an open file
whatdescribes what is being read (for error message creation)
resultthe buffer to store a pointer to the (allocated) metadata
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 389 of file bio.c.

392 {
393  uint32_t size;
394  char *buf;
396 
398  _ ("metadata length"),
399  (int32_t *) &size))
400  return GNUNET_SYSERR;
401  if (0 == size)
402  {
403  *result = NULL;
404  return GNUNET_OK;
405  }
406  if (MAX_META_DATA < size)
407  {
409  &h->emsg,
410  _ ("Serialized metadata `%s' larger than allowed (%u > %u)"),
411  what,
412  size,
413  MAX_META_DATA);
414  return GNUNET_SYSERR;
415  }
416  buf = GNUNET_malloc (size);
417  if (GNUNET_OK != GNUNET_BIO_read (h, what, buf, size))
418  {
419  GNUNET_free (buf);
420  return GNUNET_SYSERR;
421  }
423  if (NULL == meta)
424  {
425  GNUNET_free (buf);
426  GNUNET_asprintf (&h->emsg, _ ("Failed to deserialize metadata `%s'"), what);
427  return GNUNET_SYSERR;
428  }
429  GNUNET_free (buf);
430  *result = meta;
431  return GNUNET_OK;
432 }
#define MAX_META_DATA
Maximum size allowed for meta data written/read from disk.
Definition: bio.c:47
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_deserialize(const char *input, size_t size)
Deserialize meta-data.
Meta data to associate with a file, directory or namespace.

References _, buf, GNUNET_asprintf(), GNUNET_BIO_read(), GNUNET_BIO_read_int32(), GNUNET_CONTAINER_meta_data_deserialize(), GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_SYSERR, h, MAX_META_DATA, meta, result, and size.

Referenced by deserialize_fi_node(), deserialize_search_result(), and GNUNET_BIO_read_spec_meta_data().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read_float()

int GNUNET_BIO_read_float ( struct GNUNET_BIO_ReadHandle h,
const char *  what,
float *  f 
)

Read a float.

Parameters
hthe IO handle to read from
whatdescribes what is being read (for error message creation)
faddress of float to read

Definition at line 443 of file bio.c.

446 {
447  int32_t *i = (int32_t *) f;
448  return GNUNET_BIO_read_int32 (h, what, i);
449 }

References removetrailingwhitespace::f, GNUNET_BIO_read_int32(), and h.

Here is the call graph for this function:

◆ GNUNET_BIO_read_double()

int GNUNET_BIO_read_double ( struct GNUNET_BIO_ReadHandle h,
const char *  what,
double *  f 
)

Read a double.

Parameters
hthe IO handle to read from
whatdescribes what is being read (for error message creation)
faddress of double to read

Definition at line 460 of file bio.c.

463 {
464  int64_t *i = (int64_t *) f;
465  return GNUNET_BIO_read_int64 (h, what, i);
466 }
int GNUNET_BIO_read_int64(struct GNUNET_BIO_ReadHandle *h, const char *what, int64_t *i)
Read an (u)int64_t.
Definition: bio.c:500

References removetrailingwhitespace::f, GNUNET_BIO_read_int64(), and h.

Here is the call graph for this function:

◆ GNUNET_BIO_read_int32()

int GNUNET_BIO_read_int32 ( struct GNUNET_BIO_ReadHandle h,
const char *  what,
int32_t *  i 
)

Read an (u)int32_t.

Parameters
hthe IO handle to read from
whatdescribes what is being read (for error message creation)
iwhere to store the data
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 478 of file bio.c.

481 {
482  int32_t big;
483 
484  if (GNUNET_OK != GNUNET_BIO_read (h, what, &big, sizeof(int32_t)))
485  return GNUNET_SYSERR;
486  *i = ntohl (big);
487  return GNUNET_OK;
488 }

References GNUNET_BIO_read(), GNUNET_OK, GNUNET_SYSERR, and h.

Referenced by deserialize_download(), deserialize_fi_node(), deserialize_search(), deserialize_search_result(), deserialize_unindex_file(), GNUNET_BIO_read_float(), GNUNET_BIO_read_meta_data(), GNUNET_BIO_read_spec_int32(), GNUNET_BIO_read_string(), load_state(), read_download_request(), and read_update_information_graph().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read_int64()

int GNUNET_BIO_read_int64 ( struct GNUNET_BIO_ReadHandle h,
const char *  what,
int64_t *  i 
)

Read an (u)int64_t.

Parameters
hthe IO handle to read from
whatdescribes what is being read (for error message creation)
iwhere to store the data
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 500 of file bio.c.

503 {
504  int64_t big;
505 
506  if (GNUNET_OK != GNUNET_BIO_read (h, what, &big, sizeof(int64_t)))
507  return GNUNET_SYSERR;
508  *i = GNUNET_ntohll (big);
509  return GNUNET_OK;
510 }
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53

References GNUNET_BIO_read(), GNUNET_ntohll(), GNUNET_OK, GNUNET_SYSERR, and h.

Referenced by deserialize_fi_node(), deserialize_unindex_file(), GNUNET_BIO_read_double(), GNUNET_BIO_read_spec_double(), and read_start_time().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_write_open_file()

struct GNUNET_BIO_WriteHandle* GNUNET_BIO_write_open_file ( const char *  fn)

Open a file for writing.

Parameters
fnname of the file to be opened
Returns
IO handle on success, NULL on error

Definition at line 559 of file bio.c.

560 {
561  struct GNUNET_DISK_FileHandle *fd;
562  struct GNUNET_BIO_WriteHandle *h;
563 
564  fd =
571  if (NULL == fd)
572  return NULL;
574  h->buffer = &h[1];
575  h->size = BIO_BUFFER_SIZE;
576  h->fd = fd;
577  return h;
578 }
@ GNUNET_DISK_OPEN_WRITE
Open the file for writing.
@ GNUNET_DISK_OPEN_TRUNCATE
Truncate file if it exists.
@ GNUNET_DISK_OPEN_CREATE
Create file if it doesn't exist.
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
Handle for buffered writing.
Definition: bio.c:517
struct GNUNET_DISK_FileHandle * fd
Handle to a file on disk, if type is IO_FILE.
Definition: bio.c:526

References BIO_BUFFER_SIZE, GNUNET_DISK_FileHandle::fd, GNUNET_BIO_WriteHandle::fd, GNUNET_DISK_file_open(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_TRUNCATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_malloc, and h.

Referenced by get_write_handle(), get_write_handle_in_dir(), GNUNET_FS_download_sync_(), GST_stats_init(), logger_run(), run(), save(), save_hostlist_file(), save_state(), write_index_list(), and write_update_information_graph().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_write_open_buffer()

struct GNUNET_BIO_WriteHandle* GNUNET_BIO_write_open_buffer ( void  )

Create a handle backed by an in-memory buffer.

Returns
IO handle on success, NULL on error

Definition at line 587 of file bio.c.

588 {
589  struct GNUNET_BIO_WriteHandle *h;
590 
592  h->type = IO_BUFFER;
593  h->buffer = (void *) GNUNET_malloc (sizeof (struct GNUNET_Buffer));
594  return h;
595 }
Common buffer management functions.

References GNUNET_malloc, GNUNET_new, h, and IO_BUFFER.

◆ GNUNET_BIO_flush()

int GNUNET_BIO_flush ( struct GNUNET_BIO_WriteHandle h)

Force a file-based buffered writer to flush its buffer.

If the handle does not use a file, this function returns GNUNET_OK without doing anything.

Parameters
hthe IO handle
Returns
GNUNET_OK upon success. Upon failure GNUNET_SYSERR is returned and the file is closed

Definition at line 655 of file bio.c.

656 {
657  ssize_t ret;
658 
659  if (IO_FILE != h->type)
660  return GNUNET_OK;
661 
662  ret = GNUNET_DISK_file_write (h->fd, h->buffer, h->have);
663  if (ret != (ssize_t) h->have)
664  {
666  h->fd = NULL;
667  GNUNET_free (h->emsg);
668  GNUNET_asprintf (&h->emsg, _ ("Unable to flush buffer to file"));
669  return GNUNET_SYSERR;
670  }
671  h->have = 0;
672  return GNUNET_OK;
673 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:686

References _, GNUNET_asprintf(), GNUNET_DISK_file_close(), GNUNET_DISK_file_write(), GNUNET_free, GNUNET_OK, GNUNET_SYSERR, h, IO_FILE, and ret.

Referenced by GNUNET_BIO_write_close(), and write_to_file().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_get_buffer_contents()

int GNUNET_BIO_get_buffer_contents ( struct GNUNET_BIO_WriteHandle h,
char **  emsg,
void **  contents,
size_t *  size 
)

Get the IO handle's contents.

If the handle doesn't use an in-memory buffer, this function returns GNUNET_SYSERR.

Parameters
hthe IO handle
emsgset to the (allocated) error message if the handle has an error message the return value is GNUNET_SYSERR
contentswhere to store the pointer to the handle's contents
sizewhere to store the size of contents
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 689 of file bio.c.

693 {
694  if (IO_BUFFER != h->type)
695  return GNUNET_SYSERR;
696  if ((NULL == contents) || (NULL == size))
697  return GNUNET_SYSERR;
698  int ret = (NULL != h->emsg) ? GNUNET_SYSERR : GNUNET_OK;
699  if (NULL != emsg)
700  *emsg = h->emsg;
701  else
702  GNUNET_free (h->emsg);
703  *contents = GNUNET_buffer_reap ((struct GNUNET_Buffer *) h->buffer, size);
704  return ret;
705 }
void * GNUNET_buffer_reap(struct GNUNET_Buffer *buf, size_t *size)
Clear the buffer and return its contents.
Definition: buffer.c:149

References GNUNET_BIO_WriteHandle::emsg, GNUNET_buffer_reap(), GNUNET_free, GNUNET_OK, GNUNET_SYSERR, h, IO_BUFFER, ret, and size.

Here is the call graph for this function:

◆ GNUNET_BIO_write_close()

int GNUNET_BIO_write_close ( struct GNUNET_BIO_WriteHandle h,
char **  emsg 
)

Close an IO handle.

If the handle was using a file, the file will be closed.

Parameters
hfile handle
emsgset to the (allocated) error message if the handle has an error message, the return value is GNUNET_SYSERR
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 608 of file bio.c.

609 {
610  int err;
611 
612  err = (NULL == h->emsg) ? GNUNET_OK : GNUNET_SYSERR;
613  if (NULL != emsg)
614  *emsg = h->emsg;
615  else
616  GNUNET_free (h->emsg);
617  switch (h->type)
618  {
619  case IO_FILE:
620  if (NULL == h->fd)
621  return GNUNET_SYSERR;
622  if (GNUNET_OK != GNUNET_BIO_flush (h))
623  {
624  if (NULL != emsg)
625  *emsg = h->emsg;
626  else
627  GNUNET_free (h->emsg);
628  err = GNUNET_SYSERR;
629  }
630  else
631  {
633  }
634  break;
635  case IO_BUFFER:
636  GNUNET_buffer_clear ((struct GNUNET_Buffer *) h->buffer);
637  GNUNET_free (h->buffer);
638  break;
639  }
640  GNUNET_free (h);
641  return err;
642 }
void GNUNET_buffer_clear(struct GNUNET_Buffer *buf)
Free the backing memory of the given buffer.
Definition: buffer.c:164
int GNUNET_BIO_flush(struct GNUNET_BIO_WriteHandle *h)
Force a file-based buffered writer to flush its buffer.
Definition: bio.c:655

References GNUNET_BIO_WriteHandle::emsg, GNUNET_BIO_flush(), GNUNET_buffer_clear(), GNUNET_DISK_file_close(), GNUNET_free, GNUNET_OK, GNUNET_SYSERR, h, IO_BUFFER, and IO_FILE.

Referenced by GNUNET_FS_download_sync_(), GNUNET_FS_file_information_sync_(), GNUNET_FS_publish_sync_(), GNUNET_FS_search_result_sync_(), GNUNET_FS_search_sync_(), GNUNET_FS_unindex_sync_(), GST_stats_destroy(), save(), save_hostlist_file(), save_state(), shutdown_task(), write_index_list(), and write_update_information_graph().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_write()

int GNUNET_BIO_write ( struct GNUNET_BIO_WriteHandle h,
const char *  what,
const void *  buffer,
size_t  n 
)

Write a buffer to a handle.

Parameters
hthe IO handle to write to
whatwhat is being written (for error message creation)
bufferthe data to write
nnumber of bytes to write
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 795 of file bio.c.

799 {
800  const char *src = buffer;
801 
802  if (NULL != h->emsg)
803  return GNUNET_SYSERR;
804 
805  if (0 == n)
806  return GNUNET_OK;
807 
808  switch (h->type)
809  {
810  case IO_FILE:
811  return write_to_file (h, what, src, n);
812  case IO_BUFFER:
813  return write_to_buffer (h, what, src, n);
814  default:
815  GNUNET_asprintf (&h->emsg,
816  _ ("Invalid handle type while writing `%s'"),
817  what);
818  return GNUNET_SYSERR;
819  }
820 }
static int write_to_file(struct GNUNET_BIO_WriteHandle *h, const char *what, const char *source, size_t len)
Function used internally to write the contents of a buffer into a file.
Definition: bio.c:718
static int write_to_buffer(struct GNUNET_BIO_WriteHandle *h, const char *what, const char *source, size_t len)
Function used internally to write the contents of a buffer to another buffer.
Definition: bio.c:774

References _, GNUNET_BIO_WriteHandle::buffer, GNUNET_asprintf(), GNUNET_OK, GNUNET_SYSERR, h, IO_BUFFER, IO_FILE, write_to_buffer(), and write_to_file().

Referenced by copy_from_reader(), GNUNET_BIO_write_int32(), GNUNET_BIO_write_int64(), GNUNET_BIO_write_meta_data(), GNUNET_BIO_write_spec_object(), GNUNET_BIO_write_string(), GNUNET_FS_file_information_sync_(), GNUNET_FS_publish_sync_(), GNUNET_FS_search_result_sync_(), GNUNET_FS_search_sync_(), GNUNET_FS_unindex_sync_(), handle_log_msg(), sample_load_task(), save(), write_download_request(), and write_index_list().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_write_string()

int GNUNET_BIO_write_string ( struct GNUNET_BIO_WriteHandle h,
const char *  what,
const char *  s 
)

Write a 0-terminated string.

Parameters
hthe IO handle to write to
whatwhat is being written (for error message creation)
sstring to write (can be NULL)
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 832 of file bio.c.

835 {
836  uint32_t slen;
837 
838  slen = (uint32_t) ((s == NULL) ? 0 : strlen (s) + 1);
839  if (GNUNET_OK != GNUNET_BIO_write_int32 (h, _ ("string length"), slen))
840  return GNUNET_SYSERR;
841  if (0 != slen)
842  return GNUNET_BIO_write (h, what, s, slen - 1);
843  return GNUNET_OK;
844 }
int GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const char *what, const void *buffer, size_t n)
Write a buffer to a handle.
Definition: bio.c:795
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, const char *what, int32_t i)
Write an (u)int32_t.
Definition: bio.c:936

References _, GNUNET_BIO_write(), GNUNET_BIO_write_int32(), GNUNET_OK, GNUNET_SYSERR, and h.

Referenced by GNUNET_BIO_write_spec_string(), GNUNET_FS_file_information_sync_(), GNUNET_FS_search_sync_(), GNUNET_FS_unindex_sync_(), and write_index_list().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_write_meta_data()

int GNUNET_BIO_write_meta_data ( struct GNUNET_BIO_WriteHandle h,
const char *  what,
const struct GNUNET_CONTAINER_MetaData m 
)

Write a metadata container.

Parameters
hthe IO handle to write to
whatwhat is being written (for error message creation)
mmetadata to write
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 856 of file bio.c.

859 {
860  ssize_t size;
861  char *buf;
862 
863  if (m == NULL)
864  return GNUNET_BIO_write_int32 (h, _ ("metadata length"), 0);
865  buf = NULL;
867  m,
868  &buf,
871  if (-1 == size)
872  {
873  GNUNET_free (buf);
874  GNUNET_free (h->emsg);
875  GNUNET_asprintf (&h->emsg,
876  _ ("Failed to serialize metadata `%s'"),
877  what);
878  return GNUNET_SYSERR;
879  }
881  _ ("metadata length"),
882  (uint32_t) size))
883  || (GNUNET_OK != GNUNET_BIO_write (h, what, buf, size)))
884  {
885  GNUNET_free (buf);
886  return GNUNET_SYSERR;
887  }
888  GNUNET_free (buf);
889  return GNUNET_OK;
890 }
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
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.
@ GNUNET_CONTAINER_META_DATA_SERIALIZE_PART
If not enough space is available, it is acceptable to only serialize some of the metadata.

References _, buf, GNUNET_asprintf(), GNUNET_BIO_write(), GNUNET_BIO_write_int32(), GNUNET_CONTAINER_meta_data_serialize(), GNUNET_CONTAINER_META_DATA_SERIALIZE_PART, GNUNET_free, GNUNET_OK, GNUNET_SYSERR, h, m, MAX_META_DATA, and size.

Referenced by GNUNET_BIO_write_spec_meta_data().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_write_float()

int GNUNET_BIO_write_float ( struct GNUNET_BIO_WriteHandle h,
const char *  what,
float  f 
)

Write a float.

Parameters
hthe IO handle to write to
whatwhat is being written (for error message creation)
ffloat to write (must be a variable)
hthe IO handle to write to
whatwhat is being written (for error message creation)
ffloat to write

Definition at line 901 of file bio.c.

904 {
905  int32_t i = f;
906  return GNUNET_BIO_write_int32 (h, what, i);
907 }

References removetrailingwhitespace::f, GNUNET_BIO_write_int32(), and h.

Here is the call graph for this function:

◆ GNUNET_BIO_write_double()

int GNUNET_BIO_write_double ( struct GNUNET_BIO_WriteHandle h,
const char *  what,
double  f 
)

Write a double.

Parameters
hthe IO handle to write to
whatwhat is being written (for error message creation)
fdouble to write (must be a variable)
hthe IO handle to write to
whatwhat is being written (for error message creation)
fdouble to write

Definition at line 918 of file bio.c.

921 {
922  int64_t i = f;
923  return GNUNET_BIO_write_int64 (h, what, i);
924 }
int GNUNET_BIO_write_int64(struct GNUNET_BIO_WriteHandle *h, const char *what, int64_t i)
Write an (u)int64_t.
Definition: bio.c:956

References removetrailingwhitespace::f, GNUNET_BIO_write_int64(), and h.

Here is the call graph for this function:

◆ GNUNET_BIO_write_int32()

int GNUNET_BIO_write_int32 ( struct GNUNET_BIO_WriteHandle h,
const char *  what,
int32_t  i 
)

Write an (u)int32_t.

Parameters
hthe IO handle to write to
whatwhat is being written (for error message creation)
i32-bit integer to write
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 936 of file bio.c.

939 {
940  int32_t big;
941 
942  big = htonl (i);
943  return GNUNET_BIO_write (h, what, &big, sizeof(int32_t));
944 }

References GNUNET_BIO_write(), and h.

Referenced by GNUNET_BIO_write_float(), GNUNET_BIO_write_meta_data(), GNUNET_BIO_write_spec_int32(), GNUNET_BIO_write_string(), GNUNET_FS_search_sync_(), save_state(), and write_update_information_graph().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_write_int64()

int GNUNET_BIO_write_int64 ( struct GNUNET_BIO_WriteHandle h,
const char *  what,
int64_t  i 
)

Write an (u)int64_t.

Parameters
hthe IO handle to write to
whatwhat is being written (for error message creation)
i64-bit integer to write
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 956 of file bio.c.

959 {
960  int64_t big;
961 
962  big = GNUNET_htonll (i);
963  return GNUNET_BIO_write (h, what, &big, sizeof(int64_t));
964 }
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:36

References GNUNET_BIO_write(), GNUNET_htonll(), and h.

Referenced by GNUNET_BIO_write_double(), GNUNET_BIO_write_spec_double(), GNUNET_FS_file_information_sync_(), handle_p2p_estimate(), and write_start_time().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read_spec_object()

struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_object ( const char *  what,
void *  result,
size_t  len 
)

Create the specification to read a certain amount of bytes.

Parameters
whatdescribes what is being read (for error message creation)
resultthe buffer to write the result to
lenthe number of bytes to read
Returns
the read spec

Definition at line 978 of file bio.c.

1000 {
1001  struct GNUNET_BIO_ReadSpec rs = {
1003  .cls = NULL,
1004  .what = what,
1005  .target = result,
1006  .size = len,
1007  };
1008 
1009  return rs;
1010 }
static int read_spec_handler_object(void *cls, struct GNUNET_BIO_ReadHandle *h, const char *what, void *target, size_t target_size)
Function used internally to read some bytes from within a read spec.
Definition: bio.c:978
Structure specifying a reading operation on an IO handle.
const char * what
What is being read (for error message creation)
GNUNET_BIO_ReadHandler rh
Function performing data deserialization.

References GNUNET_BIO_read(), and h.

Referenced by load_state().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read_spec_string()

struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_string ( const char *  what,
char **  result,
size_t  max_length 
)

Create the specification to read a 0-terminated string.

Parameters
whatdescribes what is being read (for error message creation)
resultwhere to store the pointer to the (allocated) string (note that *result could be set to NULL as well)
max_lengthmaximum allowed length for the string
Returns
the read spec

Definition at line 1024 of file bio.c.

1048 {
1049  struct GNUNET_BIO_ReadSpec rs = {
1051  .cls = NULL,
1052  .target = result,
1053  .size = max_length,
1054  };
1055 
1056  return rs;
1057 }
static int read_spec_handler_string(void *cls, struct GNUNET_BIO_ReadHandle *h, const char *what, void *target, size_t target_size)
Function used internally to read a string from within a read spec.
Definition: bio.c:1024

References GNUNET_BIO_read_string(), h, result, GNUNET_BIO_ReadSpec::target, and GNUNET_BIO_ReadSpec::what.

Referenced by deserialize_download(), deserialize_publish_file(), load_state(), and read_update_information_graph().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read_spec_meta_data()

struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_meta_data ( const char *  what,
struct GNUNET_CONTAINER_MetaData **  result 
)

Create the specification to read a metadata container.

Parameters
whatdescribes what is being read (for error message creation)
resultthe buffer to store a pointer to the (allocated) metadata
Returns
the read spec

Definition at line 1072 of file bio.c.

1093 {
1094  struct GNUNET_BIO_ReadSpec rs = {
1096  .cls = NULL,
1097  .target = result,
1098  .size = 0,
1099  };
1100 
1101  return rs;
1102 }
static int read_spec_handler_meta_data(void *cls, struct GNUNET_BIO_ReadHandle *h, const char *what, void *target, size_t target_size)
Function used internally to read a metadata container from within a read spec.
Definition: bio.c:1072

References GNUNET_BIO_read_meta_data(), h, and result.

Referenced by deserialize_download(), and read_update_information_graph().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read_spec_int32()

struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_int32 ( const char *  what,
int32_t *  i 
)

Create the specification to read an (u)int32_t.

Parameters
whatdescribes what is being read (for error message creation)
iwhere to store the data
Returns
the read spec

Definition at line 1116 of file bio.c.

1137 {
1138  struct GNUNET_BIO_ReadSpec rs = {
1140  .cls = NULL,
1141  .target = i,
1142  .size = 0,
1143  };
1144 
1145  return rs;
1146 }
static int read_spec_handler_int32(void *cls, struct GNUNET_BIO_ReadHandle *h, const char *what, void *target, size_t target_size)
Function used internally to read an (u)int32_t from within a read spec.
Definition: bio.c:1116

References GNUNET_BIO_read_int32(), h, result, GNUNET_BIO_ReadSpec::target, and GNUNET_BIO_ReadSpec::what.

Referenced by deserialize_publish_file(), load_hostlist_file(), and read_download_request().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read_spec_int64()

struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_int64 ( const char *  what,
int64_t *  i 
)

Create the specification to read an (u)int64_t.

Parameters
whatdescribes what is being read (for error message creation)
iwhere to store the data
Returns
the read spec

Definition at line 1160 of file bio.c.

1181 {
1182  struct GNUNET_BIO_ReadSpec rs = {
1184  .cls = NULL,
1185  .target = i,
1186  .size = 0,
1187  };
1188 
1189  return rs;
1190 }
static int read_spec_handler_int64(void *cls, struct GNUNET_BIO_ReadHandle *h, const char *what, void *target, size_t target_size)
Function used internally to read an (u)int64_t from within a read spec.
Definition: bio.c:1160

Referenced by deserialize_download(), load_hostlist_file(), and read_download_request().

Here is the caller graph for this function:

◆ GNUNET_BIO_read_spec_float()

struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_float ( const char *  what,
float *  f 
)

Create the specification to read a float.

Parameters
whatdescribes what is being read (for error message creation)
faddress of float to read

Definition at line 1160 of file bio.c.

1201 {
1202  struct GNUNET_BIO_ReadSpec rs = {
1204  .cls = NULL,
1205  .target = (int32_t *) f,
1206  .size = 0,
1207  };
1208 
1209  return rs;
1210 }

◆ GNUNET_BIO_read_spec_double()

struct GNUNET_BIO_ReadSpec GNUNET_BIO_read_spec_double ( const char *  what,
double *  f 
)

Create the specification to read a double.

Parameters
whatdescribes what is being read (for error message creation)
faddress of double to read

Definition at line 1160 of file bio.c.

1221 {
1222  struct GNUNET_BIO_ReadSpec rs = {
1224  .cls = NULL,
1225  .target = (int64_t *) f,
1226  .size = 0,
1227  };
1228 
1229  return rs;
1230 }

References GNUNET_BIO_read_int64(), h, result, GNUNET_BIO_ReadSpec::target, and GNUNET_BIO_ReadSpec::what.

Here is the call graph for this function:

◆ GNUNET_BIO_read_spec_commit()

int GNUNET_BIO_read_spec_commit ( struct GNUNET_BIO_ReadHandle h,
struct GNUNET_BIO_ReadSpec rs 
)

Execute the read specifications in order.

Parameters
hthe IO handle to read from
rsarray of read specs the last element must be GNUNET_BIO_read_spec_end
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1242 of file bio.c.

1244 {
1245  int ret = GNUNET_OK;
1246 
1247  for (size_t i = 0; NULL!=rs[i].rh; ++i)
1248  {
1249  ret = rs[i].rh (rs[i].cls, h, rs[i].what, rs[i].target, rs[i].size);
1250  if (GNUNET_OK != ret)
1251  return ret;
1252  }
1253 
1254  return ret;
1255 }

References GNUNET_BIO_ReadSpec::cls, GNUNET_OK, h, ret, GNUNET_BIO_ReadSpec::rh, size, GNUNET_BIO_ReadSpec::target, and GNUNET_BIO_ReadSpec::what.

Referenced by deserialize_download(), deserialize_publish_file(), load_hostlist_file(), load_state(), read_download_request(), and read_update_information_graph().

Here is the caller graph for this function:

◆ GNUNET_BIO_write_spec_object()

struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_object ( const char *  what,
void *  source,
size_t  size 
)

Create the specification to read some bytes.

Parameters
whatdescribes what is being written (for error message creation)
sourcethe data to write
sizehow many bytes should be written
Returns
the write spec

Definition at line 1269 of file bio.c.

1291 {
1292  struct GNUNET_BIO_WriteSpec ws = {
1294  .cls = NULL,
1295  .what = what,
1296  .source = source,
1297  .source_size = size,
1298  };
1299 
1300  return ws;
1301 }
static int write_spec_handler_object(void *cls, struct GNUNET_BIO_WriteHandle *h, const char *what, void *source, size_t source_size)
Function used internally to write some bytes from within a write spec.
Definition: bio.c:1269
static GstElement * source
Appsrc instance into which we write data for the pipeline.
Structure specifying a writing operation on an IO handle.
GNUNET_BIO_WriteHandler wh
Function performing data serialization.
const char * what
What is being read (for error message creation)

References GNUNET_BIO_write(), h, source, and GNUNET_BIO_ReadSpec::what.

Referenced by GNUNET_FS_file_information_sync_(), GNUNET_FS_search_result_sync_(), GNUNET_FS_unindex_sync_(), and write_item().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_write_spec_string()

struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_string ( const char *  what,
const char *  s 
)

Create the specification to write a 0-terminated string.

Parameters
whatdescribes what is being read (for error message creation)
sstring to write (can be NULL)
Returns
the read spec

Definition at line 1316 of file bio.c.

1337 {
1338  struct GNUNET_BIO_WriteSpec ws = {
1340  .cls = NULL,
1341  .what = what,
1342  .source = (void *) s,
1343  .source_size = 0,
1344  };
1345 
1346  return ws;
1347 }
static int write_spec_handler_string(void *cls, struct GNUNET_BIO_WriteHandle *h, const char *what, void *source, size_t source_size)
Function used internally to write a 0-terminated string from within a write spec.
Definition: bio.c:1316
size_t source_size
Size of source.

References GNUNET_BIO_write_string(), h, source, and GNUNET_BIO_WriteSpec::what.

Referenced by GNUNET_FS_download_sync_(), GNUNET_FS_file_information_sync_(), GNUNET_FS_publish_sync_(), GNUNET_FS_search_result_sync_(), GNUNET_FS_unindex_sync_(), save_hostlist_file(), write_item(), and write_update_information_graph().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_write_spec_meta_data()

struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_meta_data ( const char *  what,
const struct GNUNET_CONTAINER_MetaData m 
)

Create the specification to write a metadata container.

Parameters
whatwhat is being written (for error message creation)
mmetadata to write
Returns
the write spec

Definition at line 1362 of file bio.c.

1383 {
1384  struct GNUNET_BIO_WriteSpec ws = {
1386  .cls = NULL,
1387  .what = what,
1388  .source = (void *) m,
1389  .source_size = 0,
1390  };
1391 
1392  return ws;
1393 }
static int write_spec_handler_meta_data(void *cls, struct GNUNET_BIO_WriteHandle *h, const char *what, void *source, size_t source_size)
Function used internally to write a metadata container from within a write spec.
Definition: bio.c:1362

References GNUNET_BIO_write_meta_data(), h, m, and source.

Referenced by GNUNET_FS_download_sync_(), GNUNET_FS_file_information_sync_(), GNUNET_FS_search_result_sync_(), and write_update_information_graph().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_write_spec_int32()

struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_int32 ( const char *  what,
int32_t *  i 
)

Create the specification to write an (u)int32_t.

Parameters
whatdescribes what is being written (for error message creation)
ipointer to a 32-bit integer
Returns
the write spec

Definition at line 1407 of file bio.c.

1428 {
1429  struct GNUNET_BIO_WriteSpec ws = {
1431  .cls = NULL,
1432  .what = what,
1433  .source = i,
1434  .source_size = 0,
1435  };
1436 
1437  return ws;
1438 }
static int write_spec_handler_int32(void *cls, struct GNUNET_BIO_WriteHandle *h, const char *what, void *source, size_t source_size)
Function used internally to write an (u)int32_t from within a write spec.
Definition: bio.c:1407

References GNUNET_BIO_write_int32(), h, source, and GNUNET_BIO_WriteSpec::what.

Referenced by GNUNET_FS_download_sync_(), GNUNET_FS_file_information_sync_(), GNUNET_FS_publish_sync_(), GNUNET_FS_search_result_sync_(), GNUNET_FS_unindex_sync_(), save_hostlist_file(), and write_download_request().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_write_spec_int64()

struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_int64 ( const char *  what,
int64_t *  i 
)

Create the specification to write an (u)int64_t.

Parameters
whatdescribes what is being written (for error message creation)
ipointer to a 64-bit integer
Returns
the write spec

Definition at line 1452 of file bio.c.

1473 {
1474  struct GNUNET_BIO_WriteSpec ws = {
1476  .cls = NULL,
1477  .what = what,
1478  .source = i,
1479  .source_size = 0,
1480  };
1481 
1482  return ws;
1483 }
static int write_spec_handler_int64(void *cls, struct GNUNET_BIO_WriteHandle *h, const char *what, void *source, size_t source_size)
Function used internally to write an (u)int64_t from within a write spec.
Definition: bio.c:1452

Referenced by GNUNET_FS_download_sync_(), GNUNET_FS_file_information_sync_(), GNUNET_FS_unindex_sync_(), save_hostlist_file(), and write_download_request().

Here is the caller graph for this function:

◆ GNUNET_BIO_write_spec_float()

struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_float ( const char *  what,
float *  f 
)

Create the specification to write a float.

Parameters
whatdescribes what is being written (for error message creation)
fpointer to a float
Returns
the write spec

Definition at line 1452 of file bio.c.

1495 {
1496  struct GNUNET_BIO_WriteSpec ws = {
1498  .cls = NULL,
1499  .what = what,
1500  .source = (int32_t *) f,
1501  .source_size = 0,
1502  };
1503 
1504  return ws;
1505 }

◆ GNUNET_BIO_write_spec_double()

struct GNUNET_BIO_WriteSpec GNUNET_BIO_write_spec_double ( const char *  what,
double *  f 
)

Create the specification to write an double.

Parameters
whatdescribes what is being written (for error message creation)
fpointer to a double
Returns
the write spec

Definition at line 1452 of file bio.c.

1517 {
1518  struct GNUNET_BIO_WriteSpec ws = {
1520  .cls = NULL,
1521  .what = what,
1522  .source = (int64_t *) f,
1523  .source_size = 0,
1524  };
1525 
1526  return ws;
1527 }

References GNUNET_BIO_write_int64(), h, source, and GNUNET_BIO_WriteSpec::what.

Here is the call graph for this function:

◆ GNUNET_BIO_write_spec_commit()

int GNUNET_BIO_write_spec_commit ( struct GNUNET_BIO_WriteHandle h,
struct GNUNET_BIO_WriteSpec ws 
)

Execute the write specifications in order.

Parameters
hthe IO handle to write to
wsarray of write specs the last element must be GNUNET_BIO_write_spec_end
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1539 of file bio.c.

1541 {
1542  int ret = GNUNET_OK;
1543 
1544  for (size_t i = 0; NULL!=ws[i].wh; ++i)
1545  {
1546  ret = ws[i].wh (ws[i].cls, h, ws[i].what, ws[i].source, ws[i].source_size);
1547  if (GNUNET_OK != ret)
1548  return ret;
1549  }
1550 
1551  /* If it's a file-based handle, the flush makes sure that the data in the
1552  buffer is actually written to the disk. */
1553  if (IO_FILE == h->type)
1554  ret = GNUNET_BIO_flush (h);
1555 
1556  return ret;
1557 }

Referenced by GNUNET_FS_download_sync_(), GNUNET_FS_file_information_sync_(), GNUNET_FS_publish_sync_(), GNUNET_FS_search_result_sync_(), GNUNET_FS_unindex_sync_(), save_hostlist_file(), write_download_request(), write_item(), and write_update_information_graph().

Here is the caller graph for this function: