1 files changed, 550 insertions, 533 deletions

diff --git a/src/main/extractor_datasource.c b/src/main/extractor_datasource.c
index 888e524..0b18d7c 100644
--- a/src/main/extractor_datasource.c
+++ b/src/main/extractor_datasource.c
@@ -214,35 +214,35 @@ struct CompressedFileSource
  */
 static int
 bfds_pick_next_buffer_at (struct BufferedFileDataSource *bfds,
-                          uint64_t pos)
+                          uint64_t pos)
 {
   int64_t position;
   ssize_t rd;
 
   if (pos > bfds->fsize)
-    {
-      LOG ("Invalid seek operation\n");
-      return -1; /* invalid */
-    }
+  {
+    LOG ("Invalid seek operation\n");
+    return -1;   /* invalid */
+  }
   if (NULL == bfds->buffer)
-    {
-      bfds->buffer_pos = pos;
-      return 0;
-    }
+  {
+    bfds->buffer_pos = pos;
+    return 0;
+  }
   position = (int64_t) LSEEK (bfds->fd, pos, SEEK_SET);
   if (position < 0)
-    {
-      LOG_STRERROR ("lseek");
-      return -1;
-    }
+  {
+    LOG_STRERROR ("lseek");
+    return -1;
+  }
   bfds->fpos = position;
   bfds->buffer_pos = 0;
   rd = read (bfds->fd, bfds->buffer, bfds->buffer_size);
   if (rd < 0)
-    {
-      LOG_STRERROR ("read");
-      return -1;
-    }
+  {
+    LOG_STRERROR ("read");
+    return -1;
+  }
   bfds->buffer_bytes = rd;
   return 0;
 }
