1 files changed, 311 insertions, 155 deletions

diff --git a/src/plugins/deb_extractor.c b/src/plugins/deb_extractor.c
index 2bb90c5..955657e 100644
--- a/src/plugins/deb_extractor.c
+++ b/src/plugins/deb_extractor.c
@@ -1,10 +1,10 @@
 /*
      This file is part of libextractor.
-     (C) 2002, 2003, 2004 Vidyut Samanta and Christian Grothoff
+     (C) 2002, 2003, 2004, 2012 Vidyut Samanta and Christian Grothoff
 
      libextractor is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
-     by the Free Software Foundation; either version 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      libextractor is distributed in the hope that it will be useful, but
@@ -17,12 +17,11 @@
      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      Boston, MA 02111-1307, USA.
  */
-
-#include "platform.h"
-#include "extractor.h"
-#include <zlib.h>
-
-/*
+/**
+ * @file plugins/deb_extractor.c
+ * @brief plugin to support Debian archives 
+ * @author Christian Grothoff
+ *
  * The .deb is an ar-chive file.  It contains a tar.gz file
  * named "control.tar.gz" which then contains a file 'control'
  * that has the meta-data.  And which variant of the various
@@ -33,14 +32,33 @@
  * http://lists.debian.org/debian-policy/2003/12/msg00000.html
  * http://www.opengroup.org/onlinepubs/009695399/utilities/ar.html
  */
+#include "platform.h"
+#include "extractor.h"
+#include <zlib.h>
+
+
+/**
+ * Maximum file size we allow for control.tar.gz files.
+ * This is a sanity check to avoid allocating huge amounts
+ * of memory.
+ */
+#define MAX_CONTROL_SIZE (1024 * 1024)
 
 
+/**
+ * Re-implementation of 'strndup'.
+ *
+ * @param str string to duplicate
+ * @param n maximum number of bytes to copy
+ * @return NULL on error, otherwise 0-terminated copy of 'str'
+ *         with at most n characters
+ */
 static char *
 stndup (const char *str, size_t n)
 {
   char *tmp;
-  tmp = malloc (n + 1);
-  if (tmp == NULL)
+
+  if (NULL == (tmp = malloc (n + 1)))
     return NULL;
   tmp[n] = '\0';
   memcpy (tmp, str, n);
@@ -48,15 +66,29 @@ stndup (const char *str, size_t n)
 }
 
 
-
-typedef struct
+/**
+ * Entry in the mapping from control data to LE types.
+ */
+struct Matches
 {
+  /**
+   * Key in the Debian control file.
+   */
   const char *text;
+
+  /**
+   * Corresponding type in LE.
+   */
   enum EXTRACTOR_MetaType type;
-} Matches;
+};
+
 
-/* see also: "man 5 deb-control" */
-static Matches tmap[] = {
+/**
+ * Map from deb-control entries to LE types.
+ *
+ * see also: "man 5 deb-control" 
+ */
+static struct Matches tmap[] = {
   {"Package: ",       EXTRACTOR_METATYPE_PACKAGE_NAME},
   {"Version: ",       EXTRACTOR_METATYPE_PACKAGE_VERSION},
   {"Section: ",       EXTRACTOR_METATYPE_SECTION},
@@ -79,7 +111,13 @@ static Matches tmap[] = {
 
 
 /**
- * Process the control file.
+ * Process the "control" file from the control.tar.gz
+ *
+ * @param data decompressed control data
+ * @param size number of bytes in data
+ * @param proc function to call with meta data
+ * @param proc_cls closure for 'proc'
+ * @return 0 to continue extracting, 1 if we are done
  */
 static int
 processControl (const char *data,
@@ -90,62 +128,52 @@ processControl (const char *data,
   size_t pos;
   char *key;
   char *val;
-
+  size_t colon;
+  size_t eol;
+  unsigned int i;
+  
   pos = 0;
   while (pos < size)
     {
-      size_t colon;
-      size_t eol;
-      int i;
-
-      colon = pos;
-      while (data[colon] != ':')
-        {
-          if ((colon > size) || (data[colon] == '\n'))
-            return 0;
-          colon++;
-        }
+      for (colon = pos; ':' != data[colon]; colon++)
+        if ((colon > size) || ('\n' == data[colon]))
+          return 0;
       colon++;
       while ((colon < size) && (isspace ((unsigned char) data[colon])))
         colon++;
       eol = colon;
       while ((eol < size) &&
-             ((data[eol] != '\n') ||
-              ((eol + 1 < size) && (data[eol + 1] == ' '))))
+             (('\n' != data[eol]) ||
+              ((eol + 1 < size) && (' '  == data[eol + 1]))))
         eol++;
       if ((eol == colon) || (eol > size))
         return 0;
-      key = stndup (&data[pos], colon - pos);
-      if (key == NULL)
+      if (NULL == (key = stndup (&data[pos], colon - pos)))
         return 0;
-      i = 0;
-      while (tmap[i].text != NULL)
+      for (i = 0; NULL != tmap[i].text; i++)
         {
-          if (0 == strcmp (key, tmap[i].text))
-            {
-              val = stndup (&data[colon], eol - colon);
-              if (val == NULL)
-                {
-                  free (key);
-                  return 0;
-                }
-              if (0 != proc (proc_cls, 
-                             "deb",
-                             tmap[i].type,
-                             EXTRACTOR_METAFORMAT_UTF8,
-                             "text/plain",
-                             val,
-                             strlen(val) + 1))
-                {
-                  free (val);
-                  free (key);
-                  return 1;
-                }
+          if (0 != strcmp (key, tmap[i].text))
+            continue;
+          if (NULL == (val = stndup (&data[colon], eol - colon)))
+            {
+              free (key);
+              return 0;
+            }
+          if (0 != proc (proc_cls, 
+                         "deb",
+                         tmap[i].type,
+                         EXTRACTOR_METAFORMAT_UTF8,
+                         "text/plain",
+                         val,
+                         strlen(val) + 1))
+            {
               free (val);
-              break;
-            }
-          i++;
-        }
+              free (key);
+              return 1;
+            }
+          free (val);
+          break;
+        }
       free (key);
       pos = eol + 1;
     }
@@ -153,62 +181,142 @@ processControl (const char *data,
 }
 
 
-typedef struct
+/**
+ * Header of an entry in a TAR file.
+ */
+struct TarHeader
 {
+  /**
+   * Filename.
+   */
   char name[100];
+ 
+  /**
+   * File access modes.
+   */
   char mode[8];
+
+  /**
+   * Owner of the file.
+   */
   char userId[8];
+
+  /**
+   * Group of the file.
+   */
   char groupId[8];
+
+  /**
+   * Size of the file, in octal.
+   */
   char filesize[12];
+  
+  /**
+   * Last modification time.
+   */
   char lastModTime[12];
+
+  /**
+   * Checksum of the file.
+   */
   char chksum[8];
+
+  /**
+   * Is the file a link?
+   */
   char link;
+
+  /**
+   * Destination of the link.
+   */
   char linkName[100];
-} TarHeader;
+};
+
 
-typedef struct
+/**
+ * Extended TAR header for USTar format.
+ */
+struct USTarHeader
 {
-  TarHeader tar;
+  /**
+   * Original TAR header.
+   */
+  struct TarHeader tar;
+
+  /**
+   * Additinal magic for USTar.
+   */
   char magic[6];
+
+  /**
+   * Format version.
+   */
   char version[2];
+
+  /**
+   * User name.
+   */
   char uname[32];
+
+  /**
+   * Group name.
+   */
   char gname[32];
+
+  /**
+   * Device major number.
+   */
   char devmajor[8];
+
+  /**
+   * Device minor number.
+   */
   char devminor[8];
+
+  /**
+   * Unknown (padding?).
+   */
   char prefix[155];
-} USTarHeader;
+};
+
 
 /**
  * Process the control.tar file.
+ *
+ * @param data the deflated control.tar file data
+ * @param size number of bytes in data
+ * @param proc function to call with meta data
+ * @param proc_cls closure for 'proc'
+ * @return 0 to continue extracting, 1 if we are done
  */
 static int
 processControlTar (const char *data,
-                   const size_t size,
+                   size_t size,
                    EXTRACTOR_MetaDataProcessor proc,
                    void *proc_cls)
 {
-  TarHeader *tar;
-  USTarHeader *ustar;
+  struct TarHeader *tar;
+  struct USTarHeader *ustar;
   size_t pos;
 
   pos = 0;
-  while (pos + sizeof (TarHeader) < size)
+  while (pos + sizeof (struct TarHeader) < size)
     {
       unsigned long long fsize;
       char buf[13];
 
-      tar = (TarHeader *) & data[pos];
-      if (pos + sizeof (USTarHeader) < size)
+      tar = (struct TarHeader *) & data[pos];
+      if (pos + sizeof (struct USTarHeader) < size)
         {
-          ustar = (USTarHeader *) & data[pos];
+          ustar = (struct USTarHeader *) & data[pos];
           if (0 == strncmp ("ustar", &ustar->magic[0], strlen ("ustar")))
-            pos += 512;         /* sizeof(USTarHeader); */
+            pos += 512;         /* sizeof (struct USTarHeader); */
           else
-            pos += 257;         /* sizeof(TarHeader); minus gcc alignment... */
+            pos += 257;         /* sizeof (struct TarHeader); minus gcc alignment... */
         }
       else
         {
-          pos += 257;           /* sizeof(TarHeader); minus gcc alignment... */
+          pos += 257;           /* sizeof (struct TarHeader); minus gcc alignment... */
         }
 
       memcpy (buf, &tar->filesize[0], 12);
@@ -220,9 +328,10 @@ processControlTar (const char *data,
 
       if (0 == strncmp (&tar->name[0], "./control", strlen ("./control")))
         {
+          /* found the 'control' file we were looking for */
           return processControl (&data[pos], fsize, proc, proc_cls);
         }
-      if ((fsize & 511) != 0)
+      if (0 != (fsize & 511))
         fsize = (fsize | 511) + 1;      /* round up! */
       if (pos + fsize < pos)
         return 0;
@@ -231,137 +340,184 @@ processControlTar (const char *data,
   return 0;
 }
 
-#define MAX_CONTROL_SIZE (1024 * 1024)
-
-static voidpf
-Emalloc (voidpf opaque, uInt items, uInt size)
-{
-  if (SIZE_MAX / size <= items)
-    return NULL;
-  return malloc (size * items);
-}
-
-static void
-Efree (voidpf opaque, voidpf ptr)
-{
-  free (ptr);
-}
 
 /**
  * Process the control.tar.gz file.
+ *
+ * @param ec extractor context with control.tar.gz at current read position
+ * @param size number of bytes in the control file
+ * @return 0 to continue extracting, 1 if we are done
  */
 static int
-processControlTGZ (const unsigned char *data,
-                   size_t size, 
-                   EXTRACTOR_MetaDataProcessor proc,
-                   void *proc_cls)
+processControlTGZ (struct EXTRACTOR_ExtractContext *ec,
+                   unsigned long long size)
 {
   uint32_t bufSize;
   char *buf;
+  void *data;
+  unsigned char *cdata;
   z_stream strm;
   int ret;
+  ssize_t sret;
+  unsigned long long off;
 
-  bufSize = data[size - 4] + (data[size - 3] << 8) + (data[size - 2] << 16) + (data[size - 1] << 24);
-  if (bufSize > MAX_CONTROL_SIZE)
+  if (size > MAX_CONTROL_SIZE)
+    return 0;
+  if (NULL == (cdata = malloc (size)))
     return 0;
+  off = 0;
+  while (off < size)
+    {
+      if (0 >= (sret = ec->read (ec->cls, &data, size - off)))
+        {
+          free (cdata);
+          return 0;
+        }
+      memcpy (&cdata[off], data, sret);
+      off += sret;
+    }
+  bufSize = cdata[size - 4] + (cdata[size - 3] << 8) + (cdata[size - 2] << 16) + (cdata[size - 1] << 24);
+  if (bufSize > MAX_CONTROL_SIZE)
+    {
+      free (cdata);
+      return 0;
+    }
+  if (NULL == (buf = malloc (bufSize)))
+    {
+      free (cdata);
+      return 0;
+    }
+  ret = 0;
   memset (&strm, 0, sizeof (z_stream));
   strm.next_in = (Bytef *) data;
   strm.avail_in = size;
-  strm.total_in = 0;
-  strm.zalloc = &Emalloc;
-  strm.zfree = &Efree;
-  strm.opaque = NULL;
-
   if (Z_OK == inflateInit2 (&strm, 15 + 32))
-    {
-      buf = malloc (bufSize);
-      if (buf == NULL)
-        {
-          inflateEnd (&strm);
-          return 0;
-        }
+    {  
       strm.next_out = (Bytef *) buf;
       strm.avail_out = bufSize;
       inflate (&strm, Z_FINISH);
       if (strm.total_out > 0)
-        {
-          ret = processControlTar (buf, strm.total_out, proc, proc_cls);
-          inflateEnd (&strm);
-          free (buf);
-          return ret;
-        }
-      free (buf);
+        ret = processControlTar (buf, strm.total_out, 
+                                 ec->proc, ec->cls);
       inflateEnd (&strm);
     }
-  return 0;
+  free (buf);
+  free (cdata);
+  return ret;
 }
 
-typedef struct
+
+/**
+ * Header of an object in an "AR"chive file.
+ */
+struct ObjectHeader
 {
+  /**
+   * Name of the file.
+   */
   char name[16];
+
+  /**
+   * Last modification time for the file.
+   */
   char lastModTime[12];
+
+  /**
+   * User ID of the owner.
+   */
   char userId[6];
+
+  /**
+   * Group ID of the owner.
+   */
   char groupId[6];
+
+  /**
+   * File access modes.
+   */
   char modeInOctal[8];
+
+  /**
+   * Size of the file (as decimal string)
+   */
   char filesize[10];
+
+  /**
+   * Tailer of the object header ("`\n")
+   */
   char trailer[2];
-} ObjectHeader;
+};
 
 
-int 
-EXTRACTOR_deb_extract (const char *data,
-                       size_t size,
-                       EXTRACTOR_MetaDataProcessor proc,
-                       void *proc_cls,
-                       const char *options)
+/**
+ * Main entry method for the DEB extraction plugin.  
+ *
+ * @param ec extraction context provided to the plugin
+ */
+void 
+EXTRACTOR_deb_extract_method (struct EXTRACTOR_ExtractContext *ec)
 {
-  size_t pos;
+  uint64_t pos;
   int done = 0;
-  ObjectHeader *hdr;
-  unsigned long long fsize;
+  const struct ObjectHeader *hdr;
+  uint64_t fsize;
+  unsigned long long csize;
   char buf[11];
-
-  if (size < 128)
-    return 0;
-  if (0 != strncmp ("!<arch>\n", data, strlen ("!<arch>\n")))
-    return 0;
-  pos = strlen ("!<arch>\n");
-  while (pos + sizeof (ObjectHeader) < size)
+  void *data;
+
+  fsize = ec->get_size (ec->cls);
+  if (fsize < 128)
+    return;
+  if (8 !=
+      ec->read (ec->cls, &data, 8))
+    return;
+  if (0 != strncmp ("!<arch>\n", data, 8))
+    return;
+  pos = 8;
+  while (pos + sizeof (struct ObjectHeader) < fsize)
     {
-      hdr = (ObjectHeader *) & data[pos];
+      if (pos !=
+          ec->seek (ec->cls, pos, SEEK_SET))
+        return;
+      if (sizeof (struct ObjectHeader) !=
+          ec->read (ec->cls, &data, sizeof (struct ObjectHeader)))
+        return;
+      hdr = data;
       if (0 != strncmp (&hdr->trailer[0], "`\n", 2))
-        return 0;
+        return;
       memcpy (buf, &hdr->filesize[0], 10);
       buf[10] = '\0';
-      if (1 != sscanf (buf, "%10llu", &fsize))
-        return 0;
-      pos += sizeof (ObjectHeader);
-      if ((pos + fsize > size) || (fsize > size) || (pos + fsize < pos))
-        return 0;
+      if (1 != sscanf (buf, "%10llu", &csize))
+        return;
+      pos += sizeof (struct ObjectHeader);
+      if ((pos + csize > fsize) || (csize > fsize) || (pos + csize < pos))
+        return;
       if (0 == strncmp (&hdr->name[0],
-                        "control.tar.gz", strlen ("control.tar.gz")))
+                        "control.tar.gz", 
+                        strlen ("control.tar.gz")))
         {
-          if (0 != processControlTGZ ((const unsigned char *) &data[pos],
-                                      fsize, proc, proc_cls))
-            return 1;
+          if (0 != processControlTGZ (ec,
+                                      csize))
+            return;
           done++;
         }
       if (0 == strncmp (&hdr->name[0],
                         "debian-binary", strlen ("debian-binary")))
         {
-          if (0 != proc (proc_cls, 
-                         "deb",
-                         EXTRACTOR_METATYPE_MIMETYPE,
-                         EXTRACTOR_METAFORMAT_UTF8,
-                         "text/plain",
-                         "application/x-debian-package",
-                         strlen ("application/x-debian-package")+1))
-            return 1;
+          if (0 != ec->proc (ec->cls, 
+                             "deb",
+                             EXTRACTOR_METATYPE_MIMETYPE,
+                             EXTRACTOR_METAFORMAT_UTF8,
+                             "text/plain",
+                             "application/x-debian-package",
+                             strlen ("application/x-debian-package")+1))
+            return;
           done++;
         }
-      pos += fsize;
-      if (done == 2)
+      pos += csize;
+      if (2 == done)
         break;                  /* no need to process the rest of the archive */
     }
-  return 0;
 }
+
+/* end of deb_extractor.c */