BIO library

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

Collaboration diagram for BIO library:

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_LIB_H
#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_ReadHandle *	GNUNET_BIO_read_open_file (const char *fn)
	Open a file for reading. More...
struct GNUNET_BIO_ReadHandle *	GNUNET_BIO_read_open_buffer (void *buffer, size_t size)
	Create a handle from an existing allocated buffer. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_read_close (struct GNUNET_BIO_ReadHandle *h, char **emsg)
	Close an open handle. More...
void	GNUNET_BIO_read_set_error (struct GNUNET_BIO_ReadHandle *h, const char *emsg)
	Set read error to handle. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h, const char *what, void *result, size_t len)
	Read some contents into a buffer. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_read_string (struct GNUNET_BIO_ReadHandle *h, const char *what, char **result, size_t max_length)
	Read 0-terminated string. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_read_float (struct GNUNET_BIO_ReadHandle *h, const char *what, float *f)
	Read a float. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_read_double (struct GNUNET_BIO_ReadHandle *h, const char *what, double *f)
	Read a double. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_read_int32 (struct GNUNET_BIO_ReadHandle *h, const char *what, int32_t *i)
	Read an (u)int32_t. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_read_int64 (struct GNUNET_BIO_ReadHandle *h, const char *what, int64_t *i)
	Read an (u)int64_t. More...
struct GNUNET_BIO_WriteHandle *	GNUNET_BIO_write_open_file (const char *fn)
	Open a file for writing. More...
struct GNUNET_BIO_WriteHandle *	GNUNET_BIO_write_open_buffer (void)
	Create a handle backed by an in-memory buffer. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_flush (struct GNUNET_BIO_WriteHandle *h)
	Force a file-based buffered writer to flush its buffer. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_get_buffer_contents (struct GNUNET_BIO_WriteHandle *h, char **emsg, void **contents, size_t *size)
	Get the IO handle's contents. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_write_close (struct GNUNET_BIO_WriteHandle *h, char **emsg)
	Close an IO handle. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_write (struct GNUNET_BIO_WriteHandle *h, const char *what, const void *buffer, size_t n)
	Write a buffer to a handle. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_write_string (struct GNUNET_BIO_WriteHandle *h, const char *what, const char *s)
	Write a 0-terminated string. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_write_float (struct GNUNET_BIO_WriteHandle *h, const char *what, float f)
	Write a float. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_write_double (struct GNUNET_BIO_WriteHandle *h, const char *what, double f)
	Write a double. More...
enum GNUNET_GenericReturnValue	GNUNET_BIO_write_int32 (struct GNUNET_BIO_WriteHandle *h, const char *what, int32_t i)
	Write an (u)int32_t. More...
enum GNUNET_GenericReturnValue	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_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...
enum GNUNET_GenericReturnValue	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_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...
enum GNUNET_GenericReturnValue	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_LIB_H

#define GNUNET_BIO_LIB_H

Definition at line 42 of file gnunet_bio_lib.h.

GNUNET_BIO_read_spec_end

#define GNUNET_BIO_read_spec_end

(

)

{ NULL, NULL, NULL, NULL, 0 }

End of specifications marker.

Definition at line 407 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 555 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

cls	closure (can be NULL)
h	the IO handle to read from
what	what is being read (for error message creation)
target	where to store the data
target_size	how 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 363 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

cls	closure (can be NULL)
h	the IO handle to write to
what	what is being written (for error message creation)
source	the data to write
source_size	how many bytes should be written

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 511 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

fn	file name to be opened

Returns

IO handle on success, NULL on error

Definition at line 114 of file bio.c.

{
  struct GNUNET_DISK_FileHandle *fd;
  struct GNUNET_BIO_ReadHandle *h;
 
  fd = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE);
  if (NULL == fd)
    return NULL;
  h = GNUNET_malloc (sizeof(struct GNUNET_BIO_ReadHandle) + BIO_BUFFER_SIZE);
  h->type = IO_FILE;
  h->buffer = (char *) &h[1];
  h->size = BIO_BUFFER_SIZE;
  h->fd = fd;
  return h;
}

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

buffer	the buffer to use as source
size	the total size in bytes of the buffer

Returns

IO handle on success, NULL on error

Definition at line 139 of file bio.c.

{
  struct GNUNET_BIO_ReadHandle *h;
 
  h = GNUNET_new (struct GNUNET_BIO_ReadHandle);
  h->type = IO_BUFFER;
  h->buffer = buffer;
  h->size = size;
  return h;
}

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

