1 files changed, 380 insertions, 0 deletions

diff --git a/src/plugins/png_extractor.c b/src/plugins/png_extractor.c
new file mode 100644
index 0000000..5fb2b9d
--- /dev/null
+++ b/src/plugins/png_extractor.c
@@ -0,0 +1,380 @@
+/*
+     This file is part of libextractor.
+     (C) 2002, 2003, 2004, 2005, 2009 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
+     option) any later version.
+
+     libextractor 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
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with libextractor; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+ */
+
+#include "platform.h"
+#include "extractor.h"
+#include <zlib.h>
+#include "convert.h"
+
+static char *
+stndup (const char *str, size_t n)
+{
+  char *tmp;
+  tmp = malloc (n + 1);
+  tmp[n] = '\0';
+  memcpy (tmp, str, n);
+  return tmp;
+}
+
+/**
+ * strnlen is GNU specific, let's redo it here to be
+ * POSIX compliant.
+ */
+static size_t
+stnlen (const char *str, size_t maxlen)
+{
+  size_t ret;
+  ret = 0;
+  while ((ret < maxlen) && (str[ret] != '\0'))
+    ret++;
+  return ret;
+}
+
+
+static int
+getIntAt (const void *pos)
+{
+  char p[4];
+
+  memcpy (p, pos, 4);           /* ensure alignment! */
+  return *(int *) &p[0];
+}
+
+
+static struct
+{
+  char *name;
+  enum EXTRACTOR_MetaType type;
+} tagmap[] =
+{
+  { "Author", EXTRACTOR_METATYPE_AUTHOR_NAME},
+  { "Description", EXTRACTOR_METATYPE_DESCRIPTION},
+  { "Comment", EXTRACTOR_METATYPE_COMMENT},
+  { "Copyright", EXTRACTOR_METATYPE_COPYRIGHT},
+  { "Source", EXTRACTOR_METATYPE_SOURCE_DEVICE },
+  { "Creation Time", EXTRACTOR_METATYPE_CREATION_DATE},
+  { "Title", EXTRACTOR_METATYPE_TITLE},
+  { "Software", EXTRACTOR_METATYPE_PRODUCED_BY_SOFTWARE},
+  { "Disclaimer", EXTRACTOR_METATYPE_DISCLAIMER},
+  { "Warning", EXTRACTOR_METATYPE_WARNING},
+  { NULL, EXTRACTOR_METATYPE_RESERVED }
+};
+
+
+#define ADD(t,s) do { if (0 != (ret = proc (proc_cls, "tar", t, EXTRACTOR_METAFORMAT_UTF8, "text/plain", s, strlen(s)+1))) goto FINISH; } while (0)
+#define ADDF(t,s) do { if (0 != (ret = proc (proc_cls, "tar", t, EXTRACTOR_METAFORMAT_UTF8, "text/plain", s, strlen(s)+1))) { free(s); goto FINISH; } free (s); } while (0)
+
+
+static int
+processtEXt (const char *data,
+             unsigned int length,
+             EXTRACTOR_MetaDataProcessor proc,
+             void *proc_cls)
+{
+  char *keyword;
+  unsigned int off;
+  int i;
+  int ret;
+
+  data += 4;
+  off = stnlen (data, length) + 1;
+  if (off >= length)
+    return 0;                /* failed to find '\0' */
+  keyword = EXTRACTOR_common_convert_to_utf8 (&data[off], length - off, "ISO-8859-1");
+  i = 0;
+  ret = 0;
+  while (tagmap[i].name != NULL)
+    {
+      if (0 == strcmp (tagmap[i].name, data))
+        {
+          ADDF (tagmap[i].type, keyword);
+          return 0;
+        }
+
+      i++;
+    }
+  ADDF (EXTRACTOR_METATYPE_KEYWORDS, keyword);
+ FINISH:
+  return ret;
+}
+
+static int
+processiTXt (const char *data,
+             unsigned int length, 
+             EXTRACTOR_MetaDataProcessor proc,
+             void *proc_cls)
+{
+  unsigned int pos;
+  char *keyword;
+  const char *language;
+  const char *translated;
+  int i;
+  int compressed;
+  char *buf;
+  uLongf bufLen;
+  int ret;
+  int zret;
+
+  pos = stnlen (data, length) + 1;
+  if (pos + 3 >= length)
+    return 0;
+  compressed = data[pos++];
+  if (compressed && (data[pos++] != 0))
+    return 0;                /* bad compression method */
+  language = &data[pos];
+  ret = 0;
+  if (stnlen (language, length - pos) > 0)
+    ADDF (EXTRACTOR_METATYPE_DOCUMENT_LANGUAGE,
+          stndup (language, length - pos));
+  pos += stnlen (language, length - pos) + 1;
+  if (pos + 1 >= length)
+    return 0;
+  translated = &data[pos];      /* already in utf-8! */
+  if (stnlen (translated, length - pos) > 0)
+    ADDF (EXTRACTOR_METATYPE_KEYWORDS,
+          stndup (translated, length - pos));
+  pos += stnlen (translated, length - pos) + 1;
+  if (pos >= length)
+    return 0;
+
+  if (compressed)
+    {
+      bufLen = 1024 + 2 * (length - pos);
+      while (1)
+        {
+          if (bufLen * 2 < bufLen)
+            return 0;
+          bufLen *= 2;
+          if (bufLen > 50 * (length - pos))
+            {
+              /* printf("zlib problem"); */
+              return 0;
+            }
+          buf = malloc (bufLen);
+          if (buf == NULL)
+            {
+              /* printf("out of memory"); */
+              return 0;      /* out of memory */
+            }
+          zret = uncompress ((Bytef *) buf,
+                            &bufLen,
+                            (const Bytef *) &data[pos], length - pos);
+          if (zret == Z_OK)
+            {
+              /* printf("zlib ok"); */
+              break;
+            }
+          free (buf);
+          if (zret != Z_BUF_ERROR)
+            return 0;        /* unknown error, abort */
+        }
+      keyword = stndup (buf, bufLen);
+      free (buf);
+    }
+  else
+    {
+      keyword = stndup (&data[pos], length - pos);
+    }
+  i = 0;
+  while (tagmap[i].name != NULL)
+    {
+      if (0 == strcmp (tagmap[i].name, data))
+        {
+          ADDF (tagmap[i].type, keyword /* already in utf8 */);
+          return 0;
+        }
+      i++;
+    }
+  ADDF (EXTRACTOR_METATYPE_COMMENT, keyword);
+ FINISH:
+  return ret;
+}
+
+
+static int
+processIHDR (const char *data,
+             unsigned int length, 
+             EXTRACTOR_MetaDataProcessor proc,
+             void *proc_cls)
+{
+  char tmp[128];
+  int ret;
+
+  if (length < 12)
+    return 0;
+  ret = 0;
+  snprintf (tmp,
+            sizeof(tmp),
+            "%ux%u",
+            htonl (getIntAt (&data[4])), htonl (getIntAt (&data[8])));
+  ADD (EXTRACTOR_METATYPE_IMAGE_DIMENSIONS, tmp);
+ FINISH:
+  return ret;
+}
+
+static int
+processzTXt (const char *data,
+             unsigned int length,
+             EXTRACTOR_MetaDataProcessor proc,
+             void *proc_cls)
+{
+  char *keyword;
+  unsigned int off;
+  int i;
+  char *buf;
+  uLongf bufLen;
+  int ret;
+  int zret;
+
+  data += 4;
+  off = stnlen (data, length) + 1;
+  if (off >= length)
+    return 0;                /* failed to find '\0' */
+  if (data[off] != 0)
+    return 0;                /* compression method must be 0 */
+  off++;
+
+  bufLen = 1024 + 2 * (length - off);
+  while (1)
+    {
+      if (bufLen * 2 < bufLen)
+        return 0;
+      bufLen *= 2;
+      if (bufLen > 50 * (length - off))
+        {
+          /* printf("zlib problem"); */
+          return 0;
+        }
+      buf = malloc (bufLen);
+      if (buf == NULL)
+        {
+          /* printf("out of memory"); */
+          return 0;          /* out of memory */
+        }
+      zret = uncompress ((Bytef *) buf,
+                         &bufLen, (const Bytef *) &data[off], length - off);
+      if (zret == Z_OK)
+        {
+          /* printf("zlib ok"); */
+          break;
+        }
+      free (buf);
+      if (zret != Z_BUF_ERROR)
+        return 0;            /* unknown error, abort */
+    }
+  keyword = EXTRACTOR_common_convert_to_utf8 (buf, bufLen, "ISO-8859-1");
+  free (buf);
+  i = 0;
+  while (tagmap[i].name != NULL)
+    {
+      if (0 == strcmp (tagmap[i].name, data))
+        {
+          ADDF (tagmap[i].type, keyword);
+          return 0;
+        }
+      i++;
+    }
+  ADDF (EXTRACTOR_METATYPE_COMMENT, keyword);
+ FINISH:
+  return ret;
+}
+
+static int
+processtIME (const char *data,
+             unsigned int length,
+             EXTRACTOR_MetaDataProcessor proc,
+             void *proc_cls)
+{
+  unsigned short y;
+  unsigned int year;
+  unsigned int mo;
+  unsigned int day;
+  unsigned int h;
+  unsigned int m;
+  unsigned int s;
+  char val[256];
+  int ret;
+
+  if (length != 7)
+    return 0;
+  ret = 0;
+  memcpy (&y, &data[4], sizeof (unsigned short));
+  year = ntohs (y);
+  mo = (unsigned char) data[6];
+  day = (unsigned char) data[7];
+  h = (unsigned char) data[8];
+  m = (unsigned char) data[9];
+  s = (unsigned char) data[10];
+  snprintf (val, 
+            sizeof(val),
+            "%04u-%02u-%02u %02d:%02d:%02d", year, mo, day, h, m, s);
+  ADD (EXTRACTOR_METATYPE_MODIFICATION_DATE, val);
+ FINISH:
+  return ret;
+}
+
+#define PNG_HEADER "\211PNG\r\n\032\n"
+
+
+
+int 
+EXTRACTOR_png_extract (const char *data,
+                       size_t size,
+                       EXTRACTOR_MetaDataProcessor proc,
+                       void *proc_cls,
+                       const char *options)
+{
+  const char *pos;
+  const char *end;
+  unsigned int length;
+  int ret;
+
+  if (size < strlen (PNG_HEADER))
+    return 0;
+  if (0 != strncmp (data, PNG_HEADER, strlen (PNG_HEADER)))
+    return 0;
+  end = &data[size];
+  pos = &data[strlen (PNG_HEADER)];
+  ADD (EXTRACTOR_METATYPE_MIMETYPE, "image/png");
+  ret = 0;
+  while (ret == 0)
+    {
+      if (pos + 12 >= end)
+        break;
+      length = htonl (getIntAt (pos));
+      pos += 4;
+      /* printf("Length: %u, pos %u\n", length, pos - data); */
+      if ((pos + 4 + length + 4 > end) || (pos + 4 + length + 4 < pos + 8))
+        break;
+      if (0 == strncmp (pos, "IHDR", 4))
+        ret = processIHDR (pos, length, proc, proc_cls);
+      if (0 == strncmp (pos, "iTXt", 4))
+        ret = processiTXt (pos, length, proc, proc_cls);
+      if (0 == strncmp (pos, "tEXt", 4))
+        ret = processtEXt (pos, length, proc, proc_cls);
+      if (0 == strncmp (pos, "zTXt", 4))
+        ret = processzTXt (pos, length, proc, proc_cls);
+      if (0 == strncmp (pos, "tIME", 4))
+        ret = processtIME (pos, length, proc, proc_cls);
+      pos += 4 + length + 4;    /* Chunk type, data, crc */
+    }
+ FINISH:
+  return ret;
+}