debextractor.c File Reference

#include "platform.h"
#include "extractor.h"
#include <zlib.h>

Go to the source code of this file.

Data Structures
struct	Matches
struct	TarHeader
struct	USTarHeader
struct	ObjectHeader
Defines
#define	MAX_CONTROL_SIZE   (1024 * 1024)
Functions
static EXTRACTOR_KeywordList *	addKeyword (EXTRACTOR_KeywordType type, char *keyword, EXTRACTOR_KeywordList *next)
static char *	stndup (const char *str, size_t n)
static struct EXTRACTOR_Keywords *	processControl (const char *data, const size_t size, struct EXTRACTOR_Keywords *prev)
static struct EXTRACTOR_Keywords *	processControlTar (const char *data, const size_t size, struct EXTRACTOR_Keywords *prev)
static voidpf	Emalloc (voidpf opaque, uInt items, uInt size)
static void	Efree (voidpf opaque, voidpf ptr)
static struct EXTRACTOR_Keywords *	processControlTGZ (const unsigned char *data, size_t size, struct EXTRACTOR_Keywords *prev)
EXTRACTOR_Keywords *	libextractor_deb_extract (const char *filename, const char *data, const size_t size, struct EXTRACTOR_Keywords *prev)
Variables
static Matches	tmap []

---

Define Documentation

#define MAX_CONTROL_SIZE   (1024 * 1024)

Definition at line 224 of file debextractor.c.

Referenced by processControlTGZ().

---

Function Documentation

static EXTRACTOR_KeywordList* addKeyword	(	EXTRACTOR_KeywordType	type,
		char *	keyword,
		EXTRACTOR_KeywordList *	next
	)			[static]

Definition at line 38 of file debextractor.c.

References EXTRACTOR_Keywords::keyword, EXTRACTOR_Keywords::keywordType, malloc, EXTRACTOR_Keywords::next, and NULL.

{
  EXTRACTOR_KeywordList *result;

  if (keyword == NULL)
    return next;
  result = malloc (sizeof (EXTRACTOR_KeywordList));
  result->next = next;
  result->keyword = keyword;
  result->keywordType = type;
  return result;
}

static void Efree	(	voidpf	opaque,
		voidpf	ptr
	)			[static]

Definition at line 233 of file debextractor.c.

References free.

Referenced by processControlTGZ().

{
  free (ptr);
}

static voidpf Emalloc	(	voidpf	opaque,
		uInt	items,
		uInt	size
	)			[static]

Definition at line 227 of file debextractor.c.

References malloc.

Referenced by processControlTGZ().

{
  return malloc (size * items);
}

struct EXTRACTOR_Keywords* libextractor_deb_extract	(	const char *	filename,
		const char *	data,
		const size_t	size,
		struct EXTRACTOR_Keywords *	prev
	)

Definition at line 300 of file debextractor.c.

References addKeyword(), done, EXTRACTOR_MIMETYPE, ObjectHeader::filesize, ObjectHeader::name, processControlTGZ(), and ObjectHeader::trailer.

{
  size_t pos;
  int done = 0;

  if (size < 128)
    return prev;
  if (0 != strncmp ("!<arch>\n", data, strlen ("!<arch>\n")))
    return prev;
  pos = strlen ("!<arch>\n");
  while (pos + sizeof (ObjectHeader) < size)
    {
      ObjectHeader *hdr;
      unsigned long long fsize;
      char buf[11];

      hdr = (ObjectHeader *) & data[pos];
      if (0 != strncmp (&hdr->trailer[0], "`\n", 2))
        return prev;

      memcpy (buf, &hdr->filesize[0], 10);
      buf[10] = '\0';
      if (1 != sscanf (buf, "%10llu", &fsize))
        return prev;
      pos += sizeof (ObjectHeader);
      if ((pos + fsize > size) || (fsize > size) || (pos + fsize < pos))
        return prev;
      if (0 == strncmp (&hdr->name[0],
                        "control.tar.gz", strlen ("control.tar.gz")))
        {
          prev = processControlTGZ ((const unsigned char *) &data[pos],
                                    fsize, prev);
          done++;
        }
      if (0 == strncmp (&hdr->name[0],
                        "debian-binary", strlen ("debian-binary")))
        {
          prev = addKeyword (EXTRACTOR_MIMETYPE,
                             strdup ("application/x-debian-package"), prev);
          done++;
        }
      pos += fsize;
      if (done == 2)
        break;                  /* no need to process the rest of the archive */
    }
  return prev;
}

static struct EXTRACTOR_Keywords* processControl	(	const char *	data,
		const size_t	size,
		struct EXTRACTOR_Keywords *	prev
	)			[static]

Process the control file.

Definition at line 97 of file debextractor.c.

References addKeyword(), free, NULL, stndup(), tmap, and type.

Referenced by processControlTar().

