Add peek buffer to io, hide file/buffer private functions

Implements peek buffer on top of the raw io read (with small storage
optimization). Hides implementation details of the file/buffer.

include/bh/buffer.h

@@ -8,8 +8,6 @@ typedef struct bh_buffer_s bh_buffer_t;
 
 bh_buffer_t *bh_buffer_new(void);
 
-void bh_buffer_free(bh_buffer_t *buffer);
-
 const char *bh_buffer_data(bh_buffer_t *buffer);
 
 void bh_buffer_set_data(bh_buffer_t *buffer,
@@ -21,34 +19,8 @@ size_t bh_buffer_capacity(bh_buffer_t *buffer);
 int bh_buffer_reserve(bh_buffer_t *buffer,
                       size_t size);
 
-int bh_buffer_open_base(bh_buffer_t *buffer,
+#define bh_buffer_free(buffer) \
-                        int mode);
+    bh_io_free((bh_io_t *)(buffer))
-
-void bh_buffer_close_base(bh_buffer_t *buffer);
-
-int bh_buffer_is_open_base(bh_buffer_t *buffer);
-
-size_t bh_buffer_read_base(bh_buffer_t *buffer,
-                           char *data,
-                           size_t size);
-
-size_t bh_buffer_write_base(bh_buffer_t *buffer,
-                            const char *data,
-                            size_t size);
-
-void bh_buffer_flush_base(bh_buffer_t *buffer);
-
-int bh_buffer_seek_base(bh_buffer_t *buffer,
-                        bh_off_t pos,
-                        int dir);
-
-bh_off_t bh_buffer_size_base(bh_buffer_t *buffer);
-
-bh_off_t bh_buffer_tell_base(bh_buffer_t *buffer);
-
-bh_off_t bh_buffer_available_base(bh_buffer_t *buffer);
-
-void bh_buffer_clear_base(bh_buffer_t *buffer);
 
 #define bh_buffer_open(buffer, mode) \
     bh_io_open((bh_io_t *)(buffer), (mode))

include/bh/file.h

@@ -8,36 +8,8 @@ typedef struct bh_file_s bh_file_t;
 
 bh_file_t *bh_file_new(const char *path);
 
-void bh_file_free(bh_file_t *file);
+#define bh_file_free(file) \
-
+    bh_io_free((bh_io_t *)(file))
-int bh_file_open_base(bh_file_t *file,
-                      int mode);
-
-void bh_file_close_base(bh_file_t *file);
-
-int bh_file_is_open_base(bh_file_t *file);
-
-size_t bh_file_read_base(bh_file_t *file,
-                         char *data,
-                         size_t size);
-
-size_t bh_file_write_base(bh_file_t *file,
-                          const char *data,
-                          size_t size);
-
-void bh_file_flush_base(bh_file_t *file);
-
-int bh_file_seek_base(bh_file_t *file,
-                      bh_off_t pos,
-                      int dir);
-
-bh_off_t bh_file_size_base(bh_file_t *file);
-
-bh_off_t bh_file_tell_base(bh_file_t *file);
-
-bh_off_t bh_file_available_base(bh_file_t *file);
-
-void bh_file_clear_base(bh_file_t *file);
 
 #define bh_file_open(file, mode) \
     bh_io_open((bh_io_t *)(file), (mode))
@@ -51,6 +23,9 @@ void bh_file_clear_base(bh_file_t *file);
 #define bh_file_read(file, data, size) \
     bh_io_read((bh_io_t *)(file), (data), (size))
 
+#define bh_file_peek(file, data, size) \
+    bh_io_peek((bh_io_t *)(file), (data), (size))
+
 #define bh_file_write(file, data, size) \
     bh_io_write((bh_io_t *)(file), (data), (size))
 

include/bh/internal/buffer.h

@@ -16,6 +16,38 @@ struct bh_buffer_s
 
 int bh_buffer_init(bh_buffer_t *buffer);
 
-void bh_buffer_destroy(bh_buffer_t *buffer);
+#define bh_buffer_destroy(buffer) \
+    bh_io_destroy((bh_io_t *)(buffer))
+
+void bh_buffer_destroy_base(bh_buffer_t *buffer);
+
+int bh_buffer_open_base(bh_buffer_t *buffer,
+                        int mode);
+
+void bh_buffer_close_base(bh_buffer_t *buffer);
+
+int bh_buffer_is_open_base(bh_buffer_t *buffer);
+
+size_t bh_buffer_read_base(bh_buffer_t *buffer,
+                           char *data,
+                           size_t size);
+
+size_t bh_buffer_write_base(bh_buffer_t *buffer,
+                            const char *data,
+                            size_t size);
+
+void bh_buffer_flush_base(bh_buffer_t *buffer);
+
+int bh_buffer_seek_base(bh_buffer_t *buffer,
+                        bh_off_t pos,
+                        int dir);
+
+bh_off_t bh_buffer_size_base(bh_buffer_t *buffer);
+
+bh_off_t bh_buffer_tell_base(bh_buffer_t *buffer);
+
+bh_off_t bh_buffer_available_base(bh_buffer_t *buffer);
+
+void bh_buffer_clear_base(bh_buffer_t *buffer);
 
 #endif /* BH_INTERNAL_BUFFER_H */

include/bh/internal/file.h

@@ -16,6 +16,38 @@
 int bh_file_init(bh_file_t *file,
                  const char *path);
 
-void bh_file_destroy(bh_file_t *file);
+#define bh_file_destroy(file) \
+    bh_io_destroy((bh_io_t *)(file))
+
+void bh_file_destroy_base(bh_file_t *file);
+
+int bh_file_open_base(bh_file_t *file,
+                      int mode);
+
+void bh_file_close_base(bh_file_t *file);
+
+int bh_file_is_open_base(bh_file_t *file);
+
+size_t bh_file_read_base(bh_file_t *file,
+                         char *data,
+                         size_t size);
+
+size_t bh_file_write_base(bh_file_t *file,
+                          const char *data,
+                          size_t size);
+
+void bh_file_flush_base(bh_file_t *file);
+
+int bh_file_seek_base(bh_file_t *file,
+                      bh_off_t pos,
+                      int dir);
+
+bh_off_t bh_file_size_base(bh_file_t *file);
+
+bh_off_t bh_file_tell_base(bh_file_t *file);
+
+bh_off_t bh_file_available_base(bh_file_t *file);
+
+void bh_file_clear_base(bh_file_t *file);
 
 #endif /* BH_INTERNAL_FILE_H */

include/bh/internal/io.h

@@ -4,10 +4,4 @@
 #include "bh.h"
 #include <bh/io.h>
 
-void bh_io_init(bh_io_t *io,
-                const bh_io_table_t *table);
-
-void bh_io_destroy(bh_io_t *io);
-
 #endif /* BH_INTERNAL_IO_H */
-

include/bh/io.h

@@ -5,6 +5,7 @@
 
 #define BH_IO_ERROR         0x0001
 #define BH_IO_EOF           0x0002
+#define BH_IO_UNIFIED       0x0004
 
 #define BH_IO_NONE          0x0000
 #define BH_IO_READ          0x0001
@@ -63,13 +64,30 @@ typedef struct bh_io_s
 {
     const bh_io_table_t *table;
     int flags;
+    struct
+    {
+        char *data;
+        size_t head;
+        size_t tail;
+        size_t size;
+        size_t capacity;
+    } buffer;
 } bh_io_t;
 
-bh_io_t *bh_io_new(bh_io_table_t *table,
+void bh_io_destroy_base(bh_io_t *io);
-                   size_t size);
+
+bh_io_t *bh_io_new(const bh_io_table_t *table,
+                   size_t size,
+                   int unified);
 
 void bh_io_free(bh_io_t *io);
 
+void bh_io_init(bh_io_t *io,
+                const bh_io_table_t *table,
+                int unified);
+
+void bh_io_destroy(bh_io_t *io);
+
 int bh_io_open(bh_io_t *io,
                int mode);
 
@@ -81,6 +99,9 @@ size_t bh_io_read(bh_io_t *io,
                   char *data,
                   size_t size);
 
+size_t bh_io_peek(bh_io_t *io,
+                  char *data,
+                  size_t size);
 
 size_t bh_io_write(bh_io_t *io,
                    const char* data,
@@ -97,7 +118,6 @@ bh_off_t bh_io_size(bh_io_t *io);
 
 bh_off_t bh_io_tell(bh_io_t *io);
 
-
 bh_off_t bh_io_available(bh_io_t *io);
 
 int bh_io_error(bh_io_t *io);

src/buffer.c

@@ -15,7 +15,7 @@ static const bh_io_table_t bh_buffer_table = {
     (bh_off_t (*)(struct bh_io_s *)) bh_buffer_tell_base,
     (bh_off_t (*)(struct bh_io_s *)) bh_buffer_available_base,
     (void (*)(struct bh_io_s *)) bh_buffer_clear_base,
-    (void (*)(struct bh_io_s *)) bh_buffer_destroy
+    (void (*)(struct bh_io_s *)) bh_buffer_destroy_base
 };
 
 bh_buffer_t *bh_buffer_new(void)
@@ -34,17 +34,10 @@ bh_buffer_t *bh_buffer_new(void)
     return result;
 }
 
-void bh_buffer_free(bh_buffer_t *buffer)
-{
-    /* Destroy buffer and free the memory */
-    bh_buffer_destroy(buffer);
-    free(buffer);
-}
-
 int bh_buffer_init(bh_buffer_t *buffer)
 {
     /* Initialize underlying io object */
-    bh_io_init(&buffer->base, &bh_buffer_table);
+    bh_io_init(&buffer->base, &bh_buffer_table, 1);
 
     /* Setup internal information */
     buffer->data = NULL;
@@ -56,12 +49,13 @@ int bh_buffer_init(bh_buffer_t *buffer)
     return BH_OK;
 }
 
-void bh_buffer_destroy(bh_buffer_t *buffer)
+void bh_buffer_destroy_base(bh_buffer_t *buffer)
 {
     /* Close the buffer and free allocated memory */
     bh_buffer_close(buffer);
     if (buffer->data)
         free(buffer->data);
+    bh_io_destroy_base(&buffer->base);
 }
 
 const char *bh_buffer_data(bh_buffer_t *buffer)

src/file_null.c

@@ -21,19 +21,6 @@ bh_file_t *bh_file_new(const char *path)
     return NULL;
 }
 
