Add support for in-memory tar and optimize write_null_bytes

README.md

@@ -56,6 +56,39 @@ mtar_close(&tar);
 ```
 
 
+#### Writing to memory
+```c
+mtar_t tar;
+mtar_mem_stream_t mem;
+char buffer[4096];
+const char *str1 = "Hello world";
+const char *str2 = "Goodbye world";
+
+/* Initialize memory stream object */
+mtar_init_mem_stream(&mem, buffer, sizeof(buffer));
+/* Open archive for writing */
+mtar_open_mem(&tar, &mem);
+
+/* Write strings to files `test1.txt` and `test2.txt` */
+mtar_write_file_header(&tar, "test1.txt", strlen(str1));
+mtar_write_data(&tar, str1, strlen(str1));
+mtar_write_file_header(&tar, "test2.txt", strlen(str2));
+mtar_write_data(&tar, str2, strlen(str2));
+
+/* Finalize -- this needs to be the last thing done before closing */
+mtar_finalize(&tar);
+
+/* Close archive */
+mtar_close(&tar);
+
+/* Now you can process the buffer */
+size_t data_len = mem.pos;
+FILE *fp = fopen("output.tar", "wb");
+fwrite(buffer, data_len, 1, fp);
+fclose(fp);
+```
+
+
 ## Error handling
 All functions which return an `int` will return `MTAR_ESUCCESS` if the operation
 is successful. If an error occurs an error value less-than-zero will be

src/microtar.c

@@ -76,12 +76,14 @@ static int twrite(mtar_t *tar, const void *data, unsigned size) {
 
 static int write_null_bytes(mtar_t *tar, int n) {
   int i, err;
-  char nul = '\0';
-  for (i = 0; i < n; i++) {
-    err = twrite(tar, &nul, 1);
+  char nul[MTAR_NULL_BLOCKSIZE];
+  memset(nul, 0, sizeof(nul));
+  while (n > 0) {
+    err = twrite(tar, &nul, n > MTAR_NULL_BLOCKSIZE ? MTAR_NULL_BLOCKSIZE : n);
     if (err) {
       return err;
     }
+    n -= MTAR_NULL_BLOCKSIZE;
   }
   return MTAR_ESUCCESS;
 }
@@ -173,6 +175,78 @@ static int file_close(mtar_t *tar) {
   return MTAR_ESUCCESS;
 }
 
+static int mem_write(mtar_t *tar, const void *data, unsigned size) {
+  mtar_mem_stream_t *mem = tar->stream;
+
+  if(!mem || mem->pos + size >= mem->size) {
+    return MTAR_EWRITEFAIL;
+  }
+
+  memcpy(mem->data + mem->pos, data, size);
+  mem->pos += size;
+
+  return MTAR_ESUCCESS;
+}
+
+static int mem_read(mtar_t *tar, void *data, unsigned size) {
+  mtar_mem_stream_t *mem = tar->stream;
+
+  if(!mem || mem->pos + size >= mem->size) {
+    return MTAR_EREADFAIL;
+  }
+
+  memcpy(data, mem->data + mem->pos, size);
+  mem->pos += size;
+
+  return MTAR_ESUCCESS;
+}
+
+static int mem_seek(mtar_t *tar, unsigned offset) {
+  mtar_mem_stream_t *mem = tar->stream;
+
+  if(!mem || offset >= mem->size)
+    return MTAR_ESEEKFAIL;
+
+  mem->pos = offset;
+
+  return MTAR_ESUCCESS;
+}
+
+static int mem_close(mtar_t *tar) {
+  tar->stream = NULL;
+
+  return MTAR_ESUCCESS;
+}
+
+
+int mtar_init_mem_stream(mtar_mem_stream_t *mem, void *buff, size_t size)
+{
+	mem->data = buff;
+	mem->size = size;
+	mem->pos = 0;
+	return MTAR_ESUCCESS;
+}
+
+
+int mtar_open_mem(mtar_t *tar, mtar_mem_stream_t *mem) {
+  int err;
+  mtar_header_t h;
+
+  if ( !mem || !mem->data || !mem->size ) {
+    return MTAR_EOPENFAIL;
+  }
+
+  memset(tar, 0, sizeof(*tar));
+  tar->write = mem_write;
+  tar->read = mem_read;
+  tar->seek = mem_seek;
+  tar->close = mem_close;
+
+  tar->stream = mem;
+
+  return MTAR_ESUCCESS;
+}
+
 
 int mtar_open(mtar_t *tar, const char *filename, const char *mode) {
   int err;

src/microtar.h

@@ -17,6 +17,7 @@ extern "C"
 #include <stdlib.h>
 
 #define MTAR_VERSION "0.1.0"
+#define MTAR_NULL_BLOCKSIZE 16
 
 enum {
   MTAR_ESUCCESS     =  0,
@@ -64,9 +65,20 @@ struct mtar_t {
   unsigned last_header;
 };
 
+struct mtar_mem_stream_t {
+  char *data;
+  size_t size;
+  size_t pos;
+};
+
+typedef struct mtar_mem_stream_t mtar_mem_stream_t;
+
 
 const char* mtar_strerror(int err);
 
+int mtar_init_mem_stream(mtar_mem_stream_t *mem, void *buff, size_t size);
+
+int mtar_open_mem(mtar_t *tar, mtar_mem_stream_t *mem);
 int mtar_open(mtar_t *tar, const char *filename, const char *mode);
 int mtar_close(mtar_t *tar);