{
  size_t pos;
  char *key;

  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 prev;
          colon++;
        }
      colon++;
      while ((colon < size) && (isspace (data[colon])))
        colon++;
      eol = colon;
      while ((eol < size) &&
             ((data[eol] != '\n') ||
              ((eol + 1 < size) && (data[eol + 1] == ' '))))
        eol++;
      if ((eol == colon) || (eol > size))
        return prev;
      key = stndup (&data[pos], colon - pos);
      i = 0;
      while (tmap[i].text != NULL)
        {
          if (0 == strcmp (key, tmap[i].text))
            {
              char *val;

              val = stndup (&data[colon], eol - colon);
              prev = addKeyword (tmap[i].type, val, prev);
              break;
            }
          i++;
        }
      free (key);
      pos = eol + 1;
    }
  return prev;
}

static struct EXTRACTOR_Keywords* processControlTar	(	const char *	data,
		const size_t	size,
		struct EXTRACTOR_Keywords *	prev
	)			[static]

Process the control.tar file.

Definition at line 177 of file debextractor.c.

References TarHeader::filesize, USTarHeader::magic, TarHeader::name, and processControl().

Referenced by processControlTGZ().

{
  TarHeader *tar;
  USTarHeader *ustar;
  size_t pos;

  pos = 0;
  while (pos + sizeof (TarHeader) < size)
    {
      unsigned long long fsize;
      char buf[13];

      tar = (TarHeader *) & data[pos];
      if (pos + sizeof (USTarHeader) < size)
        {
          ustar = (USTarHeader *) & data[pos];
          if (0 == strncmp ("ustar", &ustar->magic[0], strlen ("ustar")))
            pos += 512;         /* sizeof(USTarHeader); */
          else
            pos += 257;         /* sizeof(TarHeader); minus gcc alignment... */
        }
      else
        {
          pos += 257;           /* sizeof(TarHeader); minus gcc alignment... */
        }

      memcpy (buf, &tar->filesize[0], 12);
      buf[12] = '\0';
      if (1 != sscanf (buf, "%12llo", &fsize))  /* octal! Yuck yuck! */
        return prev;
      if ((pos + fsize > size) || (fsize > size) || (pos + fsize < pos))
        return prev;

      if (0 == strncmp (&tar->name[0], "./control", strlen ("./control")))
        {
          return processControl (&data[pos], fsize, prev);
        }
      if ((fsize & 511) != 0)
        fsize = (fsize | 511) + 1;      /* round up! */
      if (pos + fsize < pos)
        return prev;
      pos += fsize;
    }
  return prev;
}

static struct EXTRACTOR_Keywords* processControlTGZ	(	const unsigned char *	data,
		size_t	size,
		struct EXTRACTOR_Keywords *	prev
	)			[static]

Process the control.tar.gz file.

Definition at line 242 of file debextractor.c.

References Efree(), Emalloc(), free, malloc, MAX_CONTROL_SIZE, NULL, and processControlTar().

Referenced by libextractor_deb_extract().

{
  size_t bufSize;
  char *buf;
  z_stream strm;

  bufSize =
    data[size - 4] + 256 * data[size - 3] + 65536 * data[size - 2] +
    256 * 65536 * data[size - 1];
  if (bufSize > MAX_CONTROL_SIZE)
    return prev;

  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 prev;
        }
      strm.next_out = (Bytef *) buf;
      strm.avail_out = bufSize;
      inflate (&strm, Z_FINISH);
      if (strm.total_out > 0)
        {
          prev = processControlTar (buf, strm.total_out, prev);
          inflateEnd (&strm);
          free (buf);
          return prev;
        }
      free (buf);
      inflateEnd (&strm);
    }
  return prev;
}

static char* stndup	(	const char *	str,
		size_t	n
	)			[static]

Definition at line 53 of file debextractor.c.

References malloc.

Referenced by dateDecode(), libextractor_pdf_extract(), libextractor_real_extract(), processControl(), and processiTXt().

{
  char *tmp;
  tmp = malloc (n + 1);
  tmp[n] = '\0';
  memcpy (tmp, str, n);
  return tmp;
}

---

Variable Documentation

Matches tmap[] [static]

Initial value:

 {
  {"Package: ", EXTRACTOR_SOFTWARE},
  {"Version: ", EXTRACTOR_VERSIONNUMBER},
  {"Section: ", EXTRACTOR_GENRE},
  {"Priority: ", EXTRACTOR_PRIORITY},
  {"Architecture: ", EXTRACTOR_CREATED_FOR},
  {"Depends: ", EXTRACTOR_DEPENDENCY},
  {"Recommends: ", EXTRACTOR_RELATION},
  {"Suggests: ", EXTRACTOR_RELATION},
  {"Installed-Size: ", EXTRACTOR_SIZE},
  {"Maintainer: ", EXTRACTOR_PACKAGER},
  {"Description: ", EXTRACTOR_DESCRIPTION},
  {"Source: ", EXTRACTOR_SOURCE},
  {"Pre-Depends: ", EXTRACTOR_DEPENDENCY},
  {"Conflicts: ", EXTRACTOR_CONFLICTS},
  {"Replaces: ", EXTRACTOR_REPLACES},
  {"Provides: ", EXTRACTOR_PROVIDES},
  {NULL, 0},
  {"Essential: ", EXTRACTOR_UNKNOWN}
}

Definition at line 71 of file debextractor.c.

Referenced by check(), libextractor_id3v23_extract(), libextractor_id3v24_extract(), libextractor_id3v2_extract(), libextractor_oo_extract(), parseZZZ(), processControl(), and processMetadata().

---