-/**
- * Frees the \a file object.
- *
- * Before freeing the file object, this function ensures that underlying file
- * was closed.
- *
- * \param file  Pointer to the file object
- */
-void bh_file_free(bh_file_t *file)
-{
-    (void)file;
-}
-
 /**
  * Initializes the \a file object with specified \a path to file.
  *
@@ -59,7 +46,7 @@ int bh_file_init(bh_file_t *file,
  *
  * \param file  Pointer to the file object
  */
-void bh_file_destroy(bh_file_t *file)
+void bh_file_destroy_base(bh_file_t *file)
 {
     (void)file;
 }

src/file_posix.c

@@ -19,7 +19,7 @@ static const bh_io_table_t bh_file_table = {
     (bh_off_t (*)(struct bh_io_s *)) bh_file_tell_base,
     (bh_off_t (*)(struct bh_io_s *)) bh_file_available_base,
     (void (*)(struct bh_io_s *)) bh_file_clear_base,
-    (void (*)(struct bh_io_s *)) bh_file_destroy
+    (void (*)(struct bh_io_s *)) bh_file_destroy_base
 };
 
 bh_file_t *bh_file_new(const char *path)
@@ -38,12 +38,6 @@ bh_file_t *bh_file_new(const char *path)
     return result;
 }
 
-void bh_file_free(bh_file_t *file)
-{
-    bh_file_destroy(file);
-    free(file);
-}
-
 int bh_file_init(bh_file_t *file,
                  const char *path)
 {
@@ -51,8 +45,8 @@ int bh_file_init(bh_file_t *file,
     if (!path)
         return BH_INVALID;
 
-    /* Initialize base io object */
+    /* Initialize underlying io object */
-    bh_io_init(&file->base, &bh_file_table);
+    bh_io_init(&file->base, &bh_file_table, 1);
 
     /* Initialize file io object */
     file->handle = -1;
@@ -62,11 +56,12 @@ int bh_file_init(bh_file_t *file,
     return BH_OK;
 }
 
-void bh_file_destroy(bh_file_t *file)
+void bh_file_destroy_base(bh_file_t *file)
 {
     /* Close the file */
     bh_file_close(file);
     free(file->path);
+    bh_io_destroy_base(&file->base);
 }
 
 int bh_file_open_base(bh_file_t *file,

src/file_win.c

@@ -12,7 +12,7 @@ static const bh_io_table_t bh_file_table = {
     (bh_off_t (*)(struct bh_io_s *)) bh_file_tell_base,
     (bh_off_t (*)(struct bh_io_s *)) bh_file_available_base,
     (void (*)(struct bh_io_s *)) bh_file_clear_base,
-    (void (*)(struct bh_io_s *)) bh_file_destroy
+    (void (*)(struct bh_io_s *)) bh_file_destroy_base
 };
 
 bh_file_t *bh_file_new(const char *path)
@@ -31,13 +31,6 @@ bh_file_t *bh_file_new(const char *path)
     return result;
 }
 
-void bh_file_free(bh_file_t *file)
-{
-    /* Destroy file object and free allocated memory */
-    bh_file_destroy(file);
-    free(file);
-}
-
 int bh_file_init(bh_file_t *file,
                  const char *path)
 {
@@ -45,20 +38,23 @@ int bh_file_init(bh_file_t *file,
     if (!path)
         return BH_INVALID;
 
+    /* Initialize underlying io object */
+    bh_io_init(&file->base, &bh_file_table, 1);
+
     /* Fill file structure information */
     file->handle = INVALID_HANDLE_VALUE;
     file->mode = BH_IO_NONE;
     file->path = strdup(path);
-    file->base.table = &bh_file_table;
 
     return BH_OK;
 }
 
-void bh_file_destroy(bh_file_t *file)
+void bh_file_destroy_base(bh_file_t *file)
 {
     /* Close the file and free allocated memory */
     bh_file_close(file);
     free(file->path);
+    bh_io_destroy_base(&file->base);
 }
 
 int bh_file_open_base(bh_file_t *file,

src/io.c

@@ -1,5 +1,8 @@
 #include <bh/internal/io.h>
 #include <stdlib.h>
+#include <string.h>
+
+#define BH_IO_BUFFER_STEP 256
 
 /**
  * \defgroup io Input/Output
@@ -8,11 +11,339 @@
  * \{
  */
 
+/**
+ * \internal
+ * Returns pointer to the \a io peek buffer.
+ *
+ * \param io    Pointer to the io object
+ *
+ * \return Pointer to the peek buffer.
+ *
+ * \warning Always use this function to get data of the buffer!
+ */
+static char *bh_io_buffer_data(bh_io_t *io)
+{
+    if (io->buffer.capacity)
+        return io->buffer.data;
+
+    return (char *)&io->buffer.data;
+}
+
+/**
+ * \internal
+ * Returns peek buffer capacity of the /a io object.
+ *
+ * \param io    Pointer to the io object
+ *
+ * \return Peek buffer capacity.
+ *
+ * \warning Always use this function to get capacity of the buffer!
+ */
+static size_t bh_io_buffer_capacity(bh_io_t *io)
+{
+    if (io->buffer.capacity)
+        return io->buffer.capacity;
+    return sizeof(char *);
+}
+
+/**
+ * \internal
+ * Reduces the capacity of the \a io object peek buffer.
+ *
+ * \param io    Pointer to the io object.
+ *
+ * \note This function does not guarantee that the capacity of the buffer will
+ *       actually be reduced.
+ */
+static void bh_io_buffer_shrink(bh_io_t *io)
+{
+    size_t capacity;
+    char *data;
+
+    /* Check if buffer is allocated */
+    if (!io->buffer.capacity)
+        return;
+
+    /* Calculate new capacity and check against old capacity */
+    capacity = (io->buffer.size + BH_IO_BUFFER_STEP - 1) / BH_IO_BUFFER_STEP;
+    capacity *= BH_IO_BUFFER_STEP;
+    if (io->buffer.capacity >= capacity)
+        return;
+
+    /* Allocate new buffer space */
+    data = malloc(capacity);
+    if (!data)
+        return;
+
+    /* Copy data */
+    if (io->buffer.size)
+    {
+        size_t block;
+
+        /* Depending on the tail-head positions copy data in two or one go */
+        if (io->buffer.tail <= io->buffer.head)
+        {
+            block = io->buffer.capacity - io->buffer.head;
+            memmove(data, io->buffer.data + io->buffer.head, block);
+            memmove(data + block, io->buffer.data, io->buffer.size - block);
+        }
+        else
+        {
+            block = io->buffer.size;
+            memmove(data, io->buffer.data + io->buffer.head, block);
+        }
+    }
+
+    /* Update fields */
+    free(io->buffer.data);
+    io->buffer.data = data;
+    io->buffer.head = 0;
+    io->buffer.tail = io->buffer.size;
+    io->buffer.capacity = capacity;
+    if (io->buffer.tail >= capacity)
+        io->buffer.tail = 0;
+}
+
+/**
+ * \internal
+ * Reserves the capacity of the \a io object peek buffer.
+ *
+ * \param io    Pointer to the io object
+ * \param size  New peek buffer capacity
+ *
+ * \return On success, returns zero value.
+ * \return On failure, returns error code.
+ */
+static int bh_io_buffer_reserve(bh_io_t *io,
+                                size_t size)
+{
+    size_t capacity;
+    char *data;
+
+    /* Check if entire buffer can fit into a pointer */
+    if (size <= sizeof(char *))
+        return BH_OK;
+
+    /* Check that size can fit into a buffer */
+    if (io->buffer.capacity >= size)
+        return BH_OK;
+
+    /* Calculate new buffer capacity */
+    capacity = (size + BH_IO_BUFFER_STEP - 1) / BH_IO_BUFFER_STEP;
+    capacity *= BH_IO_BUFFER_STEP;
+
+    /* Allocate new buffer space */
+    data = malloc(capacity);
+    if (!data)
+        return BH_OOM;
+
+    /* Copy data */
+    if (io->buffer.size)
+    {
+        size_t block;
+
+        /* Depending on the tail-head positions copy data in two or one go */
+        if (io->buffer.tail <= io->buffer.head)
+        {
+            block = io->buffer.capacity - io->buffer.head;
+            memmove(data, bh_io_buffer_data(io) + io->buffer.head, block);
+            memmove(data + block, bh_io_buffer_data(io), io->buffer.size - block);
+        }
+        else
+        {
+            block = io->buffer.size;
+            memmove(data, bh_io_buffer_data(io) + io->buffer.head, block);
+        }
+    }
+
+    /* Update fields */
+    if (io->buffer.capacity)
+        free(io->buffer.data);
+    io->buffer.data = data;
+    io->buffer.head = 0;
+    io->buffer.tail = io->buffer.size;
+    io->buffer.capacity = capacity;
+    if (io->buffer.tail >= capacity)
+        io->buffer.tail = 0;
+
+    return BH_OK;
+}
+
+/**
+ * \internal
+ * Reads data from the \a io peek buffer.
+ *
+ * \param io    Pointer to the io object
+ * \param data  Pointer to the memory buffer
+ * \param size  Maximum number of bytes to be read
+ * \param peek  Reading or peeking flag
+ *
+ * \return On success, returns number of bytes successfuly read.
+ * \return On failure, returns zero.
+ */
+static size_t bh_io_buffer_read(bh_io_t *io,
+                                char *data,
+                                size_t size,
+                                int peek)
+{
+    size_t block;
+
+    /* Check if buffer is empty */
+    if (!io->buffer.size)
+        return 0;
+
+    /* Reading size can't be bigger then buffer size */
+    if (size > io->buffer.size)
+        size = io->buffer.size;
+
+    /* Copy data */
+    if (data)
+    {
+        /* Depending on the tail-head positions copy data in two or one go */
+        if (io->buffer.tail <= io->buffer.head)
+        {
+            block = bh_io_buffer_capacity(io) - io->buffer.head;
+            if (block > size)
+                block = size;
+            memmove(data, bh_io_buffer_data(io) + io->buffer.head, block);
+            memmove(data + block, bh_io_buffer_data(io), size - block);
+        }
+        else
+        {
+            block = size;
+            memmove(data, bh_io_buffer_data(io) + io->buffer.head, block);
+        }
+    }
+
+    /* Adjust head position and size if we are not peeking */
+    if (!peek)
+    {
+        io->buffer.head += size;
+        io->buffer.size -= size;
+
+        if (io->buffer.head >= bh_io_buffer_capacity(io))
+            io->buffer.head -= bh_io_buffer_capacity(io);
+
+        /* Shrink buffer if neccesary*/
+        bh_io_buffer_shrink(io);
+    }
+
+    /* Return readed size */
+    return size;
+}
+
+/**
+ * \internal
+ * Writes data to the \a io peek buffer.
+ *
+ * \param io    Pointer to the io object
+ * \param data  Pointer to the memory buffer
+ * \param size  Maximum number of bytes to be read
+ *
+ * \return On success, returns number of bytes successfuly written.
+ * \return On failure, returns zero.
+ */
+static size_t bh_io_buffer_write(bh_io_t *io,
+                                 const char *data,
+                                 size_t size)
+{
+    size_t block;
+
+    /* Reserve capacity in the buffer */
+    if (bh_io_buffer_reserve(io, io->buffer.size + size))
+        return 0;
+
+    /* Depending on the tail-head positions copy data in two or one go */
+    if (io->buffer.tail + size > bh_io_buffer_capacity(io))
+    {
+        block = io->buffer.capacity - io->buffer.tail;
+        memmove(bh_io_buffer_data(io) + io->buffer.tail, data, block);
+        memmove(bh_io_buffer_data(io), data + block, size - block);
+    }
+    else
+    {
+        block = size;
+        memmove(bh_io_buffer_data(io) + io->buffer.tail, data, block);
+    }
+
+    /* Adjust tail and size */
+    io->buffer.tail += size;
+    io->buffer.size += size;
+
+    if (io->buffer.tail >= bh_io_buffer_capacity(io))
+        io->buffer.tail -= bh_io_buffer_capacity(io);
+
+    return size;
+}
+
+/**
+ * \internal
+ * Adjusts \a io object peek buffer according to the specified seek direction
+ * \a dir and \a offset.
+ *
+ * \param io        Pointer to the io object
+ * \param offset    Number of bytes to seek in specified direciton
+ * \param dir       Seeking direction
+ *
+ * \return Returns new offset for the io seek function.
+ */
+static bh_off_t bh_io_buffer_seek(bh_io_t *io,
+                                  bh_off_t offset,
+                                  int dir)
+{
+    /* Check if seek is relative to current position */
+    if (dir != BH_IO_CURRENT)
+    {
+        /* It's not - reset peek buffer and return offset as is */
+        io->buffer.size = 0;
+        io->buffer.head = 0;
+        io->buffer.tail = 0;
+        return offset;
+    }
+
+    /* If offset is negative or past peek buffer size */
+    if (offset < 0 || offset >= (bh_off_t)io->buffer.size)
+    {
+        /* It's not - reset peek buffer and adjust offset position */
+        offset -= io->buffer.size;
+        io->buffer.size = 0;
+        io->buffer.head = 0;
+        io->buffer.tail = 0;
+        return offset;
+    }
+
+    /* Skip offset amount of bytes */
+    bh_io_buffer_read(io, NULL, offset, 0);
+    return 0;
+}
+
+/**
+ * Destroys base io object.
+ *
+ * \param io    Pointer to the base io object
+ *
+ * \warning This function should be used in context of implementing child
+ *          io objects (files, sockets, streaming compression, etc).
+ */
+void bh_io_destroy_base(bh_io_t *io)
+{
+    if (io->buffer.capacity)
+        free(io->buffer.data);
+}
+
 /**
  * Creates the new io object with specified \a table and \a size.
  *
+ * The \a unified flag specifies the behaivor of the internal peek buffer.
+ * If the \a unified flag is set - the io object will assume that read and
+ * write operations are dependant on each other (ex. writing to the file
+ * affects next read operation).
+ * If the \a unified flag is not set - the io object will asusme that read and
+ * write operations are independant.
+ *
  * \param table     Pointer to the io table
  * \param size      Size of the io object
+ * \param unified   Unified read/write stream flag
  *
  * \return On success, returns new semi-initialized io object.
  * \return On failure, returns null pointer.
@@ -20,14 +351,15 @@
  * \warning This function should be used in context of implementing child
  *          io objects (files, sockets, streaming compression, etc).
  */
-bh_io_t *bh_io_new(bh_io_table_t *table,
+bh_io_t *bh_io_new(const bh_io_table_t *table,
-                   size_t size)
+                   size_t size,
+                   int unified)
 {
     bh_io_t *result;
 
     result = malloc(size);
     if (result)
-        bh_io_init(result, table);
+        bh_io_init(result, table, unified);
 
     return result;
 }
@@ -46,14 +378,27 @@ void bh_io_free(bh_io_t *io)
 /**
  * Initializes the \a io object with specified \a table.
  *
+ * The \a unified flag specifies the behaivor of the internal peek buffer.
+ * If the \a unified flag is set - the io object will assume that read and
+ * write operations are dependant on each other (ex. writing to the file
+ * affects next read operation).
+ * If the \a unified flag is not set - the io object will asusme that read and
+ * write operations are independant.
+ *
  * \param io        Pointer to the io object to be initialized
  * \param table     Pointer to the io table
+ * \param unified   Unified read/write stream flag
  */
 void bh_io_init(bh_io_t *io,
-                const bh_io_table_t *table)
+                const bh_io_table_t *table,
+                int unified)
 {
     io->table = table;
-    io->flags = 0;
+    io->flags = (unified) ? (BH_IO_UNIFIED) : (0);
+    io->buffer.capacity = 0;
+    io->buffer.head = 0;
+    io->buffer.tail = 0;
+    io->buffer.size = 0;
 }
 
 /**
@@ -121,7 +466,50 @@ size_t bh_io_read(bh_io_t *io,
                   char *data,
                   size_t size)
 {
-    return io->table->read(io, data, size);
+
+    size_t result;
+
+    /* Read as much data from peek buffer as possible */
+    result = bh_io_buffer_read(io, data, size, 0);
+
+    /* If that wasn't enough read from the device */
+    if (result != size)
+        result += io->table->read(io, data + result, size - result);
+
+    /* Return amount of bytes read */
+    return result;
+}
+
+/**
+ * Peeks up to \a size amount of bytes from the \a io object into memory buffer
+ * pointed by \a data pointer.
+ *
+ * \param io    Pointer to the io object
+ * \param data  Pointer to the memory buffer
+ * \param size  Maximum number of bytes to be read
+ *
+ * \return On success, returns number of bytes successfuly read.
+ * \return On failure, returns zero.
+ */
+size_t bh_io_peek(bh_io_t *io,
+                  char *data,
+                  size_t size)
+{
+    /* Fill peek buffer if it's size is less then requested */
+    if (io->buffer.size < size)
+    {
+        size_t read;
+
+        read = io->table->read(io, data, size - io->buffer.size);
+        bh_io_buffer_write(io, data, read);
+    }
+
+    /* Clear EOF flag if peek buffer is not empty */
+    if (io->buffer.size > 0)
+        io->flags &= ~BH_IO_EOF;
+
+    /* Read data from the peek buffer */
+    return bh_io_buffer_read(io, data, size, 1);
 }
 
 /**
@@ -138,9 +526,19 @@ size_t bh_io_read(bh_io_t *io,
  * \note To check for error see bh_io_error.
  */
 size_t bh_io_write(bh_io_t *io,
-                   const char* data,
+                   const char *data,
                    size_t size)
 {
+    /* Clear peek buffer and adjust the position if IO is unified */
+    if (io->buffer.size && (io->flags & BH_IO_UNIFIED))
+    {
+        io->table->seek(io, -(bh_off_t)io->buffer.size, BH_IO_CURRENT);
+        io->buffer.head = 0;
+        io->buffer.tail = 0;
+        io->buffer.size = 0;
+    }
+
+    /* Write data */
     return io->table->write(io, data, size);
 }
 
@@ -172,6 +570,7 @@ int bh_io_seek(bh_io_t *io,
                bh_off_t offset,
                int dir)
 {
+    offset = bh_io_buffer_seek(io, offset, dir);
     return io->table->seek(io, offset, dir);
 }
 
@@ -198,7 +597,7 @@ bh_off_t bh_io_size(bh_io_t *io)
  */
 bh_off_t bh_io_tell(bh_io_t *io)
 {
-    return io->table->tell(io);
+    return io->table->tell(io) - io->buffer.size;
 }
 
 /**
@@ -211,7 +610,7 @@ bh_off_t bh_io_tell(bh_io_t *io)
  */
 bh_off_t bh_io_available(bh_io_t *io)
 {
-    return io->table->available(io);
+    return io->table->available(io) + io->buffer.size;
 }
 
 /**