@@ -258,8 +258,8 @@ bfds_pick_next_buffer_at (struct BufferedFileDataSource *bfds,
  */
 static struct BufferedFileDataSource *
 bfds_new (const void *data,
-          int fd,
-          int64_t fsize)
+          int fd,
+          int64_t fsize)
 {
   struct BufferedFileDataSource *result;
   size_t xtra;
@@ -269,19 +269,19 @@ bfds_new (const void *data,
   else
     xtra = (size_t) fsize;
   if ( (-1 == fd) && (NULL == data) )
-    {
-      LOG ("Invalid arguments\n");
-      return NULL;
-    }
+  {
+    LOG ("Invalid arguments\n");
+    return NULL;
+  }
   if ( (-1 != fd) && (NULL != data) )
     fd = -1; /* don't need fd */
   if (NULL != data)
     xtra = 0;
   if (NULL == (result = malloc (sizeof (struct BufferedFileDataSource) + xtra)))
-    {
-      LOG_STRERROR ("malloc");
-      return NULL;
-    }
+  {
+    LOG_STRERROR ("malloc");
+    return NULL;
+  }
   memset (result, 0, sizeof (struct BufferedFileDataSource));
   result->data = (NULL != data) ? data : &result[1];
   result->buffer = (NULL != data) ? NULL : &result[1];
@@ -318,79 +318,79 @@ bfds_delete (struct BufferedFileDataSource *bfds)
  */
 static int64_t
 bfds_seek (struct BufferedFileDataSource *bfds,
-           int64_t pos, int whence)
+           int64_t pos, int whence)
 {
   uint64_t npos;
   size_t nbpos;
 
   switch (whence)
+  {
+  case SEEK_CUR:
+    npos = bfds->fpos + bfds->buffer_pos + pos;
+    if (npos > bfds->fsize)
     {
-    case SEEK_CUR:
-      npos = bfds->fpos + bfds->buffer_pos + pos;
-      if (npos > bfds->fsize)
-        {
-          LOG ("Invalid seek operation to %lld from %llu (max is %llu)\n",
-               (long long) pos,
-               bfds->fpos + bfds->buffer_pos,
-               (unsigned long long) bfds->fsize);
-          return -1;
-        }
-      nbpos = bfds->buffer_pos + pos;
-      if ( (NULL == bfds->buffer) ||
-           (nbpos < bfds->buffer_bytes) )
-        {
-          bfds->buffer_pos = nbpos;
-          return npos;
-        }
-      if (0 != bfds_pick_next_buffer_at (bfds,
-                                         npos))
-        {
-          LOG ("seek operation failed\n");
-          return -1;
-        }
+      LOG ("Invalid seek operation to %lld from %llu (max is %llu)\n",
+           (long long) pos,
+           bfds->fpos + bfds->buffer_pos,
+           (unsigned long long) bfds->fsize);
+      return -1;
+    }
+    nbpos = bfds->buffer_pos + pos;
+    if ( (NULL == bfds->buffer) ||
+         (nbpos < bfds->buffer_bytes) )
+    {
+      bfds->buffer_pos = nbpos;
       return npos;
-    case SEEK_END:
-      if (pos > 0)
-        {
-          LOG ("Invalid seek operation\n");
-          return -1;
-        }
-      if (bfds->fsize < - pos)
-        {
-          LOG ("Invalid seek operation\n");
-          return -1;
-        }
-      pos = bfds->fsize + pos;
-      /* fall-through! */
-    case SEEK_SET:
-      if (pos < 0)
-        {
-          LOG ("Invalid seek operation\n");
-          return -1;
-        }
-      if (pos > bfds->fsize)
-        {
-          LOG ("Invalid seek operation (%lld > %llu) %d\n",
-               (long long) pos,
-               (unsigned long long) bfds->fsize,
-               SEEK_SET == whence);
-          return -1;
-        }
-      if ( (NULL == bfds->buffer) ||
-           ( (bfds->fpos <= pos) &&
-             (bfds->fpos + bfds->buffer_bytes > pos) ) )
-        {
-          bfds->buffer_pos = pos - bfds->fpos;
-          return pos;
-        }
-      if (0 != bfds_pick_next_buffer_at (bfds, pos))
-        {
-          LOG ("seek operation failed\n");
-          return -1;
-        }
-      ASSERT (pos == bfds->fpos + bfds->buffer_pos);
+    }
+    if (0 != bfds_pick_next_buffer_at (bfds,
+                                       npos))
+    {
+      LOG ("seek operation failed\n");
+      return -1;
+    }
+    return npos;
+  case SEEK_END:
+    if (pos > 0)
+    {
+      LOG ("Invalid seek operation\n");
+      return -1;
+    }
+    if (bfds->fsize < -pos)
+    {
+      LOG ("Invalid seek operation\n");
+      return -1;
+    }
+    pos = bfds->fsize + pos;
+  /* fall-through! */
+  case SEEK_SET:
+    if (pos < 0)
+    {
+      LOG ("Invalid seek operation\n");
+      return -1;
+    }
+    if (pos > bfds->fsize)
+    {
+      LOG ("Invalid seek operation (%lld > %llu) %d\n",
+           (long long) pos,
+           (unsigned long long) bfds->fsize,
+           SEEK_SET == whence);
+      return -1;
+    }
+    if ( (NULL == bfds->buffer) ||
+         ( (bfds->fpos <= pos) &&
+           (bfds->fpos + bfds->buffer_bytes > pos) ) )
+    {
+      bfds->buffer_pos = pos - bfds->fpos;
       return pos;
     }
+    if (0 != bfds_pick_next_buffer_at (bfds, pos))
+    {
+      LOG ("seek operation failed\n");
+      return -1;
+    }
+    ASSERT (pos == bfds->fpos + bfds->buffer_pos);
+    return pos;
+  }
   return -1;
 }
 
@@ -407,8 +407,8 @@ bfds_seek (struct BufferedFileDataSource *bfds,
  */
 static ssize_t
 bfds_read (struct BufferedFileDataSource *bfds,
-           void *buf_ptr,
-           size_t count)
+           void *buf_ptr,
+           size_t count)
 {
   char *cbuf = buf_ptr;
   uint64_t old_off;
@@ -420,28 +420,28 @@ bfds_read (struct BufferedFileDataSource *bfds,
     return 0; /* end of stream */
   ret = 0;
   while (count > 0)
+  {
+    if ( (bfds->buffer_bytes == bfds->buffer_pos) &&
+         (0 != bfds_pick_next_buffer_at (bfds,
+                                         bfds->fpos + bfds->buffer_bytes)) )
     {
-      if ( (bfds->buffer_bytes == bfds->buffer_pos) &&
-           (0 != bfds_pick_next_buffer_at (bfds,
-                                           bfds->fpos + bfds->buffer_bytes)) )
-        {
-          /* revert to original position, invalidate buffer */
-          bfds->fpos = old_off;
-          bfds->buffer_bytes = 0;
-          bfds->buffer_pos = 0;
-          LOG ("read operation failed\n");
-          return -1; /* getting more failed */
-        }
-      avail = bfds->buffer_bytes - bfds->buffer_pos;
-      if (avail > count)
-        avail = count;
-      if (0 == avail)
-        break;
-      memcpy (&cbuf[ret], bfds->data + bfds->buffer_pos, avail);
-      bfds->buffer_pos += avail;
-      count -= avail;
-      ret += avail;
+      /* revert to original position, invalidate buffer */
+      bfds->fpos = old_off;
+      bfds->buffer_bytes = 0;
+      bfds->buffer_pos = 0;
+      LOG ("read operation failed\n");
+      return -1; /* getting more failed */
     }
+    avail = bfds->buffer_bytes - bfds->buffer_pos;
+    if (avail > count)
+      avail = count;
+    if (0 == avail)
+      break;
+    memcpy (&cbuf[ret], bfds->data + bfds->buffer_pos, avail);
+    bfds->buffer_pos += avail;
+    count -= avail;
+    ret += avail;
+  }
   return ret;
 }
 
@@ -458,17 +458,17 @@ bfds_read (struct BufferedFileDataSource *bfds,
  */
 static int
 cfs_init_decompressor_zlib (struct CompressedFileSource *cfs,
-                            EXTRACTOR_MetaDataProcessor proc, void *proc_cls)
+                            EXTRACTOR_MetaDataProcessor proc, void *proc_cls)
 {
   unsigned int gzip_header_length = 10;
   unsigned char hdata[12];
   ssize_t rsize;
 
   if (0 != bfds_seek (cfs->bfds, 0, SEEK_SET))
-    {
-      LOG ("Failed to seek to offset 0!\n");
-      return -1;
-    }
+  {
+    LOG ("Failed to seek to offset 0!\n");
+    return -1;
+  }
   /* Process gzip header */
   rsize = bfds_read (cfs->bfds, hdata, sizeof (hdata));
   if ( (-1 == rsize) ||
@@ -478,72 +478,74 @@ cfs_init_decompressor_zlib (struct CompressedFileSource *cfs,
     gzip_header_length += 2 + (hdata[10] & 0xff) + ((hdata[11] & 0xff) * 256);
 
   if (0 != (hdata[3] & 0x8))
+  {
+    /* FNAME set */
+    char fname[1024];
+    char *cptr;
+    size_t len;
+    ssize_t buf_bytes;
+
+    if (gzip_header_length > bfds_seek (cfs->bfds, gzip_header_length,
+                                        SEEK_SET))
     {
-      /* FNAME set */
-      char fname[1024];
-      char *cptr;
-      size_t len;
-      ssize_t buf_bytes;
-
-      if (gzip_header_length > bfds_seek (cfs->bfds, gzip_header_length, SEEK_SET))
-        {
-          LOG ("Corrupt gzip, failed to seek to end of header\n");
-          return -1;
-        }
-      buf_bytes = bfds_read (cfs->bfds, fname, sizeof (fname));
-      if (buf_bytes <= 0)
-        {
-          LOG ("Corrupt gzip, failed to read filename\n");
-          return -1;
-        }
-      if (NULL == (cptr = memchr (fname, 0, buf_bytes)))
-        {
-          LOG ("Corrupt gzip, failed to read filename terminator\n");
-          return -1;
-        }
-      len = cptr - fname;
-      if ( (NULL != proc) &&
-           (0 != proc (proc_cls, "<zlib>", EXTRACTOR_METATYPE_FILENAME,
-                       EXTRACTOR_METAFORMAT_C_STRING, "text/plain",
-                       fname,
-                       len)) )
-        return 0; /* done */
-      gzip_header_length += len + 1;
+      LOG ("Corrupt gzip, failed to seek to end of header\n");
+      return -1;
     }
+    buf_bytes = bfds_read (cfs->bfds, fname, sizeof (fname));
+    if (buf_bytes <= 0)
+    {
+      LOG ("Corrupt gzip, failed to read filename\n");
+      return -1;
+    }
+    if (NULL == (cptr = memchr (fname, 0, buf_bytes)))
+    {
+      LOG ("Corrupt gzip, failed to read filename terminator\n");
+      return -1;
+    }
+    len = cptr - fname;
+    if ( (NULL != proc) &&
+         (0 != proc (proc_cls, "<zlib>", EXTRACTOR_METATYPE_FILENAME,
+                     EXTRACTOR_METAFORMAT_C_STRING, "text/plain",
+                     fname,
+                     len)) )
+      return 0; /* done */
+    gzip_header_length += len + 1;
+  }
 
   if (0 != (hdata[3] & 0x16))
+  {
+    /* FCOMMENT set */
+    char fcomment[1024];
+    char *cptr;
+    ssize_t buf_bytes;
+    size_t len;
+
+    if (gzip_header_length > bfds_seek (cfs->bfds, gzip_header_length,
+                                        SEEK_SET))
     {
-      /* FCOMMENT set */
-      char fcomment[1024];
-      char *cptr;
-      ssize_t buf_bytes;
-      size_t len;
-
-      if (gzip_header_length > bfds_seek (cfs->bfds, gzip_header_length, SEEK_SET))
-        {
-          LOG ("Corrupt gzip, failed to seek to end of header\n");
-          return -1;
-        }
-      buf_bytes = bfds_read (cfs->bfds, fcomment, sizeof (fcomment));
-      if (buf_bytes <= 0)
-        {
-          LOG ("Corrupt gzip, failed to read comment\n");
-          return -1;
-        }
-      if (NULL == (cptr = memchr (fcomment, 0, buf_bytes)))
-        {
-          LOG ("Corrupt gzip, failed to read comment terminator\n");
-          return -1;
-        }
-      len = cptr - fcomment;
-      if ( (NULL != proc) &&
-           (0 != proc (proc_cls, "<zlib>", EXTRACTOR_METATYPE_COMMENT,
-                       EXTRACTOR_METAFORMAT_C_STRING, "text/plain",
-                       (const char *) fcomment,
-                       len)) )
-        return 0; /* done */
-      gzip_header_length += len + 1;
+      LOG ("Corrupt gzip, failed to seek to end of header\n");
+      return -1;
+    }
+    buf_bytes = bfds_read (cfs->bfds, fcomment, sizeof (fcomment));
+    if (buf_bytes <= 0)
+    {
+      LOG ("Corrupt gzip, failed to read comment\n");
+      return -1;
+    }
+    if (NULL == (cptr = memchr (fcomment, 0, buf_bytes)))
+    {
+      LOG ("Corrupt gzip, failed to read comment terminator\n");
+      return -1;
     }
+    len = cptr - fcomment;
+    if ( (NULL != proc) &&
+         (0 != proc (proc_cls, "<zlib>", EXTRACTOR_METATYPE_COMMENT,
+                     EXTRACTOR_METAFORMAT_C_STRING, "text/plain",
+                     (const char *) fcomment,
+                     len)) )
+      return 0; /* done */
+    gzip_header_length += len + 1;
+  }
   if (0 != (hdata[3] & 0x2)) /* FCHRC set */
     gzip_header_length += 2;
   memset (&cfs->strm, 0, sizeof (z_stream));
@@ -556,10 +558,10 @@ cfs_init_decompressor_zlib (struct CompressedFileSource *cfs,
 
   if (cfs->gzip_header_length !=
       bfds_seek (cfs->bfds, cfs->gzip_header_length, SEEK_SET))
-    {
-      LOG ("Failed to seek to start to initialize gzip decompressor\n");
-      return -1;
-    }
+  {
+    LOG ("Failed to seek to start to initialize gzip decompressor\n");
+    return -1;
+  }
   cfs->strm.avail_out = COM_CHUNK_SIZE;
   /*
    * note: maybe plain inflateInit(&strm) is adequate,
@@ -567,20 +569,21 @@ cfs_init_decompressor_zlib (struct CompressedFileSource *cfs,
    *
    * ZLIB_VERNUM isn't defined by zlib version 1.1.4 ;
    * there might be a better check.
-   */
-  if (Z_OK != inflateInit2 (&cfs->strm,
+   */if (Z_OK != inflateInit2 (&cfs->strm,
 #ifdef ZLIB_VERNUM
-      15 + 32
+                            15 + 32
 #else
-      - MAX_WBITS
+                            -MAX_WBITS
 #endif
-      ))
-    {
-      LOG ("Failed to initialize zlib decompression\n");
-      return -1;
-    }
+                            ))
+  {
+    LOG ("Failed to initialize zlib decompression\n");
+    return -1;
+  }
   return 1;
 }
+
+
 #endif
 
 
@@ -596,24 +599,26 @@ cfs_init_decompressor_zlib (struct CompressedFileSource *cfs,
  */
 static int
 cfs_init_decompressor_bz2 (struct CompressedFileSource *cfs,
-                           EXTRACTOR_MetaDataProcessor proc, void *proc_cls)
+                           EXTRACTOR_MetaDataProcessor proc, void *proc_cls)
 {
   if (0 !=
       bfds_seek (cfs->bfds, 0, SEEK_SET))
-    {
-      LOG ("Failed to seek to start to initialize BZ2 decompressor\n");
-      return -1;
-    }
+  {
+    LOG ("Failed to seek to start to initialize BZ2 decompressor\n");
+    return -1;
+  }
   memset (&cfs->bstrm, 0, sizeof (bz_stream));
   if (BZ_OK !=
       BZ2_bzDecompressInit (&cfs->bstrm, 0, 0))
-    {
-      LOG ("Failed to initialize BZ2 decompressor\n");
-      return -1;
-    }
+  {
+    LOG ("Failed to initialize BZ2 decompressor\n");
+    return -1;
+  }
   cfs->bstrm.avail_out = COM_CHUNK_SIZE;
   return 1;
 }
+
+
 #endif
 
 
@@ -628,24 +633,24 @@ cfs_init_decompressor_bz2 (struct CompressedFileSource *cfs,
  */
 static int
 cfs_init_decompressor (struct CompressedFileSource *cfs,
-                       EXTRACTOR_MetaDataProcessor proc, void *proc_cls)
+                       EXTRACTOR_MetaDataProcessor proc, void *proc_cls)
 {
   cfs->result_pos = 0;
   cfs->fpos = 0;
   switch (cfs->compression_type)
-    {
+  {
 #if HAVE_ZLIB
-    case COMP_TYPE_ZLIB:
-      return cfs_init_decompressor_zlib (cfs, proc, proc_cls);
+  case COMP_TYPE_ZLIB:
+    return cfs_init_decompressor_zlib (cfs, proc, proc_cls);
 #endif
 #if HAVE_LIBBZ2
-    case COMP_TYPE_BZ2:
-      return cfs_init_decompressor_bz2 (cfs, proc, proc_cls);
+  case COMP_TYPE_BZ2:
+    return cfs_init_decompressor_bz2 (cfs, proc, proc_cls);
 #endif
-    default:
-      LOG ("invalid compression type selected\n");
-      return -1;
-    }
+  default:
+    LOG ("invalid compression type selected\n");
+    return -1;
+  }
 }
 
 
@@ -662,6 +667,8 @@ cfs_deinit_decompressor_zlib (struct CompressedFileSource *cfs)
   inflateEnd (&cfs->strm);
   return 1;
 }
+
+
 #endif
 
 
@@ -678,6 +685,8 @@ cfs_deinit_decompressor_bz2 (struct CompressedFileSource *cfs)
   BZ2_bzDecompressEnd (&cfs->bstrm);
   return 1;
 }
+
+
 #endif
 
 
@@ -691,19 +700,19 @@ static int
 cfs_deinit_decompressor (struct CompressedFileSource *cfs)
 {
   switch (cfs->compression_type)
-    {
+  {
 #if HAVE_ZLIB
-    case COMP_TYPE_ZLIB:
-      return cfs_deinit_decompressor_zlib (cfs);
+  case COMP_TYPE_ZLIB:
+    return cfs_deinit_decompressor_zlib (cfs);
 #endif
 #if HAVE_LIBBZ2
-    case COMP_TYPE_BZ2:
-      return cfs_deinit_decompressor_bz2 (cfs);
+  case COMP_TYPE_BZ2:
+    return cfs_deinit_decompressor_bz2 (cfs);
 #endif
-    default:
-      LOG ("invalid compression type selected\n");
-      return -1;
-    }
+  default:
+    LOG ("invalid compression type selected\n");
+    return -1;
+  }
 }
 
 
@@ -750,28 +759,28 @@ cfs_destroy (struct CompressedFileSource *cfs)
  */
 struct CompressedFileSource *
 cfs_new (struct BufferedFileDataSource *bfds,
-         int64_t fsize,
-         enum ExtractorCompressionType compression_type,
-         EXTRACTOR_MetaDataProcessor proc, void *proc_cls)
+         int64_t fsize,
+         enum ExtractorCompressionType compression_type,
+         EXTRACTOR_MetaDataProcessor proc, void *proc_cls)
 {
   struct CompressedFileSource *cfs;
 
   if (NULL == (cfs = malloc (sizeof (struct CompressedFileSource))))
-    {
-      LOG_STRERROR ("malloc");
-      return NULL;
-    }
+  {
+    LOG_STRERROR ("malloc");
+    return NULL;
+  }
   memset (cfs, 0, sizeof (struct CompressedFileSource));
   cfs->compression_type = compression_type;
   cfs->bfds = bfds;
   cfs->fsize = fsize;
   cfs->uncompressed_size = -1;
   if (1 != cfs_init_decompressor (cfs,
-                                  proc, proc_cls))
-    {
-      free (cfs);
-      return NULL;
-    }
+                                  proc, proc_cls))
+  {
+    free (cfs);
+    return NULL;
+  }
   return cfs;
 }
 
@@ -789,8 +798,8 @@ cfs_new (struct BufferedFileDataSource *bfds,
  */
 static ssize_t
 cfs_read_zlib (struct CompressedFileSource *cfs,
-               void *data,
-               size_t size)
+               void *data,
+               size_t size)
 {
   char *dst = data;
   int ret;
@@ -799,77 +808,79 @@ cfs_read_zlib (struct CompressedFileSource *cfs,
   unsigned char buf[COM_CHUNK_SIZE];
 
   if (cfs->fpos == cfs->uncompressed_size)
-    {
-      /* end of file */
-      return 0;
-    }
+  {
+    /* end of file */
+    return 0;
+  }
   rc = 0;
   if (COM_CHUNK_SIZE > cfs->strm.avail_out + cfs->result_pos)
-    {
-      /* got left-over decompressed data from previous round! */
-      in = COM_CHUNK_SIZE - (cfs->strm.avail_out + cfs->result_pos);
-      if (in > size)
-        in = size;
-      memcpy (&dst[rc], &cfs->result[cfs->result_pos], in);
-      cfs->fpos += in;
-      cfs->result_pos += in;
-      rc += in;
-    }
+  {
+    /* got left-over decompressed data from previous round! */
+    in = COM_CHUNK_SIZE - (cfs->strm.avail_out + cfs->result_pos);
+    if (in > size)
+      in = size;
+    memcpy (&dst[rc], &cfs->result[cfs->result_pos], in);
+    cfs->fpos += in;
+    cfs->result_pos += in;
+    rc += in;
+  }
   ret = Z_OK;
   while ( (rc < size) && (Z_STREAM_END != ret) )
+  {
+    /* read block from original data source */
+    in = bfds_read (cfs->bfds,
+                    buf, sizeof (buf));
+    if (in < 0)
     {
-      /* read block from original data source */
-      in = bfds_read (cfs->bfds,
-                      buf, sizeof (buf));
-      if (in < 0)
-        {
-          LOG ("unexpected EOF\n");
-          return -1; /* unexpected EOF */
-        }
-      if (0 == in)
-        {
-          cfs->uncompressed_size = cfs->fpos;
-          return rc;
-        }
-      cfs->strm.next_in = buf;
-      cfs->strm.avail_in = (uInt) in;
-      cfs->strm.next_out = (unsigned char *) cfs->result;
-      cfs->strm.avail_out = COM_CHUNK_SIZE;
-      cfs->result_pos = 0;
-      ret = inflate (&cfs->strm, Z_SYNC_FLUSH);
-      if ( (Z_OK != ret) && (Z_STREAM_END != ret) )
-        {
-          LOG ("unexpected gzip inflate error: %d\n", ret);
-          return -1; /* unexpected error */
-        }
-      /* go backwards by the number of bytes left in the buffer */
-      if (-1 == bfds_seek (cfs->bfds, - (int64_t) cfs->strm.avail_in, SEEK_CUR))
-        {
-          LOG ("seek failed\n");
-          return -1;
-        }
-      /* copy decompressed bytes to target buffer */
-      in = COM_CHUNK_SIZE - cfs->strm.avail_out;
-      if (in > size - rc)
-        {
-          if (Z_STREAM_END == ret)
-            {
-              cfs->uncompressed_size = cfs->fpos + in;
-              ret = Z_OK;
-            }
-          in = size - rc;
-        }
-      memcpy (&dst[rc], &cfs->result[cfs->result_pos], in);
-      cfs->fpos += in;
-      cfs->result_pos += in;
-      rc += in;
+      LOG ("unexpected EOF\n");
+      return -1; /* unexpected EOF */
     }
-  if (Z_STREAM_END == ret)
+    if (0 == in)
     {
       cfs->uncompressed_size = cfs->fpos;
+      return rc;
+    }
+    cfs->strm.next_in = buf;
+    cfs->strm.avail_in = (uInt) in;
+    cfs->strm.next_out = (unsigned char *) cfs->result;
+    cfs->strm.avail_out = COM_CHUNK_SIZE;
+    cfs->result_pos = 0;
+    ret = inflate (&cfs->strm, Z_SYNC_FLUSH);
+    if ( (Z_OK != ret) && (Z_STREAM_END != ret) )
+    {
+      LOG ("unexpected gzip inflate error: %d\n", ret);
+      return -1; /* unexpected error */
+    }
+    /* go backwards by the number of bytes left in the buffer */
+    if (-1 == bfds_seek (cfs->bfds, -(int64_t) cfs->strm.avail_in, SEEK_CUR))
+    {
+      LOG ("seek failed\n");
+      return -1;
+    }
+    /* copy decompressed bytes to target buffer */
+    in = COM_CHUNK_SIZE - cfs->strm.avail_out;
+    if (in > size - rc)
+    {
+      if (Z_STREAM_END == ret)
+      {
+        cfs->uncompressed_size = cfs->fpos + in;
+        ret = Z_OK;
+      }
+      in = size - rc;
     }
+    memcpy (&dst[rc], &cfs->result[cfs->result_pos], in);
+    cfs->fpos += in;
+    cfs->result_pos += in;
+    rc += in;
+  }
+  if (Z_STREAM_END == ret)
+  {
+    cfs->uncompressed_size = cfs->fpos;
+  }
   return rc;
 }
+
+
 #endif
 
 
@@ -886,8 +897,8 @@ cfs_read_zlib (struct CompressedFileSource *cfs,
  */
 static ssize_t
 cfs_read_bz2 (struct CompressedFileSource *cfs,
-              void *data,
-              size_t size)
+              void *data,
+              size_t size)
 {
   char *dst = data;
   int ret;
@@ -896,77 +907,79 @@ cfs_read_bz2 (struct CompressedFileSource *cfs,
   char buf[COM_CHUNK_SIZE];
 
   if (cfs->fpos == cfs->uncompressed_size)
-    {
-      /* end of file */
-      return 0;
-    }
+  {
+    /* end of file */
+    return 0;
+  }
   rc = 0;
   if (COM_CHUNK_SIZE > cfs->bstrm.avail_out + cfs->result_pos)
-    {
-      /* got left-over decompressed data from previous round! */
-      in = COM_CHUNK_SIZE - (cfs->bstrm.avail_out + cfs->result_pos);
-      if (in > size)
-        in = size;
-      memcpy (&dst[rc], &cfs->result[cfs->result_pos], in);
-      cfs->fpos += in;
-      cfs->result_pos += in;
-      rc += in;
-    }
+  {
+    /* got left-over decompressed data from previous round! */
+    in = COM_CHUNK_SIZE - (cfs->bstrm.avail_out + cfs->result_pos);
+    if (in > size)
+      in = size;
+    memcpy (&dst[rc], &cfs->result[cfs->result_pos], in);
+    cfs->fpos += in;
+    cfs->result_pos += in;
+    rc += in;
+  }
   ret = BZ_OK;
   while ( (rc < size) && (BZ_STREAM_END != ret) )
+  {
+    /* read block from original data source */
+    in = bfds_read (cfs->bfds,
+                    buf, sizeof (buf));
+    if (in < 0)
     {
-      /* read block from original data source */
-      in = bfds_read (cfs->bfds,
-                      buf, sizeof (buf));
-      if (in < 0)
-        {
-          LOG ("unexpected EOF\n");
-          return -1; /* unexpected EOF */
-        }
-      if (0 == in)
-        {
-          cfs->uncompressed_size = cfs->fpos;
-          return rc;
-        }
-      cfs->bstrm.next_in = buf;
-      cfs->bstrm.avail_in = (unsigned int) in;
-      cfs->bstrm.next_out = cfs->result;
-      cfs->bstrm.avail_out = COM_CHUNK_SIZE;
-      cfs->result_pos = 0;
-      ret = BZ2_bzDecompress (&cfs->bstrm);
-      if ( (BZ_OK != ret) && (BZ_STREAM_END != ret) )
-        {
-          LOG ("unexpected bzip2 decompress error: %d\n", ret);
-          return -1; /* unexpected error */
-        }
-      /* go backwards by the number of bytes left in the buffer */
-      if (-1 == bfds_seek (cfs->bfds, - (int64_t) cfs->bstrm.avail_in, SEEK_CUR))
-        {
-          LOG ("seek failed\n");
-          return -1;
-        }
-      /* copy decompressed bytes to target buffer */
-      in = COM_CHUNK_SIZE - cfs->bstrm.avail_out;
-      if (in > size - rc)
-        {
-          if (BZ_STREAM_END == ret)
-            {
-              cfs->uncompressed_size = cfs->fpos + in;
-              ret = BZ_OK;
-            }
-          in = size - rc;
-        }
-      memcpy (&dst[rc], &cfs->result[cfs->result_pos], in);
-      cfs->fpos += in;
-      cfs->result_pos += in;
-      rc += in;
+      LOG ("unexpected EOF\n");
+      return -1; /* unexpected EOF */
     }
-  if (BZ_STREAM_END == ret)
+    if (0 == in)
     {
       cfs->uncompressed_size = cfs->fpos;
+      return rc;
+    }
+    cfs->bstrm.next_in = buf;
+    cfs->bstrm.avail_in = (unsigned int) in;
+    cfs->bstrm.next_out = cfs->result;
+    cfs->bstrm.avail_out = COM_CHUNK_SIZE;
+    cfs->result_pos = 0;
+    ret = BZ2_bzDecompress (&cfs->bstrm);
+    if ( (BZ_OK != ret) && (BZ_STREAM_END != ret) )
+    {
+      LOG ("unexpected bzip2 decompress error: %d\n", ret);
+      return -1; /* unexpected error */
+    }
+    /* go backwards by the number of bytes left in the buffer */
+    if (-1 == bfds_seek (cfs->bfds, -(int64_t) cfs->bstrm.avail_in, SEEK_CUR))
+    {
+      LOG ("seek failed\n");
+      return -1;
     }
+    /* copy decompressed bytes to target buffer */
+    in = COM_CHUNK_SIZE - cfs->bstrm.avail_out;
+    if (in > size - rc)
+    {
+      if (BZ_STREAM_END == ret)
+      {
+        cfs->uncompressed_size = cfs->fpos + in;
+        ret = BZ_OK;
+      }
+      in = size - rc;
+    }
+    memcpy (&dst[rc], &cfs->result[cfs->result_pos], in);
+    cfs->fpos += in;
+    cfs->result_pos += in;
+    rc += in;
+  }
+  if (BZ_STREAM_END == ret)
+  {
+    cfs->uncompressed_size = cfs->fpos;
+  }
   return rc;
 }
+
+
 #endif
 
 
@@ -982,23 +995,23 @@ cfs_read_bz2 (struct CompressedFileSource *cfs,
  */
 static ssize_t
 cfs_read (struct CompressedFileSource *cfs,
-          void *data,
-          size_t size)
+          void *data,
+          size_t size)
 {
   switch (cfs->compression_type)
-    {
+  {
 #if HAVE_ZLIB
-    case COMP_TYPE_ZLIB:
-      return cfs_read_zlib (cfs, data, size);
+  case COMP_TYPE_ZLIB:
+    return cfs_read_zlib (cfs, data, size);
 #endif
 #if HAVE_LIBBZ2
-    case COMP_TYPE_BZ2:
-      return cfs_read_bz2 (cfs, data, size);
+  case COMP_TYPE_BZ2:
+    return cfs_read_bz2 (cfs, data, size);
 #endif
-    default:
-      LOG ("invalid compression type selected\n");
-      return -1;
-    }
+  default:
+    LOG ("invalid compression type selected\n");
+    return -1;
+  }
 }
 
 
@@ -1014,104 +1027,105 @@ cfs_read (struct CompressedFileSource *cfs,
  */
 static int64_t
 cfs_seek (struct CompressedFileSource *cfs,
-          int64_t position,
-          int whence)
+          int64_t position,
+          int whence)
 {
   uint64_t nposition;
   int64_t delta;
 
   switch (whence)
+  {
+  case SEEK_CUR:
+    if (cfs->fpos + position < 0)
+    {
+      /* underflow */
+      LOG ("Invalid seek operation\n");
+      return -1;
+    }
+    if ( (-1 != cfs->uncompressed_size) &&
+         (cfs->fpos + position > cfs->uncompressed_size) )
+    {
+      LOG ("Invalid seek operation\n");
+      return -1;
+    }
+    nposition = cfs->fpos + position;
+    break;
+  case SEEK_END:
+    ASSERT (-1 != cfs->uncompressed_size);
+    if (position > 0)
     {
-    case SEEK_CUR:
-      if (cfs->fpos + position < 0)
-        {
-          /* underflow */
-          LOG ("Invalid seek operation\n");
-          return -1;
-        }
-      if ( (-1 != cfs->uncompressed_size) &&
-           (cfs->fpos + position > cfs->uncompressed_size) )
-        {
-          LOG ("Invalid seek operation\n");
-          return -1;
-        }
-      nposition = cfs->fpos + position;
-      break;
-    case SEEK_END:
-      ASSERT (-1 != cfs->uncompressed_size);
-      if (position > 0)
-        {
-          LOG ("Invalid seek operation\n");
-          return -1;
-        }
-      if (cfs->uncompressed_size < - position)
-        {
-          LOG ("Invalid seek operation\n");
-          return -1;
-        }
-      nposition = cfs->uncompressed_size + position;
-      break;
-    case SEEK_SET:
-      if (position < 0)
-        {
-          LOG ("Invalid seek operation\n");
-          return -1;
-        }
-      if ( (-1 != cfs->uncompressed_size) &&
-           (cfs->uncompressed_size < position ) )
-        {
-          LOG ("Invalid seek operation\n");
-          return -1;
-        }
-      nposition = (uint64_t) position;
-      break;
-    default:
       LOG ("Invalid seek operation\n");
       return -1;
     }
+    if (cfs->uncompressed_size < -position)
+    {
+      LOG ("Invalid seek operation\n");
+      return -1;
+    }
+    nposition = cfs->uncompressed_size + position;
+    break;
+  case SEEK_SET:
+    if (position < 0)
+    {
+      LOG ("Invalid seek operation\n");
+      return -1;
+    }
+    if ( (-1 != cfs->uncompressed_size) &&
+         (cfs->uncompressed_size < position) )
+    {
+      LOG ("Invalid seek operation\n");
+      return -1;
+    }
+    nposition = (uint64_t) position;
+    break;
+  default:
+    LOG ("Invalid seek operation\n");
+    return -1;
+  }
   delta = nposition - cfs->fpos;
   if (delta < 0)
+  {
+    if (cfs->result_pos >= -delta)
     {
-      if (cfs->result_pos >= - delta)
-        {
-          cfs->result_pos += delta;
-          cfs->fpos += delta;
-          delta = 0;
-        }
-      else
-        {
-          if (-1 == cfs_reset_stream (cfs))
-            {
-              LOG ("Failed to restart compressed stream for seek operation\n");
-              return -1;
-            }
-          delta = nposition;
-        }
+      cfs->result_pos += delta;
+      cfs->fpos += delta;
+      delta = 0;
     }
+    else
+    {
+      if (-1 == cfs_reset_stream (cfs))
+      {
+        LOG ("Failed to restart compressed stream for seek operation\n");
+        return -1;
+      }
+      delta = nposition;
+    }
+  }
   while (delta > 0)
+  {
+    char buf[COM_CHUNK_SIZE];
+    size_t max;
+    int64_t ret;
+
+    max = (sizeof (buf) > delta) ? delta : sizeof (buf);
+    ret = cfs_read (cfs, buf, max);
+    if (-1 == ret)
+    {
+      LOG ("Failed to read decompressed stream for seek operation\n");
+      return -1;
+    }
+    if (0 == ret)
     {
-      char buf[COM_CHUNK_SIZE];
-      size_t max;
-      int64_t ret;
-
-      max = (sizeof (buf) > delta) ? delta : sizeof (buf);
-      ret = cfs_read (cfs, buf, max);
-      if (-1 == ret)
-        {
-          LOG ("Failed to read decompressed stream for seek operation\n");
-          return -1;
-        }
-      if (0 == ret)
-        {
-          LOG ("Reached unexpected end of stream at %llu during seek operation to %llu (%d left)\n",
-               (unsigned long long) cfs->fpos,
-               (unsigned long long) nposition,
-               delta);
-          return -1;
-        }
-      ASSERT (ret <= delta);
-      delta -= ret;
+      LOG (
+        "Reached unexpected end of stream at %llu during seek operation to %llu (%d left)\n",
+        (unsigned long long) cfs->fpos,
+        (unsigned long long) nposition,
+        delta);
+      return -1;
     }
+    ASSERT (ret <= delta);
+    delta -= ret;
+  }
   return cfs->fpos;
 }
 
@@ -1186,8 +1200,8 @@ struct EXTRACTOR_Datasource
  */
 struct EXTRACTOR_Datasource *
 EXTRACTOR_datasource_create_from_file_ (const char *filename,
-                                        EXTRACTOR_MetaDataProcessor proc,
-                                        void *proc_cls)
+                                        EXTRACTOR_MetaDataProcessor proc,
+                                        void *proc_cls)
 {
   struct BufferedFileDataSource *bfds;
   struct EXTRACTOR_Datasource *ds;
@@ -1201,56 +1215,56 @@ EXTRACTOR_datasource_create_from_file_ (const char *filename,
 #endif
 
   if (-1 == (fd = OPEN (filename, O_RDONLY | O_LARGEFILE | winmode)))
-    {
-      LOG_STRERROR_FILE ("open", filename);
-      return NULL;
-    }
+  {
+    LOG_STRERROR_FILE ("open", filename);
+    return NULL;
+  }
   if ( (0 != FSTAT (fd, &sb)) ||
        (S_ISDIR (sb.st_mode)) )
-    {
-      if (! S_ISDIR (sb.st_mode))
-        LOG_STRERROR_FILE ("fstat", filename);
-      else
-        LOG ("Skipping directory `%s'\n", filename);
-      (void) CLOSE (fd);
-      return NULL;
-    }
+  {
+    if (! S_ISDIR (sb.st_mode))
+      LOG_STRERROR_FILE ("fstat", filename);
+    else
+      LOG ("Skipping directory `%s'\n", filename);
+    (void) CLOSE (fd);
+    return NULL;
+  }
   fsize = (int64_t) sb.st_size;
   if (0 == fsize)
-    {
-      (void) CLOSE (fd);
-      return NULL;
-    }
+  {
+    (void) CLOSE (fd);
+    return NULL;
+  }
   bfds = bfds_new (NULL, fd, fsize);
   if (NULL == bfds)
-    {
-      (void) CLOSE (fd);
-      return NULL;
-    }
+  {
+    (void) CLOSE (fd);
+    return NULL;
+  }
   if (NULL == (ds = malloc (sizeof (struct EXTRACTOR_Datasource))))
-    {
-      LOG_STRERROR ("malloc");
-      bfds_delete (bfds);
-      (void) CLOSE (fd);
-      return NULL;
-    }
+  {
+    LOG_STRERROR ("malloc");
+    bfds_delete (bfds);
+    (void) CLOSE (fd);
+    return NULL;
+  }
   ds->bfds = bfds;
   ds->fd = fd;
   ds->cfs = NULL;
   ct = get_compression_type (bfds);
   if ( (COMP_TYPE_ZLIB == ct) ||
        (COMP_TYPE_BZ2 == ct) )
+  {
+    ds->cfs = cfs_new (bfds, fsize, ct, proc, proc_cls);
+    if (NULL == ds->cfs)
     {
-      ds->cfs = cfs_new (bfds, fsize, ct, proc, proc_cls);
-      if (NULL == ds->cfs)
-        {
-          LOG ("Failed to initialize decompressor\n");
-          bfds_delete (bfds);
-          free (ds);
-          (void) CLOSE (fd);
-          return NULL;
-        }
+      LOG ("Failed to initialize decompressor\n");
+      bfds_delete (bfds);
+      free (ds);
+      (void) CLOSE (fd);
+      return NULL;
     }
+  }
   return ds;
 }
 
@@ -1266,8 +1280,9 @@ EXTRACTOR_datasource_create_from_file_ (const char *filename,
  */
 struct EXTRACTOR_Datasource *
 EXTRACTOR_datasource_create_from_buffer_ (const char *buf,
-                                          size_t size,
-                                          EXTRACTOR_MetaDataProcessor proc, void *proc_cls)
+                                          size_t size,
+                                          EXTRACTOR_MetaDataProcessor proc,
+                                          void *proc_cls)
 {
   struct BufferedFileDataSource *bfds;
   struct EXTRACTOR_Datasource *ds;
@@ -1276,32 +1291,32 @@ EXTRACTOR_datasource_create_from_buffer_ (const char *buf,
   if (0 == size)
     return NULL;
   if (NULL == (bfds = bfds_new (buf, -1, size)))
-    {
-      LOG ("Failed to initialize buffer data source\n");
-      return NULL;
-    }
+  {
+    LOG ("Failed to initialize buffer data source\n");
+    return NULL;
+  }
   if (NULL == (ds = malloc (sizeof (struct EXTRACTOR_Datasource))))
-    {
-      LOG_STRERROR ("malloc");
-      bfds_delete (bfds);
-      return NULL;
-    }
+  {
+    LOG_STRERROR ("malloc");
+    bfds_delete (bfds);
+    return NULL;
+  }
   ds->bfds = bfds;
   ds->fd = -1;
   ds->cfs = NULL;
   ct = get_compression_type (bfds);
   if ( (COMP_TYPE_ZLIB == ct) ||
        (COMP_TYPE_BZ2 == ct) )
+  {
+    ds->cfs = cfs_new (bfds, size, ct, proc, proc_cls);
+    if (NULL == ds->cfs)
     {
-      ds->cfs = cfs_new (bfds, size, ct, proc, proc_cls);
-      if (NULL == ds->cfs)
-        {
-          LOG ("Failed to initialize decompressor\n");
-          bfds_delete (bfds);
-          free (ds);
-          return NULL;
-        }
+      LOG ("Failed to initialize decompressor\n");
+      bfds_delete (bfds);
+      free (ds);
+      return NULL;
     }
+  }
   return ds;
 }
 
@@ -1334,8 +1349,8 @@ EXTRACTOR_datasource_destroy_ (struct EXTRACTOR_Datasource *ds)
  */
 ssize_t
 EXTRACTOR_datasource_read_ (void *cls,
-                            void *data,
-                            size_t size)
+                            void *data,
+                            size_t size)
 {
   struct EXTRACTOR_Datasource *ds = cls;
 
@@ -1357,23 +1372,23 @@ EXTRACTOR_datasource_read_ (void *cls,
  */
 int64_t
 EXTRACTOR_datasource_seek_ (void *cls,
-                            int64_t pos,
-                            int whence)
+                            int64_t pos,
+                            int whence)
 {
   struct EXTRACTOR_Datasource *ds = cls;
 
   if (NULL != ds->cfs)
+  {
+    if ( (SEEK_END == whence) &&
+         (-1 == ds->cfs->uncompressed_size) )
     {
-      if ( (SEEK_END == whence) &&
-           (-1 == ds->cfs->uncompressed_size) )
-        {
-          /* need to obtain uncompressed size */
-          (void) EXTRACTOR_datasource_get_size_ (ds, 1);
-          if (-1 == ds->cfs->uncompressed_size)
-            return -1;
-        }
-      return cfs_seek (ds->cfs, pos, whence);
+      /* need to obtain uncompressed size */
+      (void) EXTRACTOR_datasource_get_size_ (ds, 1);
+      if (-1 == ds->cfs->uncompressed_size)
+        return -1;
     }
+    return cfs_seek (ds->cfs, pos, whence);
+  }
   return bfds_seek (ds->bfds, pos, whence);
 }
 
@@ -1387,30 +1402,32 @@ EXTRACTOR_datasource_seek_ (void *cls,
  */
 int64_t
 EXTRACTOR_datasource_get_size_ (void *cls,
-                                int force)
+                                int force)
 {
   struct EXTRACTOR_Datasource *ds = cls;
   char buf[32 * 1024];
   uint64_t pos;
 
   if (NULL != ds->cfs)
+  {
+    if ( (force) &&
+         (-1 == ds->cfs->uncompressed_size) )
     {
-      if ( (force) &&
-           (-1 == ds->cfs->uncompressed_size) )
-        {
-          pos = ds->cfs->fpos;
-          while ( (-1 == ds->cfs->uncompressed_size) &&
-                  (-1 != cfs_read (ds->cfs, buf, sizeof (buf))) ) ;
-          if (-1 == cfs_seek (ds->cfs, pos, SEEK_SET))
-            {
-              LOG ("Serious problem, I moved the buffer to determine the file size but could not restore it...\n");
-              return -1;
-            }
-          if (-1 == ds->cfs->uncompressed_size)
-            return -1;
-        }
-      return ds->cfs->uncompressed_size;
+      pos = ds->cfs->fpos;
+      while ( (-1 == ds->cfs->uncompressed_size) &&
+              (-1 != cfs_read (ds->cfs, buf, sizeof (buf))) )
+        ;
+      if (-1 == cfs_seek (ds->cfs, pos, SEEK_SET))
+      {
+        LOG (
+          "Serious problem, I moved the buffer to determine the file size but could not restore it...\n");
+        return -1;
+      }
+      if (-1 == ds->cfs->uncompressed_size)
+        return -1;
     }
+    return ds->cfs->uncompressed_size;
+  }
   return ds->bfds->fsize;
 }