GNUNET_BIO_read_close()

enum GNUNET_GenericReturnValue 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

h	file handle
emsg	set to the error message

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Reports if any errors reading from the file were encountered.

Parameters

h	file handle
emsg	set 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 162 of file bio.c.

{
  int err;
 
  err = (NULL == h->emsg) ? GNUNET_OK : GNUNET_SYSERR;
  if (NULL != emsg)
    *emsg = h->emsg;
  else
    GNUNET_free (h->emsg);
  switch (h->type)
  {
  case IO_FILE:
    GNUNET_DISK_file_close (h->fd);
    break;
  case IO_BUFFER:
    break;
  default:
    break;
  }
  GNUNET_free (h);
  return err;
}

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_set_error()

void GNUNET_BIO_read_set_error	(	struct GNUNET_BIO_ReadHandle *	h,
		const char *	emsg
	)

Set read error to handle.

Parameters

h	the handle
emsg	the message

Definition at line 187 of file bio.c.

{
  GNUNET_assert (NULL == h->emsg);
  h->emsg = GNUNET_strdup (emsg);
}

References GNUNET_BIO_ReadHandle::emsg, GNUNET_assert, GNUNET_strdup, and h.

Referenced by GNUNET_FS_read_meta_data().

Here is the caller graph for this function:

GNUNET_BIO_read()

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

Read some contents into a buffer.

Parameters

h	the IO handle to read from
what	describes what is being read (for error message creation)
result	the buffer to write the result to
len	the number of bytes to read

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 291 of file bio.c.

{
  char *dst = result;
 
  if (NULL != h->emsg)
    return GNUNET_SYSERR;
 
  if (0 == len)
    return GNUNET_OK;
 
  switch (h->type)
  {
  case IO_FILE:
    return read_from_file (h, what, dst, len);
  case IO_BUFFER:
    return read_from_buffer (h, what, dst, len);
  default:
    GNUNET_asprintf (&h->emsg,
                     _ ("Invalid handle type while reading `%s'"),
                     what);
    return GNUNET_SYSERR;
  }
}

References _, GNUNET_asprintf(), GNUNET_OK, GNUNET_SYSERR, h, IO_BUFFER, IO_FILE, 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_string(), GNUNET_FS_read_meta_data(), load(), read_download_request(), read_index_list(), and read_spec_handler_object().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_BIO_read_string()

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

Read 0-terminated string.

Parameters

h	the IO handle to read from
what	describes what is being read (for error message creation)
result	where to store the pointer to the (allocated) string (note that *result could be set to NULL as well)
max_length	maximum allowed length for the string

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 330 of file bio.c.

