gnunet_bio_lib.h

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2009 GNUnet e.V.
 
     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.
 
     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
 
#include "gnunet_common.h"
#if !defined (__GNUNET_UTIL_LIB_H_INSIDE__)
#error "Only <gnunet_util_lib.h> can be included directly."
#endif
 
#ifndef GNUNET_BIO_LIB_H
#define GNUNET_BIO_LIB_H
 
 
#include "gnunet_container_lib.h"
 
#ifdef __cplusplus
extern "C"
{
#if 0                           /* keep Emacsens' auto-indent happy */
}
#endif
#endif
 
/****************************** READING API *******************************/
 
struct GNUNET_BIO_ReadHandle;
 
 
struct GNUNET_BIO_ReadHandle *
GNUNET_BIO_read_open_file (const char *fn);
 
 
struct GNUNET_BIO_ReadHandle *
GNUNET_BIO_read_open_buffer (void *buffer, size_t size);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_read_close (struct GNUNET_BIO_ReadHandle *h, char **emsg);
 
void
GNUNET_BIO_read_set_error (struct GNUNET_BIO_ReadHandle *h, const char* emsg);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h,
                 const char *what,
                 void *result,
                 size_t len);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_read_string (struct GNUNET_BIO_ReadHandle *h,
                        const char *what,
                        char **result,
                        size_t max_length);
 
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_read_float (struct GNUNET_BIO_ReadHandle *h,
                       const char *what,
                       float *f);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_read_double (struct GNUNET_BIO_ReadHandle *h,
                        const char *what,
                        double *f);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_read_int32 (struct GNUNET_BIO_ReadHandle *h,
                       const char *what,
                       int32_t *i);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_read_int64 (struct GNUNET_BIO_ReadHandle *h,
                       const char *what,
                       int64_t *i);
 
 
/****************************** WRITING API *******************************/
 
struct GNUNET_BIO_WriteHandle;
 
struct GNUNET_BIO_WriteHandle *
GNUNET_BIO_write_open_file (const char *fn);
 
 
struct GNUNET_BIO_WriteHandle *
GNUNET_BIO_write_open_buffer (void);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_flush (struct GNUNET_BIO_WriteHandle *h);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_get_buffer_contents (struct GNUNET_BIO_WriteHandle *h,
                                char **emsg,
                                void **contents,
                                size_t *size);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_write_close (struct GNUNET_BIO_WriteHandle *h, char **emsg);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_write (struct GNUNET_BIO_WriteHandle *h,
                  const char *what,
                  const void *buffer,
                  size_t n);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_write_string (struct GNUNET_BIO_WriteHandle *h,
                         const char *what,
                         const char *s);
 
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_write_float (struct GNUNET_BIO_WriteHandle *h,
                        const char *what,
                        float f);
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_write_double (struct GNUNET_BIO_WriteHandle *h,
                         const char *what,
                         double f);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_write_int32 (struct GNUNET_BIO_WriteHandle *h,
                        const char *what,
                        int32_t i);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_write_int64 (struct GNUNET_BIO_WriteHandle *h,
                        const char *what,
                        int64_t i);
 
 
/****************************** READ SPEC API ***************************/
 
 
typedef int
(*GNUNET_BIO_ReadHandler)(void *cls,
                          struct GNUNET_BIO_ReadHandle *h,
                          const char *what,
                          void *target,
                          size_t target_size);
 
 
struct GNUNET_BIO_ReadSpec
{
  GNUNET_BIO_ReadHandler rh;
 
  void *cls;
 
  const char *what;
 
  void *target;
 
  size_t size;
};
 
 
#define GNUNET_BIO_read_spec_end()              \
  { NULL, NULL, NULL, NULL, 0 }
 
 
struct GNUNET_BIO_ReadSpec
GNUNET_BIO_read_spec_object (const char *what,
                             void *result,
                             size_t size);
 
 
struct GNUNET_BIO_ReadSpec
GNUNET_BIO_read_spec_string (const char *what,
                             char **result,
                             size_t max_length);
 
 
 
struct GNUNET_BIO_ReadSpec
GNUNET_BIO_read_spec_int32 (const char *what,
                            int32_t *i);
 
 
struct GNUNET_BIO_ReadSpec
GNUNET_BIO_read_spec_int64 (const char *what,
                            int64_t *i);
 
 
struct GNUNET_BIO_ReadSpec
GNUNET_BIO_read_spec_float (const char *what, float *f);
 
 
struct GNUNET_BIO_ReadSpec
GNUNET_BIO_read_spec_double (const char *what, double *f);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_read_spec_commit (struct GNUNET_BIO_ReadHandle *h,
                             struct GNUNET_BIO_ReadSpec *rs);
 
 
/******************************* WRITE SPEC API *****************************/
 
 
typedef int
(*GNUNET_BIO_WriteHandler) (void *cls,
                            struct GNUNET_BIO_WriteHandle *h,
                            const char *what,
                            void *source,
                            size_t source_size);
 
 
struct GNUNET_BIO_WriteSpec
{
  GNUNET_BIO_WriteHandler wh;
 
  void *cls;
 
  const char *what;
 
  void *source;
 
  size_t source_size;
};
 
 
#define GNUNET_BIO_write_spec_end()             \
  { NULL, NULL, NULL, NULL, 0 }
 
 
struct GNUNET_BIO_WriteSpec
GNUNET_BIO_write_spec_object (const char *what,
                              void *source,
                              size_t size);
 
 
struct GNUNET_BIO_WriteSpec
GNUNET_BIO_write_spec_string (const char *what,
                              const char *s);
 
 
struct GNUNET_BIO_WriteSpec
GNUNET_BIO_write_spec_int32 (const char *what,
                             int32_t *i);
 
 
struct GNUNET_BIO_WriteSpec
GNUNET_BIO_write_spec_int64 (const char *what,
                             int64_t *i);
 
 
struct GNUNET_BIO_WriteSpec
GNUNET_BIO_write_spec_float (const char *what, float *f);
 
 
struct GNUNET_BIO_WriteSpec
GNUNET_BIO_write_spec_double (const char *what, double *f);
 
 
enum GNUNET_GenericReturnValue
GNUNET_BIO_write_spec_commit (struct GNUNET_BIO_WriteHandle *h,
                              struct GNUNET_BIO_WriteSpec *ws);
 
 
#if 0                           /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif
 
/* ifndef GNUNET_BIO_LIB_H */
#endif
  /* end of group bio */
 /* end of group addition */
 
/* end of gnunet_bio_lib.h */