7 files changed, 2348 insertions, 0 deletions

diff --git a/Magdir/wireless b/Magdir/wireless
new file mode 100644
index 000000000000..aaae5a58fb67
--- /dev/null
+++ b/Magdir/wireless
@@ -0,0 +1,5 @@
+#------------------------------------------------------------------------------
+# wireless-regdb:        file(1) magic for CRDA wireless-regdb file format
+#
+0	string	RGDB	CRDA wireless regulatory database file
+>4	belong	19	(Version 1)
diff --git a/Makefile.am-src b/Makefile.am-src
new file mode 100644
index 000000000000..db78d96e49d4
--- /dev/null
+++ b/Makefile.am-src
@@ -0,0 +1,18 @@
+MAGIC = $(pkgdatadir)/magic
+lib_LTLIBRARIES = libmagic.la
+include_HEADERS = magic.h
+
+bin_PROGRAMS = file
+
+AM_CPPFLAGS = -DMAGIC='"$(MAGIC)"'
+AM_CFLAGS = @WARNINGS@
+
+libmagic_la_SOURCES = magic.c apprentice.c softmagic.c ascmagic.c \
+	encoding.c compress.c is_tar.c readelf.c print.c fsmagic.c \
+	funcs.c file.h names.h patchlevel.h readelf.h tar.h apptype.c \
+	file_opts.h elfclass.h mygetopt.h cdf.c cdf_time.c readcdf.c cdf.h
+libmagic_la_LDFLAGS = -no-undefined -version-info 1:0:0
+libmagic_la_LIBADD = $(LTLIBOBJS)
+
+file_SOURCES = file.c
+file_LDADD = libmagic.la
diff --git a/cdf.c b/cdf.c
new file mode 100644
index 000000000000..0c66d11bdb12
--- /dev/null
+++ b/cdf.c
@@ -0,0 +1,1105 @@
+/*-
+ * Copyright (c) 2008 Christos Zoulas
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * Parse composite document files, the format used in Microsoft Office
+ * document files before they switched to zipped xml.
+ * Info from: http://sc.openoffice.org/compdocfileformat.pdf
+ */
+
+#include "file.h"
+
+#ifndef lint
+FILE_RCSID("@(#)$File: cdf.c,v 1.17 2009/02/03 20:27:51 christos Exp $")
+#endif
+
+#include <assert.h>
+#ifdef CDF_DEBUG
+#include <err.h>
+#endif
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <time.h>
+#include <ctype.h>
+
+#ifndef EFTYPE
+#define EFTYPE EINVAL
+#endif
+
+#include "cdf.h"
+
+#ifndef __arraycount
+#define __arraycount(a) (sizeof(a) / sizeof(a[0]))
+#endif
+
+#ifdef CDF_DEBUG
+#define DPRINTF(a) printf a
+#else
+#define DPRINTF(a)
+#endif
+
+static union {
+	char s[4];
+	uint32_t u;
+} cdf_bo;
+
+#define NEED_SWAP	(cdf_bo.u == (uint32_t)0x01020304)
+
+#define CDF_TOLE8(x)	(NEED_SWAP ? cdf_tole8(x) : (uint64_t)(x))
+#define CDF_TOLE4(x)	(NEED_SWAP ? cdf_tole4(x) : (uint32_t)(x))
+#define CDF_TOLE2(x)	(NEED_SWAP ? cdf_tole2(x) : (uint16_t)(x))
+
+/*
+ * swap a short
+ */
+uint16_t
+cdf_tole2(uint16_t sv)
+{
+	uint16_t rv;
+	uint8_t *s = (uint8_t *)(void *)&sv; 
+	uint8_t *d = (uint8_t *)(void *)&rv; 
+	d[0] = s[1];
+	d[1] = s[0];
+	return rv;
+}
+
+/*
+ * swap an int
+ */
+uint32_t
+cdf_tole4(uint32_t sv)
+{
+	uint32_t rv;
+	uint8_t *s = (uint8_t *)(void *)&sv; 
+	uint8_t *d = (uint8_t *)(void *)&rv; 
+	d[0] = s[3];
+	d[1] = s[2];
+	d[2] = s[1];
+	d[3] = s[0];
+	return rv;
+}
+
+/*
+ * swap a quad
+ */
+uint64_t
+cdf_tole8(uint64_t sv)
+{
+	uint64_t rv;
+	uint8_t *s = (uint8_t *)(void *)&sv; 
+	uint8_t *d = (uint8_t *)(void *)&rv; 
+	d[0] = s[7];
+	d[1] = s[6];
+	d[2] = s[5];
+	d[3] = s[4];
+	d[4] = s[3];
+	d[5] = s[2];
+	d[6] = s[1];
+	d[7] = s[0];
+	return rv;
+}
+
+#define CDF_UNPACK(a)	\
+    (void)memcpy(&(a), &buf[len], sizeof(a)), len += sizeof(a)
+#define CDF_UNPACKA(a)	\
+    (void)memcpy((a), &buf[len], sizeof(a)), len += sizeof(a)
+
+void
+cdf_swap_header(cdf_header_t *h)
+{
+	size_t i;
+
+	h->h_magic = CDF_TOLE8(h->h_magic);
+	h->h_uuid[0] = CDF_TOLE8(h->h_uuid[0]);
+	h->h_uuid[1] = CDF_TOLE8(h->h_uuid[1]);
+	h->h_revision = CDF_TOLE2(h->h_revision);
+	h->h_version = CDF_TOLE2(h->h_version);
+	h->h_byte_order = CDF_TOLE2(h->h_byte_order);
+	h->h_sec_size_p2 = CDF_TOLE2(h->h_sec_size_p2);
+	h->h_short_sec_size_p2 = CDF_TOLE2(h->h_short_sec_size_p2);
+	h->h_num_sectors_in_sat = CDF_TOLE4(h->h_num_sectors_in_sat);
+	h->h_secid_first_directory = CDF_TOLE4(h->h_secid_first_directory);
+	h->h_min_size_standard_stream =
+	    CDF_TOLE4(h->h_min_size_standard_stream);
+	h->h_secid_first_sector_in_short_sat =
+	    CDF_TOLE4(h->h_secid_first_sector_in_short_sat);
+	h->h_num_sectors_in_short_sat =
+	    CDF_TOLE4(h->h_num_sectors_in_short_sat);
+	h->h_secid_first_sector_in_master_sat =
+	    CDF_TOLE4(h->h_secid_first_sector_in_master_sat);
+	h->h_num_sectors_in_master_sat =
+	    CDF_TOLE4(h->h_num_sectors_in_master_sat);
+	for (i = 0; i < __arraycount(h->h_master_sat); i++)
+		h->h_master_sat[i] = CDF_TOLE4(h->h_master_sat[i]);
+}
+
+void
+cdf_unpack_header(cdf_header_t *h, char *buf)
+{
+	size_t i;
+	size_t len = 0;
+
+	CDF_UNPACK(h->h_magic);
+	CDF_UNPACKA(h->h_uuid);
+	CDF_UNPACK(h->h_revision);
+	CDF_UNPACK(h->h_version);
+	CDF_UNPACK(h->h_byte_order);
+	CDF_UNPACK(h->h_sec_size_p2);
+	CDF_UNPACK(h->h_short_sec_size_p2);
+	CDF_UNPACKA(h->h_unused0);
+	CDF_UNPACK(h->h_num_sectors_in_sat);
+	CDF_UNPACK(h->h_secid_first_directory);
+	CDF_UNPACKA(h->h_unused1);
+	CDF_UNPACK(h->h_min_size_standard_stream);
+	CDF_UNPACK(h->h_secid_first_sector_in_short_sat);
+	CDF_UNPACK(h->h_num_sectors_in_short_sat);
+	CDF_UNPACK(h->h_secid_first_sector_in_master_sat);
+	CDF_UNPACK(h->h_num_sectors_in_master_sat);
+	for (i = 0; i < __arraycount(h->h_master_sat); i++)
+		CDF_UNPACK(h->h_master_sat[i]);
+}
+
+void
+cdf_swap_dir(cdf_directory_t *d)
+{
+	d->d_namelen = CDF_TOLE2(d->d_namelen);
+	d->d_left_child = CDF_TOLE4(d->d_left_child);
+	d->d_right_child = CDF_TOLE4(d->d_right_child);
+	d->d_storage = CDF_TOLE4(d->d_storage);
+	d->d_storage_uuid[0] = CDF_TOLE8(d->d_storage_uuid[0]);
+	d->d_storage_uuid[1] = CDF_TOLE8(d->d_storage_uuid[1]);
+	d->d_flags = CDF_TOLE4(d->d_flags);
+	d->d_created = CDF_TOLE8(d->d_created);
+	d->d_modified = CDF_TOLE8(d->d_modified);
+	d->d_stream_first_sector = CDF_TOLE4(d->d_stream_first_sector);
+	d->d_size = CDF_TOLE4(d->d_size);
+}
+
+void
+cdf_swap_class(cdf_classid_t *d)
+{
+	d->cl_dword = CDF_TOLE4(d->cl_dword);
+	d->cl_word[0] = CDF_TOLE2(d->cl_word[0]);
+	d->cl_word[1] = CDF_TOLE2(d->cl_word[1]);
+}
+
+void
+cdf_unpack_dir(cdf_directory_t *d, char *buf)
+{
+	size_t len = 0;
+
+	CDF_UNPACKA(d->d_name);
+	CDF_UNPACK(d->d_namelen);
+	CDF_UNPACK(d->d_type);
+	CDF_UNPACK(d->d_color);
+	CDF_UNPACK(d->d_left_child);
+	CDF_UNPACK(d->d_right_child);
+	CDF_UNPACK(d->d_storage);
+	CDF_UNPACKA(d->d_storage_uuid);
+	CDF_UNPACK(d->d_flags);
+	CDF_UNPACK(d->d_created);
+	CDF_UNPACK(d->d_modified);
+	CDF_UNPACK(d->d_stream_first_sector);
+	CDF_UNPACK(d->d_size);
+	CDF_UNPACK(d->d_unused0);
+}
+
+int
+cdf_read_header(int fd, cdf_header_t *h)
+{
+	(void)memcpy(cdf_bo.s, "\01\02\03\04", 4);
+	char buf[512];
+	if (lseek(fd, (off_t)0, SEEK_SET) == (off_t)-1)
+		return -1;
+	if (read(fd, buf, sizeof(buf)) != sizeof(buf))
+		return -1;
+	cdf_unpack_header(h, buf);
+	cdf_swap_header(h);
+	if (h->h_magic != CDF_MAGIC) {
+		DPRINTF(("Bad magic 0x%x != 0x$x\n", h->h_magic, CDF_MAGIC));
+		errno = EFTYPE;
+		return -1;
+	}
+	return 0;
+}
+
+
+ssize_t
+cdf_read_sector(int fd, void *buf, size_t offs, size_t len,
+    const cdf_header_t *h, cdf_secid_t id)
+{
+	assert((size_t)CDF_SEC_SIZE(h) == len);
+	if (lseek(fd, (off_t)CDF_SEC_POS(h, id), SEEK_SET) == (off_t)-1)
+		return -1;
+	return read(fd, ((char *)buf) + offs, len);
+}
+
+ssize_t
+cdf_read_short_sector(const cdf_stream_t *sst, void *buf, size_t offs,
+    size_t len, const cdf_header_t *h, cdf_secid_t id)
+{
+	assert((size_t)CDF_SHORT_SEC_SIZE(h) == len);
+	(void)memcpy(((char *)buf) + offs,
+	    ((const char *)sst->sst_tab) + CDF_SHORT_SEC_POS(h, id), len);
+	return len;
+}
+
+/*
+ * Read the sector allocation table.
+ */
+int
+cdf_read_sat(int fd, cdf_header_t *h, cdf_sat_t *sat)
+{
+	size_t i, j, k;
+	size_t ss = CDF_SEC_SIZE(h);
+	cdf_secid_t *msa, mid;
+
+	for (i = 0; i < __arraycount(h->h_master_sat); i++)
+		if (h->h_master_sat[i] == CDF_SECID_FREE)
+			break;
+
+	sat->sat_len = (h->h_num_sectors_in_master_sat + i);
+	if ((sat->sat_tab = calloc(sat->sat_len, ss)) == NULL)
+		return -1;
+
+	for (i = 0; i < __arraycount(h->h_master_sat); i++) {
+		if (h->h_master_sat[i] < 0)
+			break;
+		if (cdf_read_sector(fd, sat->sat_tab, ss * i, ss, h,
+		    h->h_master_sat[i]) != (ssize_t)ss) {
+			DPRINTF(("Reading sector %d", h->h_master_sat[i]));
+			goto out1;
+		}
+	}
+
+	if ((msa = calloc(1, ss)) == NULL)
+		goto out1;
+
+	mid = h->h_secid_first_sector_in_master_sat;
+	for (j = 0; j < h->h_num_sectors_in_master_sat; j++) {
+		if (j >= CDF_LOOP_LIMIT) {
+			DPRINTF(("Reading master sector loop limit"));
+			errno = EFTYPE;
+			goto out2;
+		}
+		if (cdf_read_sector(fd, msa, 0, ss, h, mid) != (ssize_t)ss) {
+			DPRINTF(("Reading master sector %d", mid));
+			goto out2;
+		}
+		for (k = 0; k < (ss / sizeof(mid)) - 1; k++, i++)
+			if (cdf_read_sector(fd, sat->sat_tab, ss * i, ss, h,
+			    CDF_TOLE4(msa[k])) != (ssize_t)ss) {
+				DPRINTF(("Reading sector %d",
+				    CDF_TOLE4(msa[k])));
+				goto out2;
+			}
+		mid = CDF_TOLE4(msa[(ss / sizeof(mid)) - 1]);
+	}
+	free(msa);
+	return 0;
+out2:
+	free(msa);
+out1:
+	free(sat->sat_tab);
+	return -1;
+}
+
+size_t
+cdf_count_chain(const cdf_header_t *h, const cdf_sat_t *sat,
+    cdf_secid_t sid)
+{
+	size_t i, j, s = CDF_SEC_SIZE(h) / sizeof(cdf_secid_t);
+	cdf_secid_t maxsector = (cdf_secid_t)(sat->sat_len * s);
+
+	DPRINTF(("Chain:"));
+	for (j = i = 0; sid >= 0; i++, j++) {
+		DPRINTF((" %d", sid));
+		if (j >= CDF_LOOP_LIMIT) {
+			DPRINTF(("Counting chain loop limit"));
+			errno = EFTYPE;
+			return (size_t)-1;
+		}
+		if (sid > maxsector) {
+			DPRINTF(("Sector %d > %d\n", sid, maxsector));
+			errno = EFTYPE;
+			return (size_t)-1;
+		}
+		sid = CDF_TOLE4(sat->sat_tab[sid]);
+	}
+	DPRINTF(("\n"));
+	return i;
+}
+
+int
+cdf_read_long_sector_chain(int fd, const cdf_header_t *h, const cdf_sat_t *sat,
+    cdf_secid_t sid, size_t len, cdf_stream_t *scn)
+{
+	size_t ss = CDF_SEC_SIZE(h), i, j;
+	ssize_t nr;
+	scn->sst_len = cdf_count_chain(h, sat, sid);
+	scn->sst_dirlen = len;
+
+	if (scn->sst_len == (size_t)-1)
+		return -1;
+
+	scn->sst_tab = calloc(scn->sst_len, ss);
+	if (scn->sst_tab == NULL)
+		return -1;
+
+	for (j = i = 0; sid >= 0; i++, j++) {
+		if ((nr = cdf_read_sector(fd, scn->sst_tab, i * ss, ss, h,
+		    sid)) != (ssize_t)ss) {
+			if (i == scn->sst_len - 1 && nr > 0) {
+				/* Last sector might be truncated */
+				return 0;
+			}
+			DPRINTF(("Reading long sector chain %d", sid));
+			goto out;
+		}
+		sid = CDF_TOLE4(sat->sat_tab[sid]);
+		if (j >= CDF_LOOP_LIMIT) {
+			DPRINTF(("Read long sector chain loop limit"));
+			errno = EFTYPE;
+			goto out;
+		}
+	}
+	return 0;
+out:
+	free(scn->sst_tab);
+	return (size_t)-1;
+}
+
+int
+cdf_read_short_sector_chain(const cdf_header_t *h,
+    const cdf_sat_t *ssat, const cdf_stream_t *sst,
+    cdf_secid_t sid, size_t len, cdf_stream_t *scn)
+{
+	size_t ss = CDF_SHORT_SEC_SIZE(h), i, j;
+	scn->sst_len = cdf_count_chain(h, ssat, sid);
+	scn->sst_dirlen = len;
+
+	if (scn->sst_len == (size_t)-1)
+		return -1;
+
+	scn->sst_tab = calloc(scn->sst_len, ss);
+	if (scn->sst_tab == NULL)
+		return -1;
+
+	for (j = i = 0; sid >= 0; i++, j++) {
+		if (j >= CDF_LOOP_LIMIT) {
+			DPRINTF(("Read short sector chain loop limit"));
+			errno = EFTYPE;
+			goto out;
+		}
+		if (cdf_read_short_sector(sst, scn->sst_tab, i * ss, ss, h,
+		    sid) != (ssize_t)ss) {
+			DPRINTF(("Reading short sector chain %d", sid));
+			goto out;
+		}
+		sid = CDF_TOLE4(ssat->sat_tab[sid]);
+	}
+	return 0;
+out:
+	free(scn->sst_tab);
+	return (size_t)-1;
+}
+
+int
+cdf_read_sector_chain(int fd, const cdf_header_t *h, const cdf_sat_t *sat,
+    const cdf_sat_t *ssat, const cdf_stream_t *sst,
+    cdf_secid_t sid, size_t len, cdf_stream_t *scn)
+{
+
+	if (len < h->h_min_size_standard_stream)
+		return cdf_read_short_sector_chain(h, ssat, sst, sid, len,
+		    scn);
+	else
+		return cdf_read_long_sector_chain(fd, h, sat, sid, len, scn);
+}
+
+int
+cdf_read_dir(int fd, const cdf_header_t *h, const cdf_sat_t *sat,
+    cdf_dir_t *dir)
+{
+	size_t i, j;
+	size_t ss = CDF_SEC_SIZE(h), ns, nd;
+	char *buf;
+	cdf_secid_t sid = h->h_secid_first_directory;
+
+	ns = cdf_count_chain(h, sat, sid);
+	if (ns == (size_t)-1)
+		return -1;
+
+	nd = ss / CDF_DIRECTORY_SIZE;
+
+	dir->dir_len = ns * nd;
+	dir->dir_tab = calloc(dir->dir_len, sizeof(dir->dir_tab[0]));
+	if (dir->dir_tab == NULL)
+		return -1;
+
+	if ((buf = malloc(ss)) == NULL) {
+		free(dir->dir_tab);
+		return -1;
+	}
+
+	for (j = i = 0; i < ns; i++, j++) {
+		if (j >= CDF_LOOP_LIMIT) {
+			DPRINTF(("Read dir loop limit"));
+			errno = EFTYPE;
+			goto out;
+		}
+		if (cdf_read_sector(fd, buf, 0, ss, h, sid) != (ssize_t)ss) {
+			DPRINTF(("Reading directory sector %d", sid));
+			goto out;
+		}
+		for (j = 0; j < nd; j++) {
+			cdf_unpack_dir(&dir->dir_tab[i * nd + j],
+			    &buf[j * CDF_DIRECTORY_SIZE]);
+		}
+		sid = CDF_TOLE4(sat->sat_tab[sid]);
+	}
+	if (NEED_SWAP)
+		for (i = 0; i < dir->dir_len; i++)
+			cdf_swap_dir(&dir->dir_tab[i]);
+	free(buf);
+	return 0;
+out:
+	free(dir->dir_tab);
+	free(buf);
+	return -1;
+}
+
+
+int
+cdf_read_ssat(int fd, const cdf_header_t *h, const cdf_sat_t *sat,
+    cdf_sat_t *ssat)
+{
+	size_t i, j;
+	size_t ss = CDF_SEC_SIZE(h);
+	cdf_secid_t sid = h->h_secid_first_sector_in_short_sat;
+
+	ssat->sat_len = cdf_count_chain(h, sat, sid);
+	if (ssat->sat_len == (size_t)-1)
+		return -1;
+
+	ssat->sat_tab = calloc(ssat->sat_len, ss);
+	if (ssat->sat_tab == NULL)
+		return -1;
+
+	for (j = i = 0; sid >= 0; i++, j++) {
+		if (j >= CDF_LOOP_LIMIT) {
+			DPRINTF(("Read short sat sector loop limit"));
+			errno = EFTYPE;
+			goto out;
+		}
+		if (cdf_read_sector(fd, ssat->sat_tab, i * ss, ss, h, sid) !=
+		    (ssize_t)ss) {
+			DPRINTF(("Reading short sat sector %d", sid));
+			goto out;
+		}
+		sid = CDF_TOLE4(sat->sat_tab[sid]);
+	}
+	return 0;
+out:
+	free(ssat->sat_tab);
+	return -1;
+}
+
+int
+cdf_read_short_stream(int fd, const cdf_header_t *h, const cdf_sat_t *sat,
+    const cdf_dir_t *dir, cdf_stream_t *scn)
+{
+	size_t i;
+	const cdf_directory_t *d;
+
+	for (i = 0; i < dir->dir_len; i++)
+		if (dir->dir_tab[i].d_type == CDF_DIR_TYPE_ROOT_STORAGE)
+			break;
+
+	if (i == dir->dir_len) {
+		DPRINTF(("Cannot find root storage node\n"));
+		errno = EFTYPE;
+		return -1;
+	}
+	d = &dir->dir_tab[i];
+
+	/* If the it is not there, just fake it; some docs don't have it */
+	if (d->d_stream_first_sector < 0) {
+		scn->sst_tab = NULL;
+		scn->sst_len = 0;
+		return 0;
+	}
+
+	return  cdf_read_long_sector_chain(fd, h, sat,
+	    d->d_stream_first_sector, d->d_size, scn);
+}
+
+static int
+cdf_namecmp(const char *d, const uint16_t *s, size_t l)
+{
+	for (; l--; d++, s++)
+		if (*d != CDF_TOLE2(*s))
+			return (unsigned char)*d - CDF_TOLE2(*s);
+	return 0;
+}
+
+int
+cdf_read_summary_info(int fd, const cdf_header_t *h,
+    const cdf_sat_t *sat, const cdf_sat_t *ssat, const cdf_stream_t *sst,
+    const cdf_dir_t *dir, cdf_stream_t *scn)
+{
+	size_t i;
+	const cdf_directory_t *d;
+	static const char name[] = "\05SummaryInformation";
+
+	for (i = 0; i < dir->dir_len; i++)
+		if (dir->dir_tab[i].d_type == CDF_DIR_TYPE_USER_STREAM &&
+		    cdf_namecmp(name, dir->dir_tab[i].d_name, sizeof(name))
+		    == 0)
+			break;
+
+	if (i == dir->dir_len) {
+		DPRINTF(("Cannot find summary information section\n"));
+		errno = EFTYPE;
+		return -1;
+	}
+	d = &dir->dir_tab[i];
+	return cdf_read_sector_chain(fd, h, sat, ssat, sst,
+	    d->d_stream_first_sector, d->d_size, scn);
+}
+
+int
+cdf_read_property_info(const cdf_stream_t *sst, uint32_t offs,
+    cdf_property_info_t **info, size_t *count, size_t *maxcount)
+{
+	const cdf_section_header_t *shp;
+	cdf_section_header_t sh;
+	const uint32_t *p, *q, *e;
+	int16_t s16;
+	int32_t s32;
+	uint32_t u32;
+	int64_t s64;
+	uint64_t u64;
+	cdf_timestamp_t tp;
+	size_t i, o, nelements, j;
+	cdf_property_info_t *inp;
+
+	shp = (const void *)((const char *)sst->sst_tab + offs);
+	sh.sh_len = CDF_TOLE4(shp->sh_len);
+	sh.sh_properties = CDF_TOLE4(shp->sh_properties);
+	DPRINTF(("section len: %d properties %d\n", sh.sh_len,
+	    sh.sh_properties));
+	if (*maxcount) {
+		*maxcount += sh.sh_properties;
+		inp = realloc(*info, *maxcount * sizeof(*inp));
+	} else {
+		*maxcount = sh.sh_properties;
+		inp = malloc(*maxcount * sizeof(*inp));
+	}
+	if (inp == NULL)
+		goto out;
+	*info = inp;
+	inp += *count;
+	*count += sh.sh_properties;
+	p = (const void *)((const char *)sst->sst_tab + offs + sizeof(sh));
+	e = (const void *)(((const char *)shp) + sh.sh_len);
+	for (i = 0; i < sh.sh_properties; i++) {
+		q = (const uint32_t *)((const char *)p +
+		    CDF_TOLE4(p[(i << 1) + 1])) - 2;
+		if (q > e) {
+			DPRINTF(("Ran of the end %p > %p\n", q, e));
+			goto out;
+		}
+		inp[i].pi_id = CDF_TOLE4(p[i << 1]);
+		inp[i].pi_type = CDF_TOLE4(q[0]);
+		DPRINTF(("%d) id=%x type=%x offs=%x\n", i, inp[i].pi_id,
+		    inp[i].pi_type, (const char *)q - (const char *)p));
+		if (inp[i].pi_type & CDF_VECTOR) {
+			nelements = CDF_TOLE4(q[1]);
+			o = 2;
+		} else {
+			nelements = 1;
+			o = 1;
+		}
+		if (inp[i].pi_type & (CDF_ARRAY|CDF_BYREF|CDF_RESERVED))
+			goto unknown;
+		switch (inp[i].pi_type & CDF_TYPEMASK) {
+		case CDF_EMPTY:
+			break;
+		case CDF_SIGNED16:
+			if (inp[i].pi_type & CDF_VECTOR)
+				goto unknown;
+			(void)memcpy(&s16, &q[o], sizeof(s16));
+			inp[i].pi_s16 = CDF_TOLE2(s16);
+			break;
+		case CDF_SIGNED32:
+			if (inp[i].pi_type & CDF_VECTOR)
+				goto unknown;
+			(void)memcpy(&s32, &q[o], sizeof(s32));
+			inp[i].pi_s32 = CDF_TOLE4(s32);
+			break;
+		case CDF_BOOL:
+		case CDF_UNSIGNED32:
+			if (inp[i].pi_type & CDF_VECTOR)
+				goto unknown;
+			(void)memcpy(&u32, &q[o], sizeof(u32));
+			inp[i].pi_u32 = CDF_TOLE4(u32);
+			break;
+		case CDF_SIGNED64:
+			if (inp[i].pi_type & CDF_VECTOR)
+				goto unknown;
+			(void)memcpy(&s64, &q[o], sizeof(s64));
+			inp[i].pi_s64 = CDF_TOLE4(s64);
+			break;
+		case CDF_UNSIGNED64:
+			if (inp[i].pi_type & CDF_VECTOR)
+				goto unknown;
+			(void)memcpy(&u64, &q[o], sizeof(u64));
+			inp[i].pi_u64 = CDF_TOLE4(u64);
+			break;
+		case CDF_LENGTH32_STRING:
+			if (nelements > 1) {
+				size_t nelem = inp - *info;
+				*maxcount += nelements;
+				inp = realloc(*info, *maxcount * sizeof(*inp));
+				if (inp == NULL)
+					goto out;
+				*info = inp;
+				inp = *info + nelem;
+			}
+			DPRINTF(("nelements = %d\n", nelements));
+			for (j = 0; j < nelements; j++, i++) {
+				uint32_t l = CDF_TOLE4(q[o]);
+				inp[i].pi_str.s_len = l;
+				inp[i].pi_str.s_buf = (const char *)(&q[o+1]);
+				DPRINTF(("l = %d, r = %d, s = %s\n", l,
+				    CDF_ROUND(l, sizeof(l)),
+				    inp[i].pi_str.s_buf));
+				l = 4 + CDF_ROUND(l, sizeof(l));
+				o += l >> 2;
+			}
+			i--;
+			break;
+		case CDF_FILETIME:
+			if (inp[i].pi_type & CDF_VECTOR)
+				goto unknown;
+			(void)memcpy(&tp, &q[o], sizeof(tp));
+			inp[i].pi_tp = CDF_TOLE8(tp);
+			break;
+		case CDF_CLIPBOARD:
+			if (inp[i].pi_type & CDF_VECTOR)
+				goto unknown;
+			break;
+		default:
+		unknown:
+			DPRINTF(("Don't know how to deal with %x\n",
+			    inp[i].pi_type));
+			goto out;
+		}
+	}
+	return 0;
+out:
+	free(*info);
+	return -1;
+}
+
+int
+cdf_unpack_summary_info(const cdf_stream_t *sst, cdf_summary_info_header_t *ssi,
+    cdf_property_info_t **info, size_t *count)
+{
+	size_t i, maxcount;
+	const cdf_summary_info_header_t *si = sst->sst_tab;
+	const cdf_section_declaration_t *sd = (const void *)
+	    ((const char *)sst->sst_tab + CDF_SECTION_DECLARATION_OFFSET);
+
+	ssi->si_byte_order = CDF_TOLE2(si->si_byte_order);
+	ssi->si_os_version = CDF_TOLE2(si->si_os_version);
+	ssi->si_os = CDF_TOLE2(si->si_os);
+	ssi->si_class = si->si_class;
+	cdf_swap_class(&ssi->si_class);
+	ssi->si_count = CDF_TOLE2(si->si_count);
+	*count = 0;
+	maxcount = 0;
+	*info = NULL;
+	for (i = 0; i < CDF_TOLE4(si->si_count); i++) {
+		if (i >= CDF_LOOP_LIMIT) {
+			DPRINTF(("Unpack summary info loop limit"));
+			errno = EFTYPE;
+			return -1;
+		}
+		if (cdf_read_property_info(sst, CDF_TOLE4(sd->sd_offset),
+		    info, count, &maxcount) == -1)
+			return -1;
+	}
+	return 0;
+}
+
+
+
+int
+cdf_print_classid(char *buf, size_t buflen, const cdf_classid_t *id)
+{
+	return snprintf(buf, buflen, "%.8x-%.4x-%.4x-%.2x%.2x-"
+	    "%.2x%.2x%.2x%.2x%.2x%.2x", id->cl_dword, id->cl_word[0],
+	    id->cl_word[1], id->cl_two[0], id->cl_two[1], id->cl_six[0],
+	    id->cl_six[1], id->cl_six[2], id->cl_six[3], id->cl_six[4],
+	    id->cl_six[5]);
+}
+
+static const struct {
+	uint32_t v;
+	const char *n;
+} vn[] = {
+	{ CDF_PROPERTY_CODE_PAGE, "Code page" },
+	{ CDF_PROPERTY_TITLE, "Title" },
+	{ CDF_PROPERTY_SUBJECT, "Subject" },
+	{ CDF_PROPERTY_AUTHOR, "Author" },
+	{ CDF_PROPERTY_KEYWORDS, "Keywords" },
+	{ CDF_PROPERTY_COMMENTS, "Comments" },
+	{ CDF_PROPERTY_TEMPLATE, "Template" },
+	{ CDF_PROPERTY_LAST_SAVED_BY, "Last Saved By" },
+	{ CDF_PROPERTY_REVISION_NUMBER, "Revision Number" },
+	{ CDF_PROPERTY_TOTAL_EDITING_TIME, "Total Editing Time" },
+	{ CDF_PROPERTY_LAST_PRINTED, "Last Printed" },
+	{ CDF_PROPERTY_CREATE_TIME, "Create Time/Date" },
+	{ CDF_PROPERTY_LAST_SAVED_TIME, "Last Saved Time/Date" },
+	{ CDF_PROPERTY_NUMBER_OF_PAGES, "Number of Pages" },
+	{ CDF_PROPERTY_NUMBER_OF_WORDS, "Number of Words" },
+	{ CDF_PROPERTY_NUMBER_OF_CHARACTERS, "Number of Characters" },
+	{ CDF_PROPERTY_THUMBNAIL, "Thumbnail" },
+	{ CDF_PROPERTY_NAME_OF_APPLICATION, "Name of Creating Application" },
+	{ CDF_PROPERTY_SECURITY, "Security" },
+	{ CDF_PROPERTY_LOCALE_ID, "Locale ID" },
+};
+
+int
+cdf_print_property_name(char *buf, size_t bufsiz, uint32_t p)
+{
+	size_t i;
+
+	for (i = 0; i < __arraycount(vn); i++)
+		if (vn[i].v == p)
+			return snprintf(buf, bufsiz, "%s", vn[i].n);
+	return snprintf(buf, bufsiz, "0x%x", p);
+}
+
+int
+cdf_print_elapsed_time(char *buf, size_t bufsiz, cdf_timestamp_t ts)
+{
+	size_t len = 0;
+	int days, hours, mins, secs;
+
+	ts /= CDF_TIME_PREC;
+	secs = ts % 60;
+	ts /= 60;
+	mins = ts % 60;
+	ts /= 60;
+	hours = ts % 24;
+	ts /= 24;
+	days = ts;
+
+	if (days) {
+		len += snprintf(buf + len, bufsiz - len, "%dd+", days);
+		if (len >= bufsiz)
+			return len;
+	}
+
+	if (days || hours) {
+		len += snprintf(buf + len, bufsiz - len, "%.2d:", hours);
+		if (len >= bufsiz)
+			return len;
+	}
+
+	len += snprintf(buf + len, bufsiz - len, "%.2d:", mins);
+	if (len >= bufsiz)
+		return len;
+
+	len += snprintf(buf + len, bufsiz - len, "%.2d", secs);
+	return len;
+}
+
+
+#ifdef CDF_DEBUG
+void
+cdf_dump_header(const cdf_header_t *h)
+{
+	size_t i;
+
+#define DUMP(a, b) printf("%40.40s = " a "\n", # b, h->h_ ## b)
+	DUMP("%d", revision);
+	DUMP("%d", version);
+	DUMP("0x%x", byte_order);
+	DUMP("%d", sec_size_p2);
+	DUMP("%d", short_sec_size_p2);
+	DUMP("%d", num_sectors_in_sat);
+	DUMP("%d", secid_first_directory);
+	DUMP("%d", min_size_standard_stream);
+	DUMP("%d", secid_first_sector_in_short_sat);
+	DUMP("%d", num_sectors_in_short_sat);
+	DUMP("%d", secid_first_sector_in_master_sat);
+	DUMP("%d", num_sectors_in_master_sat);
+	for (i = 0; i < __arraycount(h->h_master_sat); i++) {
+		if (h->h_master_sat[i] == CDF_SECID_FREE)
+			break;
+		printf("%35.35s[%.3zu] = %d\n",
+		    "master_sat", i, h->h_master_sat[i]);
+	}
+}
+
+void
+cdf_dump_sat(const char *prefix, const cdf_header_t *h, const cdf_sat_t *sat)
+{
+	size_t i, j, s = CDF_SEC_SIZE(h) / sizeof(cdf_secid_t);
+
+	for (i = 0; i < sat->sat_len; i++) {
+		printf("%s[%zu]:\n", prefix, i);
+		for (j = 0; j < s; j++) {
+			printf("%5d, ", CDF_TOLE4(sat->sat_tab[s * i + j]));
+			if ((j + 1) % 10 == 0)
+				printf("\n");
+		}
+		printf("\n");
+	}
+}
+
+void
+cdf_dump(void *v, size_t len)
+{
+	size_t i, j;
+	unsigned char *p = v;
+	char abuf[16];
+	printf("%.4x: ", 0);
+	for (i = 0, j = 0; i < len; i++, p++) {
+		printf("%.2x ", *p);
+		abuf[j++] = isprint(*p) ? *p : '.';
+		if (j == 16) {
+			j = 0;
+			abuf[15] = '\0';
+			printf("%s\n%.4x: ", abuf, i + 1);
+		}
+	}
+	printf("\n");
+}
+
+void
+cdf_dump_stream(const cdf_header_t *h, const cdf_stream_t *sst)
+{
+	size_t ss = sst->sst_dirlen < h->h_min_size_standard_stream ?
+	    CDF_SHORT_SEC_SIZE(h) : CDF_SEC_SIZE(h);
+	cdf_dump(sst->sst_tab, ss * sst->sst_len);
+}
+
+void
+cdf_dump_dir(int fd, const cdf_header_t *h, const cdf_sat_t *sat,
+    const cdf_sat_t *ssat, const cdf_stream_t *sst,
+    const cdf_dir_t *dir)
+{
+	size_t i, j;
+	cdf_directory_t *d;
+	char name[__arraycount(d->d_name)];
+	cdf_stream_t scn;
+	struct timespec ts;
+
+	static const char *types[] = { "empty", "user storage",
+	    "user stream", "lockbytes", "property", "root storage" };
+
+	for (i = 0; i < dir->dir_len; i++) {
+		d = &dir->dir_tab[i];
+		for (j = 0; j < sizeof(name); j++)
+			name[j] = (char)CDF_TOLE2(d->d_name[j]);
+		printf("Directory %zu: %s\n", i, name);
+		if (d->d_type < __arraycount(types))
+			printf("Type: %s\n", types[d->d_type]);
+		else
+			printf("Type: %d\n", d->d_type);
+		printf("Color: %s\n", d->d_color ? "black" : "red");
+		printf("Left child: %d\n", d->d_left_child);
+		printf("Right child: %d\n", d->d_right_child);
+		printf("Flags: 0x%x\n", d->d_flags);
+		cdf_timestamp_to_timespec(&ts, d->d_created);
+		printf("Created %s", ctime(&ts.tv_sec));
+		cdf_timestamp_to_timespec(&ts, d->d_modified);
+		printf("Modified %s", ctime(&ts.tv_sec));
+		printf("Stream %d\n", d->d_stream_first_sector);
+		printf("Size %d\n", d->d_size);
+		switch (d->d_type) {
+		case CDF_DIR_TYPE_USER_STORAGE:
+			printf("Storage: %d\n", d->d_storage);
+			break;
+		case CDF_DIR_TYPE_USER_STREAM:
+			if (sst == NULL)
+				break;
+			if (cdf_read_sector_chain(fd, h, sat, ssat, sst,
+			    d->d_stream_first_sector, d->d_size, &scn) == -1) {
+				warn("Can't read stream for %s at %d len %d",
+				    name, d->d_stream_first_sector, d->d_size);
+				break;
+			}
+			cdf_dump_stream(h, &scn);
+			free(scn.sst_tab);
+			break;
+		default:
+			break;
+		}
+			
+	}
+}
+
+void
+cdf_dump_property_info(const cdf_property_info_t *info, size_t count)
+{
+	cdf_timestamp_t tp;
+	struct timespec ts;
+	char buf[64];
+	size_t i;
+
+	for (i = 0; i < count; i++) {
+		cdf_print_property_name(buf, sizeof(buf), info[i].pi_id);
+		printf("%zu) %s: ", i, buf); 
+		switch (info[i].pi_type) {
+		case CDF_SIGNED16:
+			printf("signed 16 [%hd]\n", info[i].pi_s16);
+			break;
+		case CDF_SIGNED32:
+			printf("signed 32 [%d]\n", info[i].pi_s32);
+			break;
+		case CDF_UNSIGNED32:
+			printf("unsigned 32 [%u]\n", info[i].pi_u32);
+			break;
+		case CDF_LENGTH32_STRING:
+			printf("string %u [%.*s]\n", info[i].pi_str.s_len,
+			    info[i].pi_str.s_len, info[i].pi_str.s_buf);
+			break;
+		case CDF_FILETIME:
+			tp = info[i].pi_tp;
+			if (tp < 1000000000000000LL) {
+				cdf_print_elapsed_time(buf, sizeof(buf), tp);
+				printf("timestamp %s\n", buf);
+			} else {
+				cdf_timestamp_to_timespec(&ts, tp);
+				printf("timestamp %s", ctime(&ts.tv_sec));
+			}
+			break;
+		case CDF_CLIPBOARD:
+			printf("CLIPBOARD %u\n", info[i].pi_u32);
+			break;
+		default:
+			DPRINTF(("Don't know how to deal with %x\n",
+			    info[i].pi_type));
+			break;
+		}
+	}
+}
+
+
+void
+cdf_dump_summary_info(const cdf_header_t *h, const cdf_stream_t *sst)
+{
+	char buf[128];
+	cdf_summary_info_header_t ssi;
+	cdf_property_info_t *info;
+	size_t count;
+
+	(void)&h;
+	if (cdf_unpack_summary_info(sst, &ssi, &info, &count) == -1)
+		return;
+	printf("Endian: %x\n", ssi.si_byte_order);
+	printf("Os Version %d.%d\n", ssi.si_os_version & 0xff,
+		ssi.si_os_version >> 8);
+	printf("Os %d\n", ssi.si_os);
+	cdf_print_classid(buf, sizeof(buf), &ssi.si_class);
+	printf("Class %s\n", buf);
+	printf("Count %d\n", ssi.si_count);
+	cdf_dump_property_info(info, count);
+	free(info);
+}
+
+#endif
+
+#ifdef TEST
+int
+main(int argc, char *argv[])
+{
+	int fd, i;
+	cdf_header_t h;
+	cdf_sat_t sat, ssat;
+	cdf_stream_t sst, scn;
+	cdf_dir_t dir;
+
+	if (argc < 2) {
+		(void)fprintf(stderr, "Usage: %s <filename>\n", getprogname());
+		return -1;
+	}
+
+	for (i = 1; i < argc; i++) {
+		if ((fd = open(argv[1], O_RDONLY)) == -1)
+			err(1, "Cannot open `%s'", argv[1]);
+
+		if (cdf_read_header(fd, &h) == -1)
+			err(1, "Cannot read header");
+#ifdef CDF_DEBUG
+		cdf_dump_header(&h);
+#endif
+
+		if (cdf_read_sat(fd, &h, &sat) == -1)
+			err(1, "Cannot read sat");
+#ifdef CDF_DEBUG
+		cdf_dump_sat("SAT", &h, &sat);
+#endif
+
+		if (cdf_read_ssat(fd, &h, &sat, &ssat) == -1)
+			err(1, "Cannot read ssat");
+#ifdef CDF_DEBUG
+		cdf_dump_sat("SSAT", &h, &ssat);
+#endif
+
+		if (cdf_read_dir(fd, &h, &sat, &dir) == -1)
+			err(1, "Cannot read dir");
+
+		if (cdf_read_short_stream(fd, &h, &sat, &dir, &sst) == -1)
+			err(1, "Cannot read short stream");
+#ifdef CDF_DEBUG
+		cdf_dump_stream(&h, &sst);
+#endif
+
+#ifdef CDF_DEBUG
+		cdf_dump_dir(fd, &h, &sat, &ssat, &sst, &dir);
+#endif
+
+
+		if (cdf_read_summary_info(fd, &h, &sat, &ssat, &sst, &dir,
+		    &scn) == -1)
+			err(1, "Cannot read summary info");
+#ifdef CDF_DEBUG
+		cdf_dump_summary_info(&h, &scn);
+#endif
+
+		(void)close(fd);
+	}
+
+	return 0;
+}
+#endif
diff --git a/cdf.h b/cdf.h
new file mode 100644
index 000000000000..eace7ab714bb
--- /dev/null
+++ b/cdf.h
@@ -0,0 +1,298 @@
+/*-
+ * Copyright (c) 2008 Christos Zoulas
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * Info from: http://sc.openoffice.org/compdocfileformat.pdf 
+ */
+
+#ifndef _H_CDF_
+#define _H_CDF_
+
+typedef int32_t cdf_secid_t;
+
+#define CDF_LOOP_LIMIT					10000
+
+#define CDF_SECID_NULL					0
+#define CDF_SECID_FREE					-1
+#define	CDF_SECID_END_OF_CHAIN				-2
+#define	CDF_SECID_SECTOR_ALLOCATION_TABLE		-3
+#define CDF_SECID_MASTER_SECTOR_ALLOCATION_TABLE	-4
+
+typedef struct {
+	uint64_t	h_magic;
+#define CDF_MAGIC	0xE11AB1A1E011CFD0LL
+	uint64_t	h_uuid[2];
+	uint16_t	h_revision;
+	uint16_t	h_version;
+	uint16_t	h_byte_order;
+	uint16_t	h_sec_size_p2;
+	uint16_t	h_short_sec_size_p2;
+	uint8_t		h_unused0[10];
+	uint32_t	h_num_sectors_in_sat;
+	uint32_t	h_secid_first_directory;
+	uint8_t		h_unused1[4];
+	uint32_t	h_min_size_standard_stream;
+	cdf_secid_t	h_secid_first_sector_in_short_sat;
+	uint32_t	h_num_sectors_in_short_sat;
+	cdf_secid_t	h_secid_first_sector_in_master_sat;
+	uint32_t	h_num_sectors_in_master_sat;
+	cdf_secid_t	h_master_sat[436/4];
+} cdf_header_t;
+
+#define CDF_SEC_SIZE(h)	(1 << (h)->h_sec_size_p2)
+#define CDF_SEC_POS(h, secid) (CDF_SEC_SIZE(h) + (secid) * CDF_SEC_SIZE(h))
+#define CDF_SHORT_SEC_SIZE(h)	(1 << (h)->h_short_sec_size_p2)
+#define CDF_SHORT_SEC_POS(h, secid) ((secid) * CDF_SHORT_SEC_SIZE(h))
+
+typedef int32_t	cdf_dirid_t;
+#define CDF_DIRID_NULL	-1
+
+typedef int64_t	cdf_timestamp_t;
+#define CDF_BASE_YEAR	1601
+#define CDF_TIME_PREC	10000000
+
+typedef struct {
+	uint16_t	d_name[32];
+	uint16_t	d_namelen;
+	uint8_t		d_type;
+#define CDF_DIR_TYPE_EMPTY		0
+#define	CDF_DIR_TYPE_USER_STORAGE	1
+#define	CDF_DIR_TYPE_USER_STREAM	2
+#define	CDF_DIR_TYPE_LOCKBYTES		3
+#define	CDF_DIR_TYPE_PROPERTY		4
+#define	CDF_DIR_TYPE_ROOT_STORAGE	5
+	uint8_t		d_color;
+#define CDF_DIR_COLOR_READ	0
+#define CDF_DIR_COLOR_BLACK	1
+	cdf_dirid_t	d_left_child;
+	cdf_dirid_t	d_right_child;
+	cdf_dirid_t	d_storage;
+	uint64_t	d_storage_uuid[2];
+	uint32_t	d_flags;
+	cdf_timestamp_t	d_created;
+	cdf_timestamp_t	d_modified;
+	cdf_secid_t	d_stream_first_sector;
+	uint32_t	d_size;
+	uint32_t	d_unused0;
+} cdf_directory_t;
+
+#define CDF_DIRECTORY_SIZE	128
+
+typedef struct {
+	cdf_secid_t *sat_tab;
+	size_t sat_len;
+} cdf_sat_t;
+
+typedef struct {
+	cdf_directory_t *dir_tab;
+	size_t dir_len;
+} cdf_dir_t;
+
+typedef struct {
+	void *sst_tab;
+	size_t sst_len;
+	size_t sst_dirlen;
+} cdf_stream_t;
+
+typedef struct {
+	uint32_t	cl_dword;
+	uint16_t	cl_word[2];
+	uint8_t		cl_two[2];
+	uint8_t		cl_six[6];
+} cdf_classid_t;
+
+typedef struct {
+	uint16_t	si_byte_order;
+	uint16_t	si_zero;
+	uint16_t	si_os_version;
+	uint16_t	si_os;
+	cdf_classid_t	si_class;
+	uint32_t	si_count;
+} cdf_summary_info_header_t;
+
+#define CDF_SECTION_DECLARATION_OFFSET 0x1c
+
+typedef struct {
+	cdf_classid_t	sd_class;
+	uint32_t	sd_offset;
+} cdf_section_declaration_t;
+
+typedef struct {
+	uint32_t	sh_len;
+	uint32_t	sh_properties;
+} cdf_section_header_t;
+
+typedef struct {
+	uint32_t	pi_id;
+	uint32_t	pi_type;
+	union {
+		uint16_t	_pi_u16;
+		int16_t		_pi_s16;
+		uint32_t	_pi_u32;
+		int32_t		_pi_s32;
+		uint64_t	_pi_u64;
+		int64_t		_pi_s64;
+		cdf_timestamp_t	_pi_tp;
+		struct {
+			uint32_t s_len;
+			const char *s_buf;
+		} _pi_str;
+	} pi_val;
+#define pi_u64	pi_val._pi_u64
+#define pi_s64	pi_val._pi_s64
+#define pi_u32	pi_val._pi_u32
+#define pi_s32	pi_val._pi_s32
+#define pi_u16	pi_val._pi_u16
+#define pi_s16	pi_val._pi_s16
+#define pi_tp	pi_val._pi_tp
+#define pi_str	pi_val._pi_str
+} cdf_property_info_t;
+
+#define CDF_ROUND(val, by)     (((val) + (by) - 1) & ~((by) - 1))
+
+/* Variant type definitions */
+#define CDF_EMPTY		0x00000000
+#define	CDF_NULL		0x00000001
+#define CDF_SIGNED16		0x00000002
+#define CDF_SIGNED32		0x00000003
+#define CDF_FLOAT		0x00000004
+#define CDF_DOUBLE		0x00000005
+#define CDF_CY			0x00000006
+#define	CDF_DATE		0x00000007
+#define CDF_BSTR		0x00000008
+#define CDF_DISPATCH		0x00000009
+#define CDF_ERROR		0x0000000a
+#define CDF_BOOL		0x0000000b
+#define CDF_VARIANT		0x0000000c
+#define CDF_UNKNOWN		0x0000000d
+#define CDF_DECIMAL		0x0000000e
+#define CDF_SIGNED8		0x00000010
+#define CDF_UNSIGNED8		0x00000011
+#define CDF_UNSIGNED16		0x00000012
+#define	CDF_UNSIGNED32		0x00000013
+#define CDF_SIGNED64		0x00000014
+#define CDF_UNSIGNED64		0x00000015
+#define CDF_INT			0x00000016
+#define CDF_UINT		0x00000017
+#define CDF_VOID		0x00000018
+#define CDF_HRESULT		0x00000019
+#define CDF_PTR			0x0000001a
+#define CDF_SAFEARRAY		0x0000001b
+#define CDF_CARRAY		0x0000001c
+#define CDF_USERDEFINED		0x0000001d
+#define CDF_LENGTH32_STRING	0x0000001e
+#define CDF_LENGTH32_WSTRING	0x0000001f
+#define CDF_FILETIME		0x00000040
+#define CDF_BLOB		0x00000041
+#define CDF_STREAM		0x00000042
+#define CDF_STORAGE		0x00000043
+#define CDF_STREAMED_OBJECT	0x00000044
+#define CDF_STORED_OBJECT	0x00000045
+#define CDF_BLOB_OBJECT		0x00000046
+#define CDF_CLIPBOARD		0x00000047
+#define CDF_CLSID		0x00000048
+#define CDF_VECTOR		0x00001000
+#define CDF_ARRAY		0x00002000
+#define CDF_BYREF		0x00004000
+#define CDF_RESERVED		0x00008000
+#define CDF_ILLEGAL		0x0000ffff
+#define CDF_ILLEGALMASKED	0x00000fff
+#define CDF_TYPEMASK		0x00000fff
+
+#define CDF_PROPERTY_CODE_PAGE			0x00000001
+#define CDF_PROPERTY_TITLE			0x00000002
+#define CDF_PROPERTY_SUBJECT			0x00000003
+#define CDF_PROPERTY_AUTHOR			0x00000004
+#define CDF_PROPERTY_KEYWORDS			0x00000005
+#define CDF_PROPERTY_COMMENTS 			0x00000006
+#define CDF_PROPERTY_TEMPLATE			0x00000007
+#define CDF_PROPERTY_LAST_SAVED_BY		0x00000008
+#define CDF_PROPERTY_REVISION_NUMBER		0x00000009
+#define CDF_PROPERTY_TOTAL_EDITING_TIME		0x0000000a
+#define CDF_PROPERTY_LAST_PRINTED		0X0000000b
+#define CDF_PROPERTY_CREATE_TIME		0x0000000c
+#define CDF_PROPERTY_LAST_SAVED_TIME		0x0000000d
+#define CDF_PROPERTY_NUMBER_OF_PAGES		0x0000000e
+#define CDF_PROPERTY_NUMBER_OF_WORDS		0x0000000f
+#define CDF_PROPERTY_NUMBER_OF_CHARACTERS	0x00000010
+#define CDF_PROPERTY_THUMBNAIL			0x00000011
+#define CDF_PROPERTY_NAME_OF_APPLICATION	0x00000012
+#define CDF_PROPERTY_SECURITY			0x00000013
+#define CDF_PROPERTY_LOCALE_ID			0x80000000
+
+struct timespec;
+int cdf_timestamp_to_timespec(struct timespec *, cdf_timestamp_t);
+int cdf_timespec_to_timestamp(cdf_timestamp_t *, const struct timespec *);
+int cdf_read_header(int, cdf_header_t *);
+void cdf_swap_header(cdf_header_t *);
+void cdf_unpack_header(cdf_header_t *, char *);
+void cdf_swap_dir(cdf_directory_t *);
+void cdf_unpack_dir(cdf_directory_t *, char *);
+void cdf_swap_class(cdf_classid_t *);
+ssize_t cdf_read_sector(int, void *, size_t, size_t, const cdf_header_t *,
+    cdf_secid_t);
+ssize_t cdf_read_short_sector(const cdf_stream_t *, void *, size_t, size_t,
+    const cdf_header_t *, cdf_secid_t);
+int cdf_read_sat(int, cdf_header_t *, cdf_sat_t *);
+size_t cdf_count_chain(const cdf_header_t *, const cdf_sat_t *,
+    cdf_secid_t);
+int cdf_read_long_sector_chain(int, const cdf_header_t *,
+    const cdf_sat_t *, cdf_secid_t, size_t, cdf_stream_t *);
+int cdf_read_short_sector_chain(const cdf_header_t *, const cdf_sat_t *,
+    const cdf_stream_t *, cdf_secid_t, size_t, cdf_stream_t *);
+int cdf_read_sector_chain(int, const cdf_header_t *,
+    const cdf_sat_t *, const cdf_sat_t *, const cdf_stream_t *, cdf_secid_t,
+    size_t, cdf_stream_t *);
+int cdf_read_dir(int, const cdf_header_t *, const cdf_sat_t *, cdf_dir_t *);
+int cdf_read_ssat(int, const cdf_header_t *, const cdf_sat_t *, cdf_sat_t *);
+int cdf_read_short_stream(int, const cdf_header_t *, const cdf_sat_t *,
+    const cdf_dir_t *, cdf_stream_t *);
+int cdf_read_property_info(const cdf_stream_t *, uint32_t,
+    cdf_property_info_t **, size_t *, size_t *);
+int cdf_read_summary_info(int, const cdf_header_t *, const cdf_sat_t *,
+    const cdf_sat_t *, const cdf_stream_t *, const cdf_dir_t *,
+    cdf_stream_t *);
+int cdf_unpack_summary_info(const cdf_stream_t *, cdf_summary_info_header_t *,
+    cdf_property_info_t **, size_t *);
+int cdf_print_classid(char *, size_t, const cdf_classid_t *);
+int cdf_print_property_name(char *, size_t, uint32_t);
+int cdf_print_elapsed_time(char *, size_t, cdf_timestamp_t);
+uint16_t cdf_tole2(uint16_t);
+uint32_t cdf_tole4(uint32_t);
+uint64_t cdf_tole8(uint64_t);
+
+#ifdef CDF_DEBUG
+void cdf_dump_header(const cdf_header_t *);
+void cdf_dump_sat(const char *, const cdf_header_t *, const cdf_sat_t *);
+void cdf_dump(void *, size_t);
+void cdf_dump_stream(const cdf_header_t *, const cdf_stream_t *);
+void cdf_dump_dir(int, const cdf_header_t *, const cdf_sat_t *,
+    const cdf_sat_t *, const cdf_stream_t *, const cdf_dir_t *);
+void cdf_dump_property_info(const cdf_property_info_t *, size_t);
+void cdf_dump_summary_info(const cdf_header_t *, const cdf_stream_t *);
+#endif
+
+
+#endif /* _H_CDF_ */
diff --git a/cdf_time.c b/cdf_time.c
new file mode 100644
index 000000000000..e531b2dee716
--- /dev/null
+++ b/cdf_time.c
@@ -0,0 +1,182 @@
+/*-
+ * Copyright (c) 2008 Christos Zoulas
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "file.h"
+
+#ifndef lint
+FILE_RCSID("@(#)$File: cdf_time.c,v 1.5 2009/02/03 20:27:51 christos Exp $")
+#endif
+
+#include <time.h>
+#ifdef TEST
+#include <err.h>
+#endif
+#include <string.h>
+
+#include "cdf.h"
+
+#define isleap(y) ((((y) % 4) == 0) && \
+    ((((y) % 100) != 0) || (((y) % 400) == 0)))
+
+static const int mdays[] = {
+    31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
+};
+
+/*
+ * Return the number of days between jan 01 1601 and jan 01 of year.
+ */
+static int
+cdf_getdays(int year)
+{
+	int days = 0;
+	int y;
+
+	for (y = CDF_BASE_YEAR; y < year; y++)
+		days += isleap(y) + 365;
+		
+	return days;
+}
+
+/*
+ * Return the day within the month
+ */
+static int
+cdf_getday(int year, int days)
+{
+	size_t m;
+
+	for (m = 0; m < sizeof(mdays) / sizeof(mdays[0]); m++) {
+		int sub = mdays[m] + (m == 1 && isleap(year));
+		if (days < sub)
+			return days;
+		days -= sub;
+	}
+	return days;
+}
+
+/* 
+ * Return the 0...11 month number.
+ */
+static int
+cdf_getmonth(int year, int days)
+{
+	size_t m;
+
+	for (m = 0; m < sizeof(mdays) / sizeof(mdays[0]); m++) {
+		days -= mdays[m];
+		if (m == 1 && isleap(year))
+			days--;
+		if (days <= 0)
+			return (int)m;
+	}
+	return (int)m;
+}
+
+int
+cdf_timestamp_to_timespec(struct timespec *ts, cdf_timestamp_t t)
+{
+	struct tm tm;
+#ifdef HAVE_STRUCT_TM_TM_ZONE
+	static char UTC[] = "UTC";
+#endif
+
+	/* Unit is 100's of nanoseconds */
+	ts->tv_nsec = (t % CDF_TIME_PREC) * 100;
+
+	t /= CDF_TIME_PREC;
+	tm.tm_sec = t % 60;
+	t /= 60;
+
+	tm.tm_min = t % 60;
+	t /= 60;
+
+	tm.tm_hour = t % 24;
+	t /= 24;
+
+	// XXX: Approx
+	tm.tm_year = CDF_BASE_YEAR + (t / 365);
+
+	int rdays = cdf_getdays(tm.tm_year);
+	t -= rdays;
+	tm.tm_mday = cdf_getday(tm.tm_year, t);
+	tm.tm_mon = cdf_getmonth(tm.tm_year, t);
+	tm.tm_wday = 0;
+	tm.tm_yday = 0;
+	tm.tm_isdst = 0;
+#ifdef HAVE_STRUCT_TM_TM_GMTOFF
+	tm.tm_gmtoff = 0;
+#endif
+#ifdef HAVE_STRUCT_TM_TM_ZONE
+	tm.tm_zone = UTC;
+#endif
+	tm.tm_year -= 1900;
+	ts->tv_sec = mktime(&tm);
+	if (ts->tv_sec == -1) {
+		errno = EINVAL;
+		return -1;
+	}
+	return 0;
+}
+
+int
+cdf_timespec_to_timestamp(cdf_timestamp_t *t, const struct timespec *ts)
+{
+	(void)&t;
+	(void)&ts;
+#ifdef notyet
+	struct tm tm;
+	if (gmtime_r(&ts->ts_sec, &tm) == NULL) {
+		errno = EINVAL;
+		return -1;
+	}
+	*t = (ts->ts_nsec / 100) * CDF_TIME_PREC;
+	*t = tm.tm_sec;
+	*t += tm.tm_min * 60;
+	*t += tm.tm_hour * 60 * 60;
+	*t += tm.tm_mday * 60 * 60 * 24;
+#endif
+	return 0;
+}
+
+
+#ifdef TEST
+int
+main(int argc, char *argv[])
+{
+	struct timespec ts;
+	static const cdf_timestamp_t tst = 0x01A5E403C2D59C00ULL;
+	static const char *ref = "Sat Apr 23 01:30:00 1977";
+	char *p, *q;
+
+	cdf_timestamp_to_timespec(&ts, tst);
+	p = ctime(&ts.tv_sec);
+	if ((q = strchr(p, '\n')) != NULL)
+		*q = '\0';
+	if (strcmp(ref, p) != 0)
+		errx(1, "Error date %s != %s\n", ref, p);
+	return 0;
+}
+#endif
diff --git a/encoding.c b/encoding.c
new file mode 100644
index 000000000000..4e94f9b868f0
--- /dev/null
+++ b/encoding.c
@@ -0,0 +1,484 @@
+/*
+ * Copyright (c) Ian F. Darwin 1986-1995.
+ * Software written by Ian F. Darwin and others;
+ * maintained 1995-present by Christos Zoulas and others.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice immediately at the beginning of the file, without modification,
+ *    this list of conditions, and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+/*
+ * Encoding -- determine the character encoding of a text file.
+ *
+ * Joerg Wunsch <joerg@freebsd.org> wrote the original support for 8-bit
+ * international characters.
+ */
+
+#include "file.h"
+
+#ifndef	lint
+FILE_RCSID("@(#)$File: encoding.c,v 1.3 2009/02/03 20:27:51 christos Exp $")
+#endif	/* lint */
+
+#include "magic.h"
+#include <string.h>
+#include <memory.h>
+#include <stdlib.h>
+
+
+private int looks_ascii(const unsigned char *, size_t, unichar *, size_t *);
+private int looks_utf8_with_BOM(const unsigned char *, size_t, unichar *,
+    size_t *);
+private int looks_ucs16(const unsigned char *, size_t, unichar *, size_t *);
+private int looks_latin1(const unsigned char *, size_t, unichar *, size_t *);
+private int looks_extended(const unsigned char *, size_t, unichar *, size_t *);
+private void from_ebcdic(const unsigned char *, size_t, unsigned char *);
+
+/*
+ * Try to determine whether text is in some character code we can
+ * identify.  Each of these tests, if it succeeds, will leave
+ * the text converted into one-unichar-per-character Unicode in
+ * ubuf, and the number of characters converted in ulen.
+ */
+protected int
+file_encoding(struct magic_set *ms, const unsigned char *buf, size_t nbytes, unichar **ubuf, size_t *ulen, const char **code, const char **code_mime, const char **type)
+{
+	size_t mlen;
+	int rv = 1, ucs_type;
+	unsigned char *nbuf = NULL;
+
+	mlen = (nbytes + 1) * sizeof(nbuf[0]);
+	if ((nbuf = CAST(unsigned char *, calloc((size_t)1, mlen))) == NULL) {
+		file_oomem(ms, mlen);
+		goto done;
+	}
+	mlen = (nbytes + 1) * sizeof((*ubuf)[0]);
+	if ((*ubuf = CAST(unichar *, calloc((size_t)1, mlen))) == NULL) {
+		file_oomem(ms, mlen);
+		goto done;
+	}
+
+	*type = "text";
+	if (looks_ascii(buf, nbytes, *ubuf, ulen)) {
+		*code = "ASCII";
+		*code_mime = "us-ascii";
+	} else if (looks_utf8_with_BOM(buf, nbytes, *ubuf, ulen) > 0) {
+		*code = "UTF-8 Unicode (with BOM)";
+		*code_mime = "utf-8";
+	} else if (file_looks_utf8(buf, nbytes, *ubuf, ulen) > 1) {
+		*code = "UTF-8 Unicode";
+		*code_mime = "utf-8";
+	} else if ((ucs_type = looks_ucs16(buf, nbytes, *ubuf, ulen)) != 0) {
+		if (ucs_type == 1) {
+			*code = "Little-endian UTF-16 Unicode";
+			*code_mime = "utf-16le";
+		} else {
+			*code = "Big-endian UTF-16 Unicode";
+			*code_mime = "utf-16be";
+		}
+	} else if (looks_latin1(buf, nbytes, *ubuf, ulen)) {
+		*code = "ISO-8859";
+		*code_mime = "iso-8859-1";
+	} else if (looks_extended(buf, nbytes, *ubuf, ulen)) {
+		*code = "Non-ISO extended-ASCII";
+		*code_mime = "unknown-8bit";
+	} else {
+		from_ebcdic(buf, nbytes, nbuf);
+
+		if (looks_ascii(nbuf, nbytes, *ubuf, ulen)) {
+			*code = "EBCDIC";
+			*code_mime = "ebcdic";
+		} else if (looks_latin1(nbuf, nbytes, *ubuf, ulen)) {
+			*code = "International EBCDIC";
+			*code_mime = "ebcdic";
+		} else { /* Doesn't look like text at all */
+			rv = 0;
+			*type = "binary";
+		}
+	}
+
+ done:
+	if (nbuf)
+		free(nbuf);
+
+	return rv;
+}
+
+/*
+ * This table reflects a particular philosophy about what constitutes
+ * "text," and there is room for disagreement about it.
+ *
+ * Version 3.31 of the file command considered a file to be ASCII if
+ * each of its characters was approved by either the isascii() or
+ * isalpha() function.  On most systems, this would mean that any
+ * file consisting only of characters in the range 0x00 ... 0x7F
+ * would be called ASCII text, but many systems might reasonably
+ * consider some characters outside this range to be alphabetic,
+ * so the file command would call such characters ASCII.  It might
+ * have been more accurate to call this "considered textual on the
+ * local system" than "ASCII."
+ *
+ * It considered a file to be "International language text" if each
+ * of its characters was either an ASCII printing character (according
+ * to the real ASCII standard, not the above test), a character in
+ * the range 0x80 ... 0xFF, or one of the following control characters:
+ * backspace, tab, line feed, vertical tab, form feed, carriage return,
+ * escape.  No attempt was made to determine the language in which files
+ * of this type were written.
+ *
+ *
+ * The table below considers a file to be ASCII if all of its characters
+ * are either ASCII printing characters (again, according to the X3.4
+ * standard, not isascii()) or any of the following controls: bell,
+ * backspace, tab, line feed, form feed, carriage return, esc, nextline.
+ *
+ * I include bell because some programs (particularly shell scripts)
+ * use it literally, even though it is rare in normal text.  I exclude
+ * vertical tab because it never seems to be used in real text.  I also
+ * include, with hesitation, the X3.64/ECMA-43 control nextline (0x85),
+ * because that's what the dd EBCDIC->ASCII table maps the EBCDIC newline
+ * character to.  It might be more appropriate to include it in the 8859
+ * set instead of the ASCII set, but it's got to be included in *something*
+ * we recognize or EBCDIC files aren't going to be considered textual.
+ * Some old Unix source files use SO/SI (^N/^O) to shift between Greek
+ * and Latin characters, so these should possibly be allowed.  But they
+ * make a real mess on VT100-style displays if they're not paired properly,
+ * so we are probably better off not calling them text.
+ *
+ * A file is considered to be ISO-8859 text if its characters are all
+ * either ASCII, according to the above definition, or printing characters
+ * from the ISO-8859 8-bit extension, characters 0xA0 ... 0xFF.
+ *
+ * Finally, a file is considered to be international text from some other
+ * character code if its characters are all either ISO-8859 (according to
+ * the above definition) or characters in the range 0x80 ... 0x9F, which
+ * ISO-8859 considers to be control characters but the IBM PC and Macintosh
+ * consider to be printing characters.
+ */
+
+#define F 0   /* character never appears in text */
+#define T 1   /* character appears in plain ASCII text */
+#define I 2   /* character appears in ISO-8859 text */
+#define X 3   /* character appears in non-ISO extended ASCII (Mac, IBM PC) */
+
+private char text_chars[256] = {
+	/*                  BEL BS HT LF    FF CR    */
+	F, F, F, F, F, F, F, T, T, T, T, F, T, T, F, F,  /* 0x0X */
+	/*                              ESC          */
+	F, F, F, F, F, F, F, F, F, F, F, T, F, F, F, F,  /* 0x1X */
+	T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x2X */
+	T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x3X */
+	T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x4X */
+	T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x5X */
+	T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x6X */
+	T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, F,  /* 0x7X */
+	/*            NEL                            */
+	X, X, X, X, X, T, X, X, X, X, X, X, X, X, X, X,  /* 0x8X */
+	X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X,  /* 0x9X */
+	I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xaX */
+	I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xbX */
+	I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xcX */
+	I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xdX */
+	I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xeX */
+	I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I   /* 0xfX */
+};
+
+private int
+looks_ascii(const unsigned char *buf, size_t nbytes, unichar *ubuf,
+    size_t *ulen)
+{
+	size_t i;
+
+	*ulen = 0;
+
+	for (i = 0; i < nbytes; i++) {
+		int t = text_chars[buf[i]];
+
+		if (t != T)
+			return 0;
+
+		ubuf[(*ulen)++] = buf[i];
+	}
+
+	return 1;
+}
+
+private int
+looks_latin1(const unsigned char *buf, size_t nbytes, unichar *ubuf, size_t *ulen)
+{
+	size_t i;
+
+	*ulen = 0;
+
+	for (i = 0; i < nbytes; i++) {
+		int t = text_chars[buf[i]];
+
+		if (t != T && t != I)
+			return 0;
+
+		ubuf[(*ulen)++] = buf[i];
+	}
+
+	return 1;
+}
+
+private int
+looks_extended(const unsigned char *buf, size_t nbytes, unichar *ubuf,
+    size_t *ulen)
+{
+	size_t i;
+
+	*ulen = 0;
+
+	for (i = 0; i < nbytes; i++) {
+		int t = text_chars[buf[i]];
+
+		if (t != T && t != I && t != X)
+			return 0;
+
+		ubuf[(*ulen)++] = buf[i];
+	}
+
+	return 1;
+}
+
+/*
+ * Decide whether some text looks like UTF-8. Returns:
+ *
+ *     -1: invalid UTF-8
+ *      0: uses odd control characters, so doesn't look like text
+ *      1: 7-bit text
+ *      2: definitely UTF-8 text (valid high-bit set bytes)
+ *
+ * If ubuf is non-NULL on entry, text is decoded into ubuf, *ulen;
+ * ubuf must be big enough!
+ */
+protected int
+file_looks_utf8(const unsigned char *buf, size_t nbytes, unichar *ubuf, size_t *ulen)
+{
+	size_t i;
+	int n;
+	unichar c;
+	int gotone = 0, ctrl = 0;
+
+	if (ubuf)
+		*ulen = 0;
+
+	for (i = 0; i < nbytes; i++) {
+		if ((buf[i] & 0x80) == 0) {	   /* 0xxxxxxx is plain ASCII */
+			/*
+			 * Even if the whole file is valid UTF-8 sequences,
+			 * still reject it if it uses weird control characters.
+			 */
+
+			if (text_chars[buf[i]] != T)
+				ctrl = 1;
+
+			if (ubuf)
+				ubuf[(*ulen)++] = buf[i];
+		} else if ((buf[i] & 0x40) == 0) { /* 10xxxxxx never 1st byte */
+			return -1;
+		} else {			   /* 11xxxxxx begins UTF-8 */
+			int following;
+
+			if ((buf[i] & 0x20) == 0) {		/* 110xxxxx */
+				c = buf[i] & 0x1f;
+				following = 1;
+			} else if ((buf[i] & 0x10) == 0) {	/* 1110xxxx */
+				c = buf[i] & 0x0f;
+				following = 2;
+			} else if ((buf[i] & 0x08) == 0) {	/* 11110xxx */
+				c = buf[i] & 0x07;
+				following = 3;
+			} else if ((buf[i] & 0x04) == 0) {	/* 111110xx */
+				c = buf[i] & 0x03;
+				following = 4;
+			} else if ((buf[i] & 0x02) == 0) {	/* 1111110x */
+				c = buf[i] & 0x01;
+				following = 5;
+			} else
+				return -1;
+
+			for (n = 0; n < following; n++) {
+				i++;
+				if (i >= nbytes)
+					goto done;
+
+				if ((buf[i] & 0x80) == 0 || (buf[i] & 0x40))
+					return -1;
+
+				c = (c << 6) + (buf[i] & 0x3f);
+			}
+
+			if (ubuf)
+				ubuf[(*ulen)++] = c;
+			gotone = 1;
+		}
+	}
+done:
+	return ctrl ? 0 : (gotone ? 2 : 1);
+}
+
+/*
+ * Decide whether some text looks like UTF-8 with BOM. If there is no
+ * BOM, return -1; otherwise return the result of looks_utf8 on the
+ * rest of the text.
+ */
+private int
+looks_utf8_with_BOM(const unsigned char *buf, size_t nbytes, unichar *ubuf,
+    size_t *ulen)
+{
+	if (nbytes > 3 && buf[0] == 0xef && buf[1] == 0xbb && buf[2] == 0xbf)
+		return file_looks_utf8(buf + 3, nbytes - 3, ubuf, ulen);
+	else
+		return -1;
+}
+
+private int
+looks_ucs16(const unsigned char *buf, size_t nbytes, unichar *ubuf,
+    size_t *ulen)
+{
+	int bigend;
+	size_t i;
+
+	if (nbytes < 2)
+		return 0;
+
+	if (buf[0] == 0xff && buf[1] == 0xfe)
+		bigend = 0;
+	else if (buf[0] == 0xfe && buf[1] == 0xff)
+		bigend = 1;
+	else
+		return 0;
+
+	*ulen = 0;
+
+	for (i = 2; i + 1 < nbytes; i += 2) {
+		/* XXX fix to properly handle chars > 65536 */
+
+		if (bigend)
+			ubuf[(*ulen)++] = buf[i + 1] + 256 * buf[i];
+		else
+			ubuf[(*ulen)++] = buf[i] + 256 * buf[i + 1];
+
+		if (ubuf[*ulen - 1] == 0xfffe)
+			return 0;
+		if (ubuf[*ulen - 1] < 128 &&
+		    text_chars[(size_t)ubuf[*ulen - 1]] != T)
+			return 0;
+	}
+
+	return 1 + bigend;
+}
+
+#undef F
+#undef T
+#undef I
+#undef X
+
+/*
+ * This table maps each EBCDIC character to an (8-bit extended) ASCII
+ * character, as specified in the rationale for the dd(1) command in
+ * draft 11.2 (September, 1991) of the POSIX P1003.2 standard.
+ *
+ * Unfortunately it does not seem to correspond exactly to any of the
+ * five variants of EBCDIC documented in IBM's _Enterprise Systems
+ * Architecture/390: Principles of Operation_, SA22-7201-06, Seventh
+ * Edition, July, 1999, pp. I-1 - I-4.
+ *
+ * Fortunately, though, all versions of EBCDIC, including this one, agree
+ * on most of the printing characters that also appear in (7-bit) ASCII.
+ * Of these, only '|', '!', '~', '^', '[', and ']' are in question at all.
+ *
+ * Fortunately too, there is general agreement that codes 0x00 through
+ * 0x3F represent control characters, 0x41 a nonbreaking space, and the
+ * remainder printing characters.
+ *
+ * This is sufficient to allow us to identify EBCDIC text and to distinguish
+ * between old-style and internationalized examples of text.
+ */
+
+private unsigned char ebcdic_to_ascii[] = {
+  0,   1,   2,   3, 156,   9, 134, 127, 151, 141, 142,  11,  12,  13,  14,  15,
+ 16,  17,  18,  19, 157, 133,   8, 135,  24,  25, 146, 143,  28,  29,  30,  31,
+128, 129, 130, 131, 132,  10,  23,  27, 136, 137, 138, 139, 140,   5,   6,   7,
+144, 145,  22, 147, 148, 149, 150,   4, 152, 153, 154, 155,  20,  21, 158,  26,
+' ', 160, 161, 162, 163, 164, 165, 166, 167, 168, 213, '.', '<', '(', '+', '|',
+'&', 169, 170, 171, 172, 173, 174, 175, 176, 177, '!', '$', '*', ')', ';', '~',
+'-', '/', 178, 179, 180, 181, 182, 183, 184, 185, 203, ',', '%', '_', '>', '?',
+186, 187, 188, 189, 190, 191, 192, 193, 194, '`', ':', '#', '@', '\'','=', '"',
+195, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 196, 197, 198, 199, 200, 201,
+202, 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', '^', 204, 205, 206, 207, 208,
+209, 229, 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 210, 211, 212, '[', 214, 215,
+216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, ']', 230, 231,
+'{', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 232, 233, 234, 235, 236, 237,
+'}', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 238, 239, 240, 241, 242, 243,
+'\\',159, 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 244, 245, 246, 247, 248, 249,
+'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 250, 251, 252, 253, 254, 255
+};
+
+#ifdef notdef
+/*
+ * The following EBCDIC-to-ASCII table may relate more closely to reality,
+ * or at least to modern reality.  It comes from
+ *
+ *   http://ftp.s390.ibm.com/products/oe/bpxqp9.html
+ *
+ * and maps the characters of EBCDIC code page 1047 (the code used for
+ * Unix-derived software on IBM's 390 systems) to the corresponding
+ * characters from ISO 8859-1.
+ *
+ * If this table is used instead of the above one, some of the special
+ * cases for the NEL character can be taken out of the code.
+ */
+
+private unsigned char ebcdic_1047_to_8859[] = {
+0x00,0x01,0x02,0x03,0x9C,0x09,0x86,0x7F,0x97,0x8D,0x8E,0x0B,0x0C,0x0D,0x0E,0x0F,
+0x10,0x11,0x12,0x13,0x9D,0x0A,0x08,0x87,0x18,0x19,0x92,0x8F,0x1C,0x1D,0x1E,0x1F,
+0x80,0x81,0x82,0x83,0x84,0x85,0x17,0x1B,0x88,0x89,0x8A,0x8B,0x8C,0x05,0x06,0x07,
+0x90,0x91,0x16,0x93,0x94,0x95,0x96,0x04,0x98,0x99,0x9A,0x9B,0x14,0x15,0x9E,0x1A,
+0x20,0xA0,0xE2,0xE4,0xE0,0xE1,0xE3,0xE5,0xE7,0xF1,0xA2,0x2E,0x3C,0x28,0x2B,0x7C,
+0x26,0xE9,0xEA,0xEB,0xE8,0xED,0xEE,0xEF,0xEC,0xDF,0x21,0x24,0x2A,0x29,0x3B,0x5E,
+0x2D,0x2F,0xC2,0xC4,0xC0,0xC1,0xC3,0xC5,0xC7,0xD1,0xA6,0x2C,0x25,0x5F,0x3E,0x3F,
+0xF8,0xC9,0xCA,0xCB,0xC8,0xCD,0xCE,0xCF,0xCC,0x60,0x3A,0x23,0x40,0x27,0x3D,0x22,
+0xD8,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0xAB,0xBB,0xF0,0xFD,0xFE,0xB1,
+0xB0,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0xAA,0xBA,0xE6,0xB8,0xC6,0xA4,
+0xB5,0x7E,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0xA1,0xBF,0xD0,0x5B,0xDE,0xAE,
+0xAC,0xA3,0xA5,0xB7,0xA9,0xA7,0xB6,0xBC,0xBD,0xBE,0xDD,0xA8,0xAF,0x5D,0xB4,0xD7,
+0x7B,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0xAD,0xF4,0xF6,0xF2,0xF3,0xF5,
+0x7D,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0xB9,0xFB,0xFC,0xF9,0xFA,0xFF,
+0x5C,0xF7,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0xB2,0xD4,0xD6,0xD2,0xD3,0xD5,
+0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0xB3,0xDB,0xDC,0xD9,0xDA,0x9F
+};
+#endif
+
+/*
+ * Copy buf[0 ... nbytes-1] into out[], translating EBCDIC to ASCII.
+ */
+private void
+from_ebcdic(const unsigned char *buf, size_t nbytes, unsigned char *out)
+{
+	size_t i;
+
+	for (i = 0; i < nbytes; i++) {
+		out[i] = ebcdic_to_ascii[buf[i]];
+	}
+}
diff --git a/readcdf.c b/readcdf.c
new file mode 100644
index 000000000000..27031dbd9dd3
--- /dev/null
+++ b/readcdf.c
@@ -0,0 +1,256 @@
+/*-
+ * Copyright (c) 2008 Christos Zoulas
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "file.h"
+
+#ifndef lint
+FILE_RCSID("@(#)$File: readcdf.c,v 1.11 2009/02/03 20:27:51 christos Exp $")
+#endif
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <time.h>
+#include <ctype.h>
+
+#include "cdf.h"
+#include "magic.h"
+
+#define NOTMIME(ms) (((ms)->flags & MAGIC_MIME) == 0)
+
+private int
+cdf_file_property_info(struct magic_set *ms, const cdf_property_info_t *info,
+    size_t count)
+{
+	size_t i;
+	cdf_timestamp_t tp;
+	struct timespec ts;
+	char buf[64];
+	const char *str = "vnd.ms-office";
+	const char *s;
+	int len;
+
+	for (i = 0; i < count; i++) {
+		cdf_print_property_name(buf, sizeof(buf), info[i].pi_id);
+		switch (info[i].pi_type) {
+		case CDF_SIGNED16:
+			if (NOTMIME(ms) && file_printf(ms, ", %s: %hd", buf,
+			    info[i].pi_s16) == -1)
+				return -1;
+			break;
+		case CDF_SIGNED32:
+			if (NOTMIME(ms) && file_printf(ms, ", %s: %d", buf,
+			    info[i].pi_s32) == -1)
+				return -1;
+			break;
+		case CDF_UNSIGNED32:
+			if (NOTMIME(ms) && file_printf(ms, ", %s: %u", buf,
+			    info[i].pi_u32) == -1)
+				return -1;
+			break;
+		case CDF_LENGTH32_STRING:
+			len = info[i].pi_str.s_len;
+			if (len > 1) {
+				s = info[i].pi_str.s_buf;
+				if (NOTMIME(ms)) {
+					if (file_printf(ms, ", %s: %.*s", buf,
+					    len, s) == -1)
+						return -1;
+				} else if (info[i].pi_id == 
+					CDF_PROPERTY_NAME_OF_APPLICATION) {
+					if (strstr(s, "Word"))
+						str = "msword";
+					else if (strstr(s, "Excel"))
+						str = "vnd.ms-excel";
+					else if (strstr(s, "Powerpoint"))
+						str = "vnd.ms-powerpoint";
+				}
+			}
+			break;
+		case CDF_FILETIME:
+			tp = info[i].pi_tp;
+			if (tp != 0) {
+				if (tp < 1000000000000000LL) {
+					char tbuf[64];
+					cdf_print_elapsed_time(tbuf,
+					    sizeof(tbuf), tp);
+					if (NOTMIME(ms) && file_printf(ms,
+					    ", %s: %s", buf, tbuf) == -1)
+						return -1;
+				} else {
+					char *c, *ec;
+					cdf_timestamp_to_timespec(&ts, tp);
+					c = ctime(&ts.tv_sec);
+					if ((ec = strchr(c, '\n')) != NULL)
+						*ec = '\0';
+
+					if (NOTMIME(ms) && file_printf(ms,
+					    ", %s: %s", buf, c) == -1)
+						return -1;
+				}
+			}
+			break;
+		case CDF_CLIPBOARD:
+			break;
+		default:
+			file_error(ms, 0, "Internal parsing error");
+			return -1;
+		}
+	}
+	if (!NOTMIME(ms)) {
+		if (file_printf(ms, "application/%s", str) == -1)
+			return -1;
+	}
+	return 1;
+}
+
+private int
+cdf_file_summary_info(struct magic_set *ms, const cdf_stream_t *sst)
+{
+	cdf_summary_info_header_t si;
+	cdf_property_info_t *info;
+	size_t count;
+	int m;
+
+	if (cdf_unpack_summary_info(sst, &si, &info, &count) == -1) {
+		if (si.si_byte_order != 0xfffe)
+			return 0;
+		else
+			return -1;
+	}
+
+	if (si.si_byte_order != 0xfffe)
+		return 0;
+
+	if (NOTMIME(ms)) {
+		if (file_printf(ms, "CDF V2 Document") == -1)
+			return -1;
+
+		if (file_printf(ms, ", %s Endian",
+		    si.si_byte_order == 0xfffe ?  "Little" : "Big") == -1)
+			return -1;
+		switch (si.si_os) {
+		case 2:
+			if (file_printf(ms, ", Os: Windows, Version %d.%d",
+			    si.si_os_version & 0xff, si.si_os_version >> 8)
+			    == -1)
+				return -1;
+			break;
+		case 1:
+			if (file_printf(ms, ", Os: MacOS, Version %d.%d",
+			    si.si_os_version >> 8, si.si_os_version & 0xff)
+			    == -1)
+				return -1;
+			break;
+		default:
+			if (file_printf(ms, ", Os %d, Version: %d.%d", si.si_os,
+			    si.si_os_version & 0xff, si.si_os_version >> 8)
+			    == -1)
+				return -1;
+			break;
+		}
+	}
+
+	m = cdf_file_property_info(ms, info, count);
+	free(info);
+
+	return m;
+}
+
+protected int
+file_trycdf(struct magic_set *ms, int fd, const unsigned char *buf,
+    size_t nbytes)
+{
+	cdf_header_t h;
+	cdf_sat_t sat, ssat;
+	cdf_stream_t sst, scn;
+	cdf_dir_t dir;
+	int i;
+	(void)&nbytes;
+	(void)&buf;
+
+	if (ms->flags & MAGIC_APPLE)
+		return 0;
+	if (cdf_read_header(fd, &h) == -1)
+		return 0;
+#ifdef CDF_DEBUG
+	cdf_dump_header(&h);
+#endif
+
+	if (cdf_read_sat(fd, &h, &sat) == -1) {
+		file_error(ms, errno, "Can't read SAT");
+		return -1;
+	}
+#ifdef CDF_DEBUG
+	cdf_dump_sat("SAT", &h, &sat);
+#endif
+
+	if ((i = cdf_read_ssat(fd, &h, &sat, &ssat)) == -1) {
+		file_error(ms, errno, "Can't read SAT");
+		goto out1;
+	}
+#ifdef CDF_DEBUG
+	cdf_dump_sat("SSAT", &h, &ssat);
+#endif
+
+	if ((i = cdf_read_dir(fd, &h, &sat, &dir)) == -1) {
+		file_error(ms, errno, "Can't read directory");
+		goto out2;
+	}
+
+	if ((i = cdf_read_short_stream(fd, &h, &sat, &dir, &sst)) == -1) {
+		file_error(ms, errno, "Cannot read short stream");
+		goto out3;
+	}
+
+#ifdef CDF_DEBUG
+	cdf_dump_dir(fd, &h, &sat, &ssat, &sst, &dir);
+#endif
+	if ((i = cdf_read_summary_info(fd, &h, &sat, &ssat, &sst, &dir, &scn))
+	    == -1) {
+		/* Some files don't have summary info! */
+#ifdef notyet
+		file_error(ms, errno, "Can't read summary_info");
+#else
+		i = 0;
+#endif
+		goto out4;
+	}
+#ifdef CDF_DEBUG
+	cdf_dump_summary_info(&h, &scn);
+#endif
+	if ((i = cdf_file_summary_info(ms, &scn)) == -1)
+		file_error(ms, errno, "Can't expand summary_info");
+	free(scn.sst_tab);
+out4:
+	free(sst.sst_tab);
+out3:
+	free(dir.dir_tab);
+out2:
+	free(ssat.sat_tab);
+out1:
+	free(sat.sat_tab);
+	return i;
+}