{
  char *buf;
  uint32_t big;
 
  if (GNUNET_OK != GNUNET_BIO_read_int32 (h,
                                          _ ("string length"),
                                          (int32_t *) &big))
  {
    char *tmp = h->emsg;
    if (NULL != tmp)
      GNUNET_asprintf (&h->emsg,
                       _ ("%s (while reading `%s')"),
                       tmp,
                       what);
    else
      GNUNET_asprintf (&h->emsg,
                       _ ("Error reading length of string `%s'"),
                       what);
    GNUNET_free (tmp);
    return GNUNET_SYSERR;
  }
  if (0 == big)
  {
    *result = NULL;
    return GNUNET_OK;
  }
  if (big > max_length)
  {
    GNUNET_asprintf (&h->emsg,
                     _ ("String `%s' longer than allowed (%u > %lu)"),
                     what,
                     big,
                     (unsigned long) max_length);
    return GNUNET_SYSERR;
  }
  buf = GNUNET_malloc (big);
  *result = buf;
  buf[--big] = '\0';
  if (0 == big)
    return GNUNET_OK;
  if (GNUNET_OK != GNUNET_BIO_read (h, what, buf, big))
  {
    GNUNET_free (buf);
    *result = NULL;
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References _, 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(), load_hostlist_file(), read_index_list(), and read_spec_handler_string().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_BIO_read_float()

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

Read a float.

Parameters

h	the IO handle to read from
what	describes what is being read (for error message creation)
f	address of float to read

Definition at line 392 of file bio.c.

{
  int32_t *i = (int32_t *) f;
  return GNUNET_BIO_read_int32 (h, what, i);
}

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

Here is the call graph for this function:

GNUNET_BIO_read_double()

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

Read a double.

Parameters

h	the IO handle to read from
what	describes what is being read (for error message creation)
f	address of double to read

Definition at line 409 of file bio.c.

{
  int64_t *i = (int64_t *) f;
  return GNUNET_BIO_read_int64 (h, what, i);
}

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

Here is the call graph for this function:

GNUNET_BIO_read_int32()

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

Read an (u)int32_t.

Parameters

h	the IO handle to read from
what	describes what is being read (for error message creation)
i	where to store the data

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 427 of file bio.c.

{
  int32_t big;
 
  if (GNUNET_OK != GNUNET_BIO_read (h, what, &big, sizeof(int32_t)))
    return GNUNET_SYSERR;
  *i = ntohl (big);
  return GNUNET_OK;
}

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_string(), GNUNET_FS_read_meta_data(), load_state(), read_download_request(), read_spec_handler_int32(), 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()

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

Read an (u)int64_t.

Parameters

h	the IO handle to read from
what	describes what is being read (for error message creation)
i	where to store the data

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 449 of file bio.c.

{
  int64_t big;
 
  if (GNUNET_OK != GNUNET_BIO_read (h, what, &big, sizeof(int64_t)))
    return GNUNET_SYSERR;
  *i = GNUNET_ntohll (big);
  return GNUNET_OK;
}

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

Referenced by deserialize_fi_node(), deserialize_unindex_file(), GNUNET_BIO_read_double(), read_spec_handler_int64(), 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

fn	name of the file to be opened

Returns

IO handle on success, NULL on error

Definition at line 508 of file bio.c.

{
  struct GNUNET_DISK_FileHandle *fd;
  struct GNUNET_BIO_WriteHandle *h;
 
  fd = GNUNET_DISK_file_open (fn,
                              GNUNET_DISK_OPEN_WRITE
                              | GNUNET_DISK_OPEN_TRUNCATE
                              | GNUNET_DISK_OPEN_CREATE,
                              GNUNET_DISK_PERM_USER_READ
                              | GNUNET_DISK_PERM_USER_WRITE);
  if (NULL == fd)
    return NULL;
  h = GNUNET_malloc (sizeof(struct GNUNET_BIO_WriteHandle) + BIO_BUFFER_SIZE);
  h->buffer = &h[1];
  h->size = BIO_BUFFER_SIZE;
  h->fd = fd;
  return h;
}

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_(), 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 535 of file bio.c.

{
  struct GNUNET_BIO_WriteHandle *h;
 
  h = GNUNET_new (struct GNUNET_BIO_WriteHandle);
  h->type = IO_BUFFER;
  h->buffer = (void *) GNUNET_malloc (sizeof (struct GNUNET_Buffer));
  return h;
}

References GNUNET_malloc, GNUNET_new, h, and IO_BUFFER.

GNUNET_BIO_flush()

enum GNUNET_GenericReturnValue 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

h	the IO handle

Returns

GNUNET_OK upon success. Upon failure GNUNET_SYSERR is returned and the file is closed

Definition at line 607 of file bio.c.

{
  ssize_t ret;
 
  if (IO_FILE != h->type)
    return GNUNET_OK;
  ret = GNUNET_DISK_file_write (h->fd,
                                h->buffer,
                                h->have);
  if (ret != (ssize_t) h->have)
  {
    GNUNET_DISK_file_close (h->fd);
    h->fd = NULL;
    GNUNET_free (h->emsg);
    GNUNET_asprintf (&h->emsg,
                     "Unable to flush buffer to file");
    return GNUNET_SYSERR;
  }
  h->have = 0;
  return GNUNET_OK;
}

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(), GNUNET_BIO_write_spec_commit(), 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()

enum GNUNET_GenericReturnValue 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

h	the IO handle
emsg	set to the (allocated) error message if the handle has an error message the return value is GNUNET_SYSERR
contents	where to store the pointer to the handle's contents
size	where to store the size of contents

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 643 of file bio.c.

{
  enum GNUNET_GenericReturnValue ret;
  if (IO_BUFFER != h->type)
    return GNUNET_SYSERR;
  if ((NULL == contents) || (NULL == size))
    return GNUNET_SYSERR;
  ret = (NULL != h->emsg) ? GNUNET_SYSERR : GNUNET_OK;
  if (NULL != emsg)
    *emsg = h->emsg;
  else
    GNUNET_free (h->emsg);
  *contents = GNUNET_buffer_reap ((struct GNUNET_Buffer *) h->buffer, size);
  return ret;
}

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()

enum GNUNET_GenericReturnValue 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

h	file handle
emsg	set 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 556 of file bio.c.

{
  int err;
 
  err = (NULL == h->emsg) ? GNUNET_OK : GNUNET_SYSERR;
  if (NULL != emsg)
    *emsg = h->emsg;
  else
    GNUNET_free (h->emsg);
  switch (h->type)
  {
  case IO_FILE:
    if (NULL == h->fd)
    {
      err = GNUNET_SYSERR;
      break;
    }
    if (GNUNET_OK != GNUNET_BIO_flush (h))
    {
      if (NULL != emsg)
        *emsg = h->emsg;
      else
        GNUNET_free (h->emsg);
      err = GNUNET_SYSERR;
    }
    else
    {
      GNUNET_DISK_file_close (h->fd);
    }
    break;
  case IO_BUFFER:
    GNUNET_buffer_clear ((struct GNUNET_Buffer *) h->buffer);
    GNUNET_free (h->buffer);
    break;
  }
  GNUNET_free (h);
  return err;
}

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_(), 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()

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

Write a buffer to a handle.

Parameters

h	the IO handle to write to
what	what is being written (for error message creation)
buffer	the data to write
n	number of bytes to write

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 750 of file bio.c.

{
  const char *src = buffer;
 
  if (NULL != h->emsg)
    return GNUNET_SYSERR;
 
  if (0 == n)
    return GNUNET_OK;
 
  switch (h->type)
  {
  case IO_FILE:
    return write_to_file (h, what, src, n);
  case IO_BUFFER:
    return write_to_buffer (h, what, src, n);
  default:
    GNUNET_asprintf (&h->emsg,
                     _ ("Invalid handle type while writing `%s'"),
                     what);
    return GNUNET_SYSERR;
  }
}

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_string(), GNUNET_FS_file_information_sync_(), GNUNET_FS_publish_sync_(), GNUNET_FS_search_result_sync_(), GNUNET_FS_search_sync_(), GNUNET_FS_unindex_sync_(), GNUNET_FS_write_meta_data(), save(), write_download_request(), write_index_list(), and write_spec_handler_object().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_BIO_write_string()

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

Write a 0-terminated string.

Parameters

h	the IO handle to write to
what	what is being written (for error message creation)
s	string to write (can be NULL)

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 787 of file bio.c.

{
  uint32_t slen;
 
  slen = (uint32_t) ((s == NULL) ? 0 : strlen (s) + 1);
  if (GNUNET_OK != GNUNET_BIO_write_int32 (h, _ ("string length"), slen))
    return GNUNET_SYSERR;
  if (0 != slen)
    return GNUNET_BIO_write (h, what, s, slen - 1);
  return GNUNET_OK;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_BIO_write_float()

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

Write a float.

Parameters

h	the IO handle to write to
what	what is being written (for error message creation)
f	float to write (must be a variable)
h	the IO handle to write to
what	what is being written (for error message creation)
f	float to write

Definition at line 810 of file bio.c.

{
  int32_t i = f;
  return GNUNET_BIO_write_int32 (h, what, i);
}

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

Here is the call graph for this function:

GNUNET_BIO_write_double()

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

Write a double.

Parameters

h	the IO handle to write to
what	what is being written (for error message creation)
f	double to write (must be a variable)
h	the IO handle to write to
what	what is being written (for error message creation)
f	double to write

Definition at line 827 of file bio.c.

{
  int64_t i = f;
  return GNUNET_BIO_write_int64 (h, what, i);
}

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

Here is the call graph for this function:

GNUNET_BIO_write_int32()

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

Write an (u)int32_t.

Parameters

h	the IO handle to write to
what	what is being written (for error message creation)
i	32-bit integer to write

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 845 of file bio.c.

{
  int32_t big;
 
  big = htonl (i);
  return GNUNET_BIO_write (h, what, &big, sizeof(int32_t));
}

References GNUNET_BIO_write(), and h.

Referenced by GNUNET_BIO_write_float(), GNUNET_BIO_write_string(), GNUNET_FS_search_sync_(), GNUNET_FS_write_meta_data(), save_state(), write_spec_handler_int32(), 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()

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

Write an (u)int64_t.

Parameters

h	the IO handle to write to
what	what is being written (for error message creation)
i	64-bit integer to write

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 865 of file bio.c.

{
  int64_t big;
 
  big = GNUNET_htonll (i);
  return GNUNET_BIO_write (h, what, &big, sizeof(int64_t));
}

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

Referenced by GNUNET_BIO_write_double(), GNUNET_FS_file_information_sync_(), handle_p2p_estimate(), write_spec_handler_int64(), 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

what	describes what is being read (for error message creation)
result	the buffer to write the result to
len	the number of bytes to read

Returns

the read spec

Definition at line 906 of file bio.c.

{
  struct GNUNET_BIO_ReadSpec rs = {
    .rh = &read_spec_handler_object,
    .cls = NULL,
    .what = what,
    .target = result,
    .size = len,
  };
 
  return rs;
}

References read_spec_handler_object(), result, GNUNET_BIO_ReadSpec::rh, and GNUNET_BIO_ReadSpec::what.

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

what	describes what is being read (for error message creation)
result	where to store the pointer to the (allocated) string (note that *result could be set to NULL as well)
max_length	maximum allowed length for the string

Returns

the read spec

Definition at line 954 of file bio.c.

{
  struct GNUNET_BIO_ReadSpec rs = {
    .rh = &read_spec_handler_string,
    .cls = NULL,
    .target = result,
    .size = max_length,
  };
 
  return rs;
}

References read_spec_handler_string(), result, and GNUNET_BIO_ReadSpec::rh.

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

what	describes what is being read (for error message creation)
i	where to store the data

Returns

the read spec

Definition at line 999 of file bio.c.

{
  struct GNUNET_BIO_ReadSpec rs = {
    .rh = &read_spec_handler_int32,
    .cls = NULL,
    .target = i,
    .size = 0,
  };
 
  return rs;
}

References read_spec_handler_int32(), and GNUNET_BIO_ReadSpec::rh.

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

what	describes what is being read (for error message creation)
i	where to store the data

Returns

the read spec

Definition at line 1043 of file bio.c.

{
  struct GNUNET_BIO_ReadSpec rs = {
    .rh = &read_spec_handler_int64,
    .cls = NULL,
    .target = i,
    .size = 0,
  };
 
  return rs;
}

References read_spec_handler_int64(), and GNUNET_BIO_ReadSpec::rh.

Referenced by deserialize_download(), 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_float()

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

Create the specification to read a float.

Parameters

what	describes what is being read (for error message creation)
f	address of float to read

Definition at line 1064 of file bio.c.

{
  struct GNUNET_BIO_ReadSpec rs = {
    .rh = &read_spec_handler_int32,
    .cls = NULL,
    .target = (int32_t *) f,
    .size = 0,
  };
 
  return rs;
}

References removetrailingwhitespace::f, read_spec_handler_int32(), GNUNET_BIO_ReadSpec::rh, and size.

Here is the call graph for this function:

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

what	describes what is being read (for error message creation)
f	address of double to read

Definition at line 1084 of file bio.c.

{
  struct GNUNET_BIO_ReadSpec rs = {
    .rh = &read_spec_handler_int64,
    .cls = NULL,
    .target = (int64_t *) f,
    .size = 0,
  };
 
  return rs;
}

References removetrailingwhitespace::f, read_spec_handler_int64(), GNUNET_BIO_ReadSpec::rh, and size.

Here is the call graph for this function:

GNUNET_BIO_read_spec_commit()

enum GNUNET_GenericReturnValue GNUNET_BIO_read_spec_commit	(	struct GNUNET_BIO_ReadHandle *	h,
		struct GNUNET_BIO_ReadSpec *	rs
	)

Execute the read specifications in order.

Parameters

h	the IO handle to read from
rs	array of read specs the last element must be GNUNET_BIO_read_spec_end

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1106 of file bio.c.

{
  int ret = GNUNET_OK;
 
  for (size_t i = 0; NULL!=rs[i].rh; ++i)
  {
    ret = rs[i].rh (rs[i].cls, h, rs[i].what, rs[i].target, rs[i].size);
    if (GNUNET_OK != ret)
      return ret;
  }
 
  return ret;
}

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

what	describes what is being written (for error message creation)
source	the data to write
size	how many bytes should be written

Returns

the write spec

Definition at line 1152 of file bio.c.

{
  struct GNUNET_BIO_WriteSpec ws = {
    .wh = &write_spec_handler_object,
    .cls = NULL,
    .what = what,
    .source = source,
    .source_size = size,
  };
 
  return ws;
}

References size, source, GNUNET_BIO_WriteSpec::wh, GNUNET_BIO_WriteSpec::what, and write_spec_handler_object().

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

what	describes what is being read (for error message creation)
s	string to write (can be NULL)

Returns

the read spec

Definition at line 1199 of file bio.c.

{
  struct GNUNET_BIO_WriteSpec ws = {
    .wh = &write_spec_handler_string,
    .cls = NULL,
    .what = what,
    .source = (void *) s,
    .source_size = 0,
  };
 
  return ws;
}

References GNUNET_BIO_WriteSpec::source_size, GNUNET_BIO_WriteSpec::wh, GNUNET_BIO_WriteSpec::what, and write_spec_handler_string().

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

what	describes what is being written (for error message creation)
i	pointer to a 32-bit integer

Returns

the write spec

Definition at line 1244 of file bio.c.

{
  struct GNUNET_BIO_WriteSpec ws = {
    .wh = &write_spec_handler_int32,
    .cls = NULL,
    .what = what,
    .source = i,
    .source_size = 0,
  };
 
  return ws;
}

References GNUNET_BIO_WriteSpec::wh, GNUNET_BIO_WriteSpec::what, and write_spec_handler_int32().

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

what	describes what is being written (for error message creation)
i	pointer to a 64-bit integer

Returns

the write spec

Definition at line 1289 of file bio.c.

{
  struct GNUNET_BIO_WriteSpec ws = {
    .wh = &write_spec_handler_int64,
    .cls = NULL,
    .what = what,
    .source = i,
    .source_size = 0,
  };
 
  return ws;
}

References GNUNET_BIO_WriteSpec::wh, GNUNET_BIO_WriteSpec::what, and write_spec_handler_int64().

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 call graph for this function:

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

what	describes what is being written (for error message creation)
f	pointer to a float

Returns

the write spec

Definition at line 1312 of file bio.c.

{
  struct GNUNET_BIO_WriteSpec ws = {
    .wh = &write_spec_handler_int32,
    .cls = NULL,
    .what = what,
    .source = (int32_t *) f,
    .source_size = 0,
  };
 
  return ws;
}

References removetrailingwhitespace::f, GNUNET_BIO_WriteSpec::source_size, GNUNET_BIO_WriteSpec::wh, GNUNET_BIO_WriteSpec::what, and write_spec_handler_int32().

Here is the call graph for this function:

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

what	describes what is being written (for error message creation)
f	pointer to a double

Returns

the write spec

Definition at line 1334 of file bio.c.

{
  struct GNUNET_BIO_WriteSpec ws = {
    .wh = &write_spec_handler_int64,
    .cls = NULL,
    .what = what,
    .source = (int64_t *) f,
    .source_size = 0,
  };
 
  return ws;
}

References removetrailingwhitespace::f, GNUNET_BIO_WriteSpec::source_size, GNUNET_BIO_WriteSpec::wh, GNUNET_BIO_WriteSpec::what, and write_spec_handler_int64().

Here is the call graph for this function:

GNUNET_BIO_write_spec_commit()

enum GNUNET_GenericReturnValue GNUNET_BIO_write_spec_commit	(	struct GNUNET_BIO_WriteHandle *	h,
		struct GNUNET_BIO_WriteSpec *	ws
	)

Execute the write specifications in order.

Parameters

h	the IO handle to write to
ws	array of write specs the last element must be GNUNET_BIO_write_spec_end

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 1357 of file bio.c.

{
  int ret = GNUNET_OK;
 
  for (size_t i = 0; NULL!=ws[i].wh; ++i)
  {
    ret = ws[i].wh (ws[i].cls, h, ws[i].what, ws[i].source, ws[i].source_size);
    if (GNUNET_OK != ret)
      return ret;
  }
 
  /* If it's a file-based handle, the flush makes sure that the data in the
     buffer is actually written to the disk. */
  if (IO_FILE == h->type)
    ret = GNUNET_BIO_flush (h);
 
  return ret;
}

References GNUNET_BIO_WriteSpec::cls, GNUNET_BIO_flush(), GNUNET_OK, h, IO_FILE, ret, source, GNUNET_BIO_WriteSpec::source_size, GNUNET_BIO_WriteSpec::wh, 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_download_request(), write_item(), and write_update_information_graph().

Here is the call graph for this function:

Here is the caller graph for this function: