GNUnet  0.10.x
Macros | Functions
BIO library

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

Macros

#define GNUNET_BIO_read_float(h, f)   (GNUNET_BIO_read_fn(h, __FILE__, __LINE__, f, sizeof(float)))
 Read a float. More...
 
#define GNUNET_BIO_read_double(h, f)   (GNUNET_BIO_read_fn(h, __FILE__, __LINE__, f, sizeof(double)))
 Read a double. More...
 
#define GNUNET_BIO_read_int32(h, i)   GNUNET_BIO_read_int32__(h, __FILE__, __LINE__, (int32_t*)i)
 Read an (u)int32_t. More...
 
#define GNUNET_BIO_read_int64(h, i)   GNUNET_BIO_read_int64__(h, __FILE__, __LINE__, (int64_t*)i)
 Read an (u)int64_t. More...
 
#define GNUNET_BIO_write_float(h, f)   GNUNET_BIO_write(h, &f, sizeof(float))
 Write a float. More...
 
#define GNUNET_BIO_write_double(h, f)   GNUNET_BIO_write(h, &f, sizeof(double))
 Write a double. More...
 

Functions

struct GNUNET_BIO_ReadHandleGNUNET_BIO_read_open (const char *fn)
 Open a file for reading. More...
 
int GNUNET_BIO_read_close (struct GNUNET_BIO_ReadHandle *h, char **emsg)
 Close an open file. More...
 
int GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h, const char *what, void *result, size_t len)
 Read the contents of a binary file into a buffer. More...
 
int GNUNET_BIO_read_fn (struct GNUNET_BIO_ReadHandle *h, const char *file, int line, void *result, size_t len)
 Read the contents of a binary file 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 from a file. More...
 
int GNUNET_BIO_read_meta_data (struct GNUNET_BIO_ReadHandle *h, const char *what, struct GNUNET_CONTAINER_MetaData **result)
 Read metadata container from a file. More...
 
int GNUNET_BIO_read_int32__ (struct GNUNET_BIO_ReadHandle *h, const char *file, int line, int32_t *i)
 Read an (u)int32_t. More...
 
int GNUNET_BIO_read_int64__ (struct GNUNET_BIO_ReadHandle *h, const char *file, int line, int64_t *i)
 Read an (u)int64_t. More...
 
struct GNUNET_BIO_WriteHandleGNUNET_BIO_write_open (const char *fn)
 Open a file for writing. More...
 
int GNUNET_BIO_write_close (struct GNUNET_BIO_WriteHandle *h)
 Close an open file for writing. More...
 
int GNUNET_BIO_write (struct GNUNET_BIO_WriteHandle *h, const void *buffer, size_t n)
 Write a buffer to a file. More...
 
int GNUNET_BIO_flush (struct GNUNET_BIO_WriteHandle *h)
 Force a buffered writer to flush its buffer. More...
 
int GNUNET_BIO_write_string (struct GNUNET_BIO_WriteHandle *h, const char *s)
 Write a string to a file. More...
 
int GNUNET_BIO_write_meta_data (struct GNUNET_BIO_WriteHandle *h, const struct GNUNET_CONTAINER_MetaData *m)
 Write metadata container to a file. More...
 
int GNUNET_BIO_write_int32 (struct GNUNET_BIO_WriteHandle *h, int32_t i)
 Write an (u)int32_t. More...
 
int GNUNET_BIO_write_int64 (struct GNUNET_BIO_WriteHandle *h, int64_t i)
 Write an (u)int64_t. More...
 

Detailed Description

Buffered binary disk IO (with endianess conversion)

Macro Definition Documentation

◆ GNUNET_BIO_read_float

#define GNUNET_BIO_read_float (   h,
 
)    (GNUNET_BIO_read_fn(h, __FILE__, __LINE__, f, sizeof(float)))

Read a float.

Parameters
hhande to open file
faddress of float to read

Definition at line 136 of file gnunet_bio_lib.h.

◆ GNUNET_BIO_read_double

#define GNUNET_BIO_read_double (   h,
 
)    (GNUNET_BIO_read_fn(h, __FILE__, __LINE__, f, sizeof(double)))

Read a double.

Parameters
hhande to open file
faddress of double to read

Definition at line 146 of file gnunet_bio_lib.h.

◆ GNUNET_BIO_read_int32

#define GNUNET_BIO_read_int32 (   h,
 
)    GNUNET_BIO_read_int32__(h, __FILE__, __LINE__, (int32_t*)i)

◆ GNUNET_BIO_read_int64

#define GNUNET_BIO_read_int64 (   h,
 
)    GNUNET_BIO_read_int64__(h, __FILE__, __LINE__, (int64_t*)i)

Read an (u)int64_t.

Parameters
hhande to open file
iaddress of 64-bit integer to read

Definition at line 192 of file gnunet_bio_lib.h.

Referenced by deserialize_download(), deserialize_fi_node(), deserialize_unindex_file(), load_hostlist_file(), read_download_request(), and read_start_time().

◆ GNUNET_BIO_write_float

#define GNUNET_BIO_write_float (   h,
 
)    GNUNET_BIO_write(h, &f, sizeof(float))

Write a float.

Parameters
hhande to open file
ffloat to write (must be a variable)

Definition at line 274 of file gnunet_bio_lib.h.

◆ GNUNET_BIO_write_double

#define GNUNET_BIO_write_double (   h,
 
)    GNUNET_BIO_write(h, &f, sizeof(double))

Write a double.

Parameters
hhande to open file
fdouble to write (must be a variable)

Definition at line 284 of file gnunet_bio_lib.h.

Function Documentation

◆ GNUNET_BIO_read_open()

struct GNUNET_BIO_ReadHandle* GNUNET_BIO_read_open ( 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 93 of file bio.c.

References BIO_BUFFER_SIZE, GNUNET_BIO_ReadHandle::buffer, GNUNET_BIO_ReadHandle::fd, GNUNET_DISK_file_open(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_malloc, h, and GNUNET_BIO_ReadHandle::size.

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

94 {
95  struct GNUNET_DISK_FileHandle *fd;
96  struct GNUNET_BIO_ReadHandle *h;
97 
99  if (NULL == fd)
100  return NULL;
102  h->buffer = (char *)&h[1];
103  h->size = BIO_BUFFER_SIZE;
104  h->fd = fd;
105  return h;
106 }
Open the file for reading.
struct GNUNET_DISK_FileHandle * fd
Underlying file abstraction.
Definition: bio.c:57
Nobody is allowed to do anything to the file.
#define BIO_BUFFER_SIZE
Size for I/O buffers.
Definition: bio.c:41
size_t size
Total size of buffer.
Definition: bio.c:77
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
static char * fn
Filename of the unique file.
char * buffer
I/O buffer.
Definition: bio.c:67
int fd
File handle on Unix-like systems.
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:1262
Handle used to access files (and pipes).
#define GNUNET_malloc(size)
Wrapper around malloc.
Handle for buffered reading.
Definition: bio.c:53
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read_close()

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

Close an open file.

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

Definition at line 118 of file bio.c.

References GNUNET_BIO_ReadHandle::emsg, GNUNET_BIO_ReadHandle::fd, GNUNET_DISK_file_close(), GNUNET_free, GNUNET_free_non_null, GNUNET_OK, and GNUNET_SYSERR.

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

119 {
120  int err;
121 
122  err = (NULL == h->emsg) ? GNUNET_OK : GNUNET_SYSERR;
123  if (emsg != NULL)
124  *emsg = h->emsg;
125  else
128  GNUNET_free(h);
129  return err;
130 }
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1339
struct GNUNET_DISK_FileHandle * fd
Underlying file abstraction.
Definition: bio.c:57
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
char * emsg
Error message, NULL if there were no errors.
Definition: bio.c:62
#define GNUNET_free(ptr)
Wrapper around free.
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 the contents of a binary file into a buffer.

Parameters
hhandle to an open file
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 143 of file bio.c.

References _, GNUNET_BIO_ReadHandle::buffer, GNUNET_BIO_ReadHandle::emsg, GNUNET_BIO_ReadHandle::fd, GNUNET_asprintf(), GNUNET_assert, GNUNET_DISK_file_read(), GNUNET_memcpy, GNUNET_OK, GNUNET_SYSERR, GNUNET_BIO_ReadHandle::have, GNUNET_BIO_ReadHandle::pos, result, ret, and GNUNET_BIO_ReadHandle::size.

Referenced by deserialize_fi_node(), deserialize_publish_file(), deserialize_search(), deserialize_search_result(), deserialize_unindex_file(), GNUNET_BIO_read_fn(), GNUNET_BIO_read_meta_data(), GNUNET_BIO_read_string(), load(), load_state(), read_download_request(), and read_index_list().

147 {
148  char *dst = result;
149  size_t min;
150  size_t pos;
151  ssize_t ret;
152 
153  if (NULL != h->emsg)
154  return GNUNET_SYSERR;
155  pos = 0;
156  do
157  {
158  /* first, use buffer */
159  min = h->have - h->pos;
160  if (min > 0)
161  {
162  if (min > len - pos)
163  min = len - pos;
164  GNUNET_memcpy(&dst[pos], &h->buffer[h->pos], min);
165  h->pos += min;
166  pos += min;
167  }
168  if (pos == len)
169  return GNUNET_OK; /* done! */
170  GNUNET_assert(((off_t)h->have) == h->pos);
171  /* fill buffer */
172  ret = GNUNET_DISK_file_read(h->fd, h->buffer, h->size);
173  if (-1 == ret)
174  {
175  GNUNET_asprintf(&h->emsg,
176  _("Error reading `%s': %s"),
177  what,
178  strerror(errno));
179  return GNUNET_SYSERR;
180  }
181  if (0 == ret)
182  {
183  GNUNET_asprintf(&h->emsg,
184  _("Error reading `%s': %s"),
185  what,
186  _("End of file"));
187  return GNUNET_SYSERR;
188  }
189  h->pos = 0;
190  h->have = ret;
191  }
192  while (pos < len); /* should always be true */
193  return GNUNET_OK;
194 }
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:729
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_DISK_FileHandle * fd
Underlying file abstraction.
Definition: bio.c:57
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
size_t size
Total size of buffer.
Definition: bio.c:77
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
size_t have
Number of bytes available in read buffer.
Definition: bio.c:72
static int result
Global testing status.
char * buffer
I/O buffer.
Definition: bio.c:67
off_t pos
Current read offset in buffer.
Definition: bio.c:82
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
char * emsg
Error message, NULL if there were no errors.
Definition: bio.c:62
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read_fn()

int GNUNET_BIO_read_fn ( struct GNUNET_BIO_ReadHandle h,
const char *  file,
int  line,
void *  result,
size_t  len 
)

Read the contents of a binary file into a buffer.

Parameters
hhandle to an open file
filename of the source file
lineline number in the source file
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 208 of file bio.c.

References GNUNET_BIO_read(), GNUNET_snprintf(), and PATH_MAX.

Referenced by GNUNET_BIO_read_int32__(), and GNUNET_BIO_read_int64__().

213 {
214  char what[PATH_MAX + 1024];
215 
216  GNUNET_snprintf(what, sizeof(what), "%s:%d", file, line);
217  return GNUNET_BIO_read(h, what, result, len);
218 }
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
int GNUNET_BIO_read(struct GNUNET_BIO_ReadHandle *h, const char *what, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: bio.c:143
static char * line
Desired phone line (string to be converted to a hash).
static int result
Global testing status.
#define PATH_MAX
Assumed maximum path length (for source file names).
Definition: bio.c:34
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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 from a file.

Parameters
hhandle to an open file
whatdescribes what is being read (for error message creation)
resultthe buffer to store a pointer to the (allocated) string to (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 232 of file bio.c.

References _, buf, GNUNET_BIO_ReadHandle::emsg, GNUNET_asprintf(), GNUNET_BIO_read(), GNUNET_BIO_read_int32, GNUNET_free, GNUNET_free_non_null, GNUNET_malloc, GNUNET_OK, and GNUNET_SYSERR.

Referenced by deserialize_download(), deserialize_fi_node(), deserialize_publish_file(), deserialize_search(), deserialize_search_result(), deserialize_unindex_file(), load_hostlist_file(), load_state(), read_index_list(), and read_update_information_graph().

236 {
237  char *buf;
238  uint32_t big;
239 
240  if (GNUNET_OK != GNUNET_BIO_read_int32(h, &big))
241  {
243  GNUNET_asprintf(&h->emsg, _("Error reading length of string `%s'"), what);
244  return GNUNET_SYSERR;
245  }
246  if (0 == big)
247  {
248  *result = NULL;
249  return GNUNET_OK;
250  }
251  if (big > max_length)
252  {
253  GNUNET_asprintf(&h->emsg,
254  _("String `%s' longer than allowed (%u > %u)"),
255  what,
256  big,
257  max_length);
258  return GNUNET_SYSERR;
259  }
260  buf = GNUNET_malloc(big);
261  *result = buf;
262  buf[--big] = '\0';
263  if (0 == big)
264  return GNUNET_OK;
265  if (GNUNET_OK != GNUNET_BIO_read(h, what, buf, big))
266  {
267  GNUNET_free(buf);
268  *result = NULL;
269  return GNUNET_SYSERR;
270  }
271  return GNUNET_OK;
272 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
int GNUNET_BIO_read(struct GNUNET_BIO_ReadHandle *h, const char *what, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: bio.c:143
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static char buf[2048]
static int result
Global testing status.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_BIO_read_int32(h, i)
Read an (u)int32_t.
char * emsg
Error message, NULL if there were no errors.
Definition: bio.c:62
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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 metadata container from a file.

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 284 of file bio.c.

References _, buf, GNUNET_BIO_ReadHandle::emsg, GNUNET_asprintf(), GNUNET_BIO_read(), GNUNET_BIO_read_int32, GNUNET_CONTAINER_meta_data_deserialize(), GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_SYSERR, MAX_META_DATA, meta, and GNUNET_BIO_ReadHandle::size.

Referenced by deserialize_download(), deserialize_fi_node(), deserialize_search_result(), and read_update_information_graph().

287 {
288  uint32_t size;
289  char *buf;
291 
292  if (GNUNET_OK != GNUNET_BIO_read_int32(h, (int32_t *)&size))
293  return GNUNET_SYSERR;
294  if (size == 0)
295  {
296  *result = NULL;
297  return GNUNET_OK;
298  }
299  if (size > MAX_META_DATA)
300  {
301  GNUNET_asprintf(&h->emsg,
302  _("Serialized metadata `%s' larger than allowed (%u>%u)"),
303  what,
304  size,
305  MAX_META_DATA);
306  return GNUNET_SYSERR;
307  }
308  buf = GNUNET_malloc(size);
309  if (GNUNET_OK != GNUNET_BIO_read(h, what, buf, size))
310  {
311  GNUNET_free(buf);
312  return GNUNET_SYSERR;
313  }
314  meta = GNUNET_CONTAINER_meta_data_deserialize(buf, size);
315  if (NULL == meta)
316  {
317  GNUNET_free(buf);
318  GNUNET_asprintf(&h->emsg, _("Metadata `%s' failed to deserialize"), what);
319  return GNUNET_SYSERR;
320  }
321  GNUNET_free(buf);
322  *result = meta;
323  return GNUNET_OK;
324 }
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_deserialize(const char *input, size_t size)
Deserialize meta-data.
#define MAX_META_DATA
Maximum size allowed for meta data written/read from disk.
Definition: bio.c:47
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
int GNUNET_BIO_read(struct GNUNET_BIO_ReadHandle *h, const char *what, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: bio.c:143
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
Meta data to associate with a file, directory or namespace.
static char buf[2048]
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:66
#define GNUNET_BIO_read_int32(h, i)
Read an (u)int32_t.
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.
char * emsg
Error message, NULL if there were no errors.
Definition: bio.c:62
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_read_int32__()

int GNUNET_BIO_read_int32__ ( struct GNUNET_BIO_ReadHandle h,
const char *  file,
int  line,
int32_t *  i 
)

Read an (u)int32_t.

Parameters
hhande to open file
filename of the source file
lineline number in the code
iaddress of 32-bit integer to read
Returns
GNUNET_OK on success, GNUNET_SYSERR on error
Parameters
hhande to open file
filename of the source file
lineline number in the source file
iaddress of 32-bit integer to read
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 337 of file bio.c.

References GNUNET_BIO_read_fn(), GNUNET_OK, and GNUNET_SYSERR.

341 {
342  int32_t big;
343 
344  if (GNUNET_OK != GNUNET_BIO_read_fn(h, file, line, &big, sizeof(int32_t)))
345  return GNUNET_SYSERR;
346  *i = ntohl(big);
347  return GNUNET_OK;
348 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static char * line
Desired phone line (string to be converted to a hash).
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int GNUNET_BIO_read_fn(struct GNUNET_BIO_ReadHandle *h, const char *file, int line, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: bio.c:208
Here is the call graph for this function:

◆ GNUNET_BIO_read_int64__()

int GNUNET_BIO_read_int64__ ( struct GNUNET_BIO_ReadHandle h,
const char *  file,
int  line,
int64_t *  i 
)

Read an (u)int64_t.

Parameters
hhande to open file
filename of the source file
lineline number in the code
iaddress of 64-bit integer to read
Returns
GNUNET_OK on success, GNUNET_SYSERR on error
Parameters
hhande to open file
filename of the source file
lineline number in the source file
iaddress of 64-bit integer to read
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 361 of file bio.c.

References GNUNET_BIO_read_fn(), GNUNET_ntohll(), GNUNET_OK, and GNUNET_SYSERR.

365 {
366  int64_t big;
367 
368  if (GNUNET_OK != GNUNET_BIO_read_fn(h, file, line, &big, sizeof(int64_t)))
369  return GNUNET_SYSERR;
370  *i = GNUNET_ntohll(big);
371  return GNUNET_OK;
372 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static char * line
Desired phone line (string to be converted to a hash).
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int GNUNET_BIO_read_fn(struct GNUNET_BIO_ReadHandle *h, const char *file, int line, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: bio.c:208
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
Here is the call graph for this function:

◆ GNUNET_BIO_write_open()

struct GNUNET_BIO_WriteHandle* GNUNET_BIO_write_open ( const char *  fn)

Open a file for writing.

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

Definition at line 408 of file bio.c.

References BIO_BUFFER_SIZE, GNUNET_BIO_WriteHandle::buffer, GNUNET_BIO_ReadHandle::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, h, and GNUNET_BIO_WriteHandle::size.

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

409 {
410  struct GNUNET_DISK_FileHandle *fd;
411  struct GNUNET_BIO_WriteHandle *h;
412 
413  fd =
419  if (NULL == fd)
420  return NULL;
422  h->buffer = (char *)&h[1];
423  h->size = BIO_BUFFER_SIZE;
424  h->fd = fd;
425  return h;
426 }
Create file if it doesn&#39;t exist.
#define BIO_BUFFER_SIZE
Size for I/O buffers.
Definition: bio.c:41
struct GNUNET_DISK_FileHandle * fd
Underlying file handle.
Definition: bio.c:382
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
static char * fn
Filename of the unique file.
Truncate file if it exists.
char * buffer
I/O buffer.
Definition: bio.c:387
Handle for buffered writing.
Definition: bio.c:378
Open the file for writing.
size_t size
Total size of buffer.
Definition: bio.c:397
int fd
File handle on Unix-like systems.
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:1262
Handle used to access files (and pipes).
#define GNUNET_malloc(size)
Wrapper around malloc.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_write_close()

int GNUNET_BIO_write_close ( struct GNUNET_BIO_WriteHandle h)

Close an open file for writing.

Parameters
hfile handle
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise
Parameters
hfile handle
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 436 of file bio.c.

References GNUNET_BIO_WriteHandle::fd, GNUNET_BIO_flush(), GNUNET_DISK_file_close(), GNUNET_free, GNUNET_OK, GNUNET_SYSERR, and ret.

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

437 {
438  int ret;
439 
440  ret = GNUNET_SYSERR;
441  if ((NULL != h->fd) && (GNUNET_OK == (ret = GNUNET_BIO_flush(h))))
443  GNUNET_free(h);
444  return ret;
445 }
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1339
int GNUNET_BIO_flush(struct GNUNET_BIO_WriteHandle *h)
Force a buffered writer to flush its buffer.
Definition: bio.c:456
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_DISK_FileHandle * fd
Underlying file handle.
Definition: bio.c:382
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_free(ptr)
Wrapper around free.
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 void *  buffer,
size_t  n 
)

Write a buffer to a file.

Parameters
hhandle to open file
bufferthe data to write
nnumber of bytes to write
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 481 of file bio.c.

References GNUNET_BIO_ReadHandle::buffer, GNUNET_BIO_WriteHandle::buffer, GNUNET_BIO_WriteHandle::fd, GNUNET_assert, GNUNET_BIO_flush(), GNUNET_break, GNUNET_memcpy, GNUNET_OK, GNUNET_SYSERR, GNUNET_BIO_WriteHandle::have, GNUNET_BIO_ReadHandle::pos, and GNUNET_BIO_WriteHandle::size.

Referenced by copy_from_reader(), GNUNET_BIO_write_int32(), GNUNET_BIO_write_int64(), GNUNET_BIO_write_meta_data(), 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(), write_index_list(), and write_item().

484 {
485  const char *src = buffer;
486  size_t min;
487  size_t pos;
488 
489  if (NULL == h->fd)
490  return GNUNET_SYSERR;
491  pos = 0;
492  do
493  {
494  /* first, just use buffer */
495  min = h->size - h->have;
496  if (min > n - pos)
497  min = n - pos;
498  GNUNET_memcpy(&h->buffer[h->have], &src[pos], min);
499  pos += min;
500  h->have += min;
501  if (pos == n)
502  return GNUNET_OK; /* done */
503  GNUNET_assert(h->have == h->size);
504  if (GNUNET_OK != GNUNET_BIO_flush(h))
505  return GNUNET_SYSERR; /* error */
506  }
507  while (pos < n); /* should always be true */
508  GNUNET_break(0);
509  return GNUNET_OK;
510 }
int GNUNET_BIO_flush(struct GNUNET_BIO_WriteHandle *h)
Force a buffered writer to flush its buffer.
Definition: bio.c:456
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_DISK_FileHandle * fd
Underlying file handle.
Definition: bio.c:382
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
size_t have
Number of bytes already in buffer.
Definition: bio.c:392
char * buffer
I/O buffer.
Definition: bio.c:387
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
size_t size
Total size of buffer.
Definition: bio.c:397
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_flush()

int GNUNET_BIO_flush ( struct GNUNET_BIO_WriteHandle h)

Force a buffered writer to flush its buffer.

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

Definition at line 456 of file bio.c.

References GNUNET_BIO_WriteHandle::buffer, GNUNET_BIO_WriteHandle::fd, GNUNET_DISK_file_close(), GNUNET_DISK_file_write(), GNUNET_OK, GNUNET_SYSERR, GNUNET_BIO_WriteHandle::have, and ret.

Referenced by GNUNET_BIO_write(), and GNUNET_BIO_write_close().

457 {
458  ssize_t ret;
459 
460  ret = GNUNET_DISK_file_write(h->fd, h->buffer, h->have);
461  if (ret != (ssize_t)h->have)
462  {
464  h->fd = NULL;
465  return GNUNET_SYSERR; /* error */
466  }
467  h->have = 0;
468  return GNUNET_OK;
469 }
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1339
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_DISK_FileHandle * fd
Underlying file handle.
Definition: bio.c:382
static int ret
Final status code.
Definition: gnunet-arm.c:89
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:817
size_t have
Number of bytes already in buffer.
Definition: bio.c:392
char * buffer
I/O buffer.
Definition: bio.c:387
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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 *  s 
)

Write a string to a file.

Parameters
hhandle to open file
sstring to write (can be NULL)
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 521 of file bio.c.

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

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_hostlist_file(), write_index_list(), write_item(), and write_update_information_graph().

522 {
523  uint32_t slen;
524 
525  slen = (uint32_t)((s == NULL) ? 0 : strlen(s) + 1);
526  if (GNUNET_OK != GNUNET_BIO_write_int32(h, slen))
527  return GNUNET_SYSERR;
528  if (0 != slen)
529  return GNUNET_BIO_write(h, s, slen - 1);
530  return GNUNET_OK;
531 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, int32_t i)
Write an (u)int32_t.
Definition: bio.c:580
int GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: bio.c:481
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 struct GNUNET_CONTAINER_MetaData m 
)

Write metadata container to a file.

Parameters
hhandle to open file
mmetadata to write
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 542 of file bio.c.

References buf, GNUNET_BIO_write(), GNUNET_BIO_write_int32(), GNUNET_CONTAINER_meta_data_serialize(), GNUNET_CONTAINER_META_DATA_SERIALIZE_PART, GNUNET_free, GNUNET_OK, GNUNET_SYSERR, MAX_META_DATA, and GNUNET_BIO_ReadHandle::size.

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

544 {
545  ssize_t size;
546  char *buf;
547 
548  if (m == NULL)
549  return GNUNET_BIO_write_int32(h, 0);
550  buf = NULL;
552  m,
553  &buf,
556  if (size == -1)
557  {
558  GNUNET_free(buf);
559  return GNUNET_SYSERR;
560  }
561  if ((GNUNET_OK != GNUNET_BIO_write_int32(h, (uint32_t)size)) ||
562  (GNUNET_OK != GNUNET_BIO_write(h, buf, size)))
563  {
564  GNUNET_free(buf);
565  return GNUNET_SYSERR;
566  }
567  GNUNET_free(buf);
568  return GNUNET_OK;
569 }
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.
If not enough space is available, it is acceptable to only serialize some of the metadata.
#define MAX_META_DATA
Maximum size allowed for meta data written/read from disk.
Definition: bio.c:47
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static char buf[2048]
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:66
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, int32_t i)
Write an (u)int32_t.
Definition: bio.c:580
int GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: bio.c:481
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BIO_write_int32()

int GNUNET_BIO_write_int32 ( struct GNUNET_BIO_WriteHandle h,
int32_t  i 
)

Write an (u)int32_t.

Parameters
hhande to open file
i32-bit integer to write
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 580 of file bio.c.

References GNUNET_BIO_write().

Referenced by GNUNET_BIO_write_meta_data(), GNUNET_BIO_write_string(), 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_hostlist_file(), save_state(), write_download_request(), and write_update_information_graph().

581 {
582  int32_t big;
583 
584  big = htonl(i);
585  return GNUNET_BIO_write(h, &big, sizeof(int32_t));
586 }
int GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: bio.c:481
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,
int64_t  i 
)

Write an (u)int64_t.

Parameters
hhande to open file
i64-bit integer to write
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 597 of file bio.c.

References GNUNET_BIO_write(), and GNUNET_htonll().

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

598 {
599  int64_t big;
600 
601  big = GNUNET_htonll(i);
602  return GNUNET_BIO_write(h, &big, sizeof(int64_t));
603 }
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:35
int GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: bio.c:481
Here is the call graph for this function:
Here is the caller graph for this function: