commit missing files (helps if you cvs add, don't it?) for tar implementation

2 files changed, 627 insertions, 0 deletions

diff --git a/ext/phar/tar.c b/ext/phar/tar.c
new file mode 100644
index 0000000000..30c6fd2e4c
--- /dev/null
+++ b/ext/phar/tar.c
@@ -0,0 +1,548 @@
+/*
+  +----------------------------------------------------------------------+
+  | TAR archive support for Phar                                         |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 2005-2008 The PHP Group                                |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.01 of the PHP license,      |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_01.txt.                                 |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Authors: Dmitry Stogov <dmitry@zend.com>                             |
+  |          Gregory Beaver <cellog@php.net>                             |
+  +----------------------------------------------------------------------+
+*/
+
+#include "phar_internal.h"
+
+#define TAR_FILE    '0'
+#define TAR_LINK    '1'
+#define TAR_SYMLINK '2'
+#define TAR_DIR     '5'
+#define TAR_NEW     '8'
+
+static php_uint32 phar_tar_number(char *buf, int len) /* {{{ */
+{
+	php_uint32 num = 0;
+	int i = 0;
+
+	while (i < len && buf[i] == ' ') {
+		i++;
+	}
+	while (i < len &&
+	       buf[i] >= '0' &&
+	       buf[i] <= '7') {
+		num = num * 8 + (buf[i] - '0');
+		i++;
+	}
+	return num;
+}
+/* }}} */
+
+/* adapted from format_octal() in libarchive
+ * 
+ * Copyright (c) 2003-2007 Tim Kientzle
+ * 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 AUTHOR(S) ``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(S) 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.
+ */
+static int phar_tar_octal(char *buf, php_uint32 val, int len) /* {{{ */
+{
+	char *p = buf;
+	int s = len;
+
+	p += len;		/* Start at the end and work backwards. */
+	while (s-- > 0) {
+		*--p = (char)('0' + (val & 7));
+		val >>= 3;
+	}
+
+	if (val == 0)
+		return SUCCESS;
+
+	/* If it overflowed, fill field with max value. */
+	while (len-- > 0)
+		*p++ = '7';
+
+	return FAILURE;
+}
+/* }}} */
+
+static php_uint32 phar_tar_checksum(char *buf, int len) /* {{{ */
+{
+	php_uint32 sum = 0;
+	char *end = buf + len;
+
+	while (buf != end) {
+		sum += (unsigned char)*buf;
+		buf++;
+	}
+	return sum;
+}
+/* }}} */
+
+int phar_is_tar(char *buf)
+{
+	tar_header *header = (tar_header *) buf;
+	php_uint32 checksum = phar_tar_number(header->checksum, sizeof(header->checksum));
+	php_uint32 ret;
+	char save[sizeof(header->checksum)];
+
+	/* assume that the first filename in a tar won't begin with <?php */
+	if (!strncmp(buf, "<?php", sizeof("<?php")-1)) {
+		return 0;
+	}
+
+	memcpy(save, header->checksum, sizeof(header->checksum));
+	memset(header->checksum, ' ', sizeof(header->checksum));
+	ret = (checksum == phar_tar_checksum(buf, 512));
+	memcpy(header->checksum, save, sizeof(header->checksum));
+	return ret;
+}
+
+int phar_open_or_create_tar(char *fname, int fname_len, char *alias, int alias_len, int options, phar_archive_data** pphar, char **error TSRMLS_DC) /* {{{ */
+{
+	phar_archive_data *phar;
+	int ret = phar_create_or_parse_filename(fname, fname_len, alias, alias_len, options, pphar, error TSRMLS_CC);
+
+	if (FAILURE == ret) {
+		return FAILURE;
+	}
+	if ((*pphar)->is_tar) {
+		return ret;
+	}
+
+	phar = *pphar;
+	if (phar->is_brandnew) {
+		phar->is_tar = 1;
+		return SUCCESS;
+	}
+
+	/* we've reached here - the phar exists and is a regular phar */
+	if (error) {
+		spprintf(error, 4096, "phar zip error: phar \"%s\" already exists as a regular phar and must be deleted from disk prior to creating as a zip-based phar", fname);
+	}
+	return FAILURE;
+}
+
+int phar_open_tarfile(php_stream* fp, char *fname, int fname_len, char *alias, int alias_len, int options, phar_archive_data** pphar, char **error TSRMLS_DC) /* {{{ */
+{
+	char buf[512], *actual_alias = NULL;
+	phar_entry_info entry = {0};
+	size_t pos = 0, read;
+	tar_header *hdr;
+	php_uint32 sum1, sum2, size, old;
+	phar_archive_data *myphar;
+
+	if (error) {
+		*error = NULL;
+	}
+	php_stream_seek(fp, 0, SEEK_SET);
+
+	read = php_stream_read(fp, buf, sizeof(buf));
+	if (read != sizeof(buf)) {
+		if (error) {
+			spprintf(error, 4096, "phar error: \"%s\" is not a tar file", fname);
+		}
+		php_stream_close(fp);
+		return FAILURE;
+	}
+	hdr = (tar_header*)buf;
+	old = (memcmp(hdr->magic, "ustar", sizeof("ustar")-1) != 0);
+
+	myphar = (phar_archive_data *) ecalloc(1, sizeof(phar_archive_data));
+	zend_hash_init(&myphar->manifest, sizeof(phar_entry_info),
+		zend_get_hash_value, destroy_phar_manifest, 0);
+	myphar->is_tar = 1;
+
+	entry.is_tar = 1;
+	entry.is_crc_checked = 1;
+	entry.phar = myphar;
+	do {
+		if (read != sizeof(buf)) {
+			if (error) {
+				spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file", fname);
+			}
+			php_stream_close(fp);
+			zend_hash_destroy(&myphar->manifest);
+			efree(myphar);
+			return FAILURE;
+		}
+		pos += sizeof(buf);
+		hdr = (tar_header*) buf;
+		sum1 = phar_tar_number(hdr->checksum, sizeof(hdr->checksum));
+		if (sum1 == 0 && phar_tar_checksum(buf, sizeof(buf)) == 0) {
+			break;
+		}
+		memset(hdr->checksum, ' ', sizeof(hdr->checksum));
+		sum2 = phar_tar_checksum(buf, old?sizeof(old_tar_header):sizeof(tar_header));
+		if (sum1 != sum2) {
+			if (error) {
+				spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file", fname);
+			}
+			php_stream_close(fp);
+			zend_hash_destroy(&myphar->manifest);
+			efree(myphar);
+			return FAILURE;
+		}
+
+		size = entry.uncompressed_filesize = entry.compressed_filesize =
+			phar_tar_number(hdr->size, sizeof(hdr->size));
+
+		if (!old && hdr->prefix[0] != 0) {
+			char name[256];
+
+			strcpy(name, hdr->prefix);
+			strcat(name, hdr->name);
+			entry.filename_len = strlen(name);
+			entry.filename = estrndup(name, entry.filename_len);
+		} else {
+			entry.filename = estrdup(hdr->name);
+			entry.filename_len = strlen(entry.filename);
+		}
+
+		entry.tar_type = ((old & (hdr->typeflag == 0))?'0':hdr->typeflag);
+		entry.offset_within_phar = pos;
+		entry.flags = phar_tar_number(hdr->mode, sizeof(hdr->mode)) & PHAR_ENT_PERM_MASK;
+		entry.timestamp = phar_tar_number(hdr->mtime, sizeof(hdr->mtime));
+
+		if (old && entry.tar_type == TAR_FILE && S_ISDIR(entry.flags)) {
+			entry.tar_type = TAR_DIR;
+		}
+
+		entry.link = NULL;
+		if (entry.tar_type == TAR_LINK) {
+			if (!zend_hash_exists(&myphar->manifest, hdr->linkname, strlen(hdr->linkname))) {
+				if (error) {
+					spprintf(error, 4096, "phar error: \"%s\" is a corrupted tar file - symbolic link to non-existent file", fname);
+				}
+				php_stream_close(fp);
+				zend_hash_destroy(&myphar->manifest);
+				efree(myphar);
+				return FAILURE;
+			}
+			entry.link = estrdup(hdr->linkname);
+		} else if (entry.tar_type == TAR_SYMLINK) {
+			entry.link = estrdup(hdr->linkname);
+		}
+		zend_hash_add(&myphar->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL);
+		if (!actual_alias && entry.filename_len == sizeof(".phar/alias.txt")-1 && !strncmp(entry.filename, ".phar/alias.txt", sizeof(".phar/alias.txt")-1)) {
+			size_t read;
+			/* found explicit alias */
+			read = php_stream_read(fp, buf, size);
+			if (read == size) {
+				actual_alias = estrndup(buf, size);
+				myphar->alias = actual_alias;
+				myphar->alias_len = size;
+				php_stream_seek(fp, pos, SEEK_SET);
+			} else {
+				if (error) {
+					spprintf(error, 4096, "phar error: Unable to read alias from tar-based phar \"%s\"", fname);
+				}
+				php_stream_close(fp);
+				zend_hash_destroy(&myphar->manifest);
+				efree(myphar);
+				return FAILURE;
+			}
+		}
+		size = (size+511)&~511;
+		pos += size;
+		if (((hdr->typeflag == 0) || (hdr->typeflag == TAR_FILE)) && size > 0) {
+			php_stream_seek(fp, size, SEEK_CUR);
+		}
+		read = php_stream_read(fp, buf, sizeof(buf));
+	} while (read != 0);
+	myphar->fname = estrndup(fname, fname_len);
+	myphar->fname_len = fname_len;
+	phar_request_initialize(TSRMLS_C);
+	zend_hash_add(&(PHAR_GLOBALS->phar_fname_map), myphar->fname, fname_len, (void*)&myphar, sizeof(phar_archive_data*),  NULL);
+	if (actual_alias) {
+		myphar->is_explicit_alias = 1;
+		zend_hash_add(&(PHAR_GLOBALS->phar_alias_map), actual_alias, myphar->alias_len, (void*)&myphar, sizeof(phar_archive_data*), NULL);
+	} else {
+		myphar->is_explicit_alias = 0;
+	}
+	if (pphar) {
+		*pphar = myphar;
+	}
+	php_stream_close(fp);
+	return SUCCESS;
+}
+/* }}} */
+
+struct _phar_pass_tar_info {
+	php_stream *old;
+	php_stream *new;
+	char **error;
+};
+
+int phar_tar_writeheaders(void *pDest, void *argument TSRMLS_DC)
+{
+	tar_header header;
+	size_t pos;
+	phar_entry_info *entry = (phar_entry_info *) pDest;
+	struct _phar_pass_tar_info *fp = (struct _phar_pass_tar_info *)argument;
+	php_stream *file;
+
+	if (entry->is_deleted) {
+		return ZEND_HASH_APPLY_REMOVE;
+	}
+
+	memset((char *) &header, 0, sizeof(header));
+	if (entry->filename_len > 100) {
+		if (entry->filename_len > 255) {
+			if (fp->error) {
+				spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, filename \"%s\" is too long for tar file format", entry->phar->fname, entry->filename);
+			}
+			return ZEND_HASH_APPLY_STOP;
+		}
+		memcpy(header.prefix, entry->filename+100, entry->filename_len - 100);
+		memcpy(header.name, entry->filename, 100);
+	} else {
+		memcpy(header.name, entry->filename, entry->filename_len);
+	}
+	phar_tar_octal(header.mode, entry->flags & PHAR_ENT_PERM_MASK, sizeof(header.mode));
+	if (FAILURE == phar_tar_octal(header.size, entry->uncompressed_filesize, sizeof(header.size))) {
+		if (fp->error) {
+			spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, filename \"%s\" is too large for tar file format", entry->phar->fname, entry->filename);
+		}
+		return ZEND_HASH_APPLY_STOP;
+	}
+	if (FAILURE == phar_tar_octal(header.mtime, entry->timestamp, sizeof(header.mtime))) {
+		if (fp->error) {
+			spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, file modification time of file \"%s\" is too large for tar file format", entry->phar->fname, entry->filename);
+		}
+		return ZEND_HASH_APPLY_STOP;
+	}
+	/* calc checksum */
+	header.typeflag = entry->tar_type;
+	if (entry->link) {
+		strcpy(header.linkname, entry->link);
+	}
+	strcpy(header.magic, "ustar");
+	strcpy(header.version, "00");
+	strcpy(header.checksum, "        ");
+	entry->crc32 = phar_tar_checksum((char *)&header, sizeof(header));
+	if (FAILURE == phar_tar_octal(header.checksum, entry->crc32, sizeof(header.checksum))) {
+		if (fp->error) {
+			spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, checksum of file \"%s\" is too large for tar file format", entry->phar->fname, entry->filename);
+		}
+		return ZEND_HASH_APPLY_STOP;
+	}
+
+	/* write header */
+	if (sizeof(header) != php_stream_write(fp->new, (char *) &header, sizeof(header))) {
+		if (fp->error) {
+			spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, header for  file \"%s\" could not be written", entry->phar->fname, entry->filename);
+		}
+		return ZEND_HASH_APPLY_STOP;
+	}
+	pos = php_stream_tell(fp->new); /* save start of file within tar */
+
+	/* write contents */
+	if (entry->fp) {
+		/* new file */
+		file = entry->fp;
+		php_stream_seek(file, 0, SEEK_SET);
+	} else {
+		file = fp->old;
+		php_stream_seek(file, entry->offset_within_phar, SEEK_SET);
+	}
+	if (entry->uncompressed_filesize != php_stream_copy_to_stream(file, fp->new, entry->uncompressed_filesize)) {
+		if (fp->error) {
+			spprintf(fp->error, 4096, "tar-based phar \"%s\" cannot be created, contents of file \"%s\" could not be written", entry->phar->fname, entry->filename);
+		}
+		return ZEND_HASH_APPLY_STOP;
+	}
+
+	if (entry->fp) {
+		php_stream_close(entry->fp);
+		entry->fp = NULL;
+	}
+
+	/* note new location within tar */
+	entry->offset_within_phar = pos;
+	return ZEND_HASH_APPLY_KEEP;
+}
+
+int phar_tar_flush(phar_archive_data *archive, char *user_stub, long len, char **error TSRMLS_DC) /* {{{ */
+{
+	phar_entry_info entry = {0};
+	static const char newstub[] = "<?php // tar-based phar archive stub file\n__HALT_COMPILER();";
+	php_stream *oldfile, *newfile, *stubfile;
+	int closeoldfile, free_user_stub;
+	struct _phar_pass_tar_info pass;
+
+	entry.flags = PHAR_ENT_PERM_DEF_FILE;
+	entry.timestamp = time(NULL);
+	entry.is_modified = 1;
+	entry.is_tar = 1;
+	entry.tar_type = '0';
+	/* set alias */
+	if (archive->is_explicit_alias) {
+		entry.filename = estrndup(".phar/alias.txt", sizeof(".phar/alias.txt")-1);
+		entry.filename_len = sizeof(".phar/alias.txt")-1;
+		entry.fp = php_stream_fopen_tmpfile();
+		entry.crc32 = phar_tar_checksum(archive->alias, archive->alias_len);
+		php_stream_write(entry.fp, archive->alias, archive->alias_len);
+		entry.uncompressed_filesize = archive->alias_len;
+		zend_hash_add(&archive->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL);
+	}
+
+	/* set stub */
+	if (user_stub) {
+		char *pos;
+		if (len < 0) {
+			/* resource passed in */
+			if (!(php_stream_from_zval_no_verify(stubfile, (zval **)user_stub))) {
+				if (error) {
+					spprintf(error, 0, "unable to access resource to copy stub to new tar-based phar \"%s\"", archive->fname);
+				}
+				return EOF;
+			}
+			if (len == -1) {
+				len = PHP_STREAM_COPY_ALL;
+			} else {
+				len = -len;
+			}
+			user_stub = 0;
+			if (!(len = php_stream_copy_to_mem(stubfile, &user_stub, len, 0)) || !user_stub) {
+				if (error) {
+					spprintf(error, 0, "unable to read resource to copy stub to new tar-based phar \"%s\"", archive->fname);
+				}
+				return EOF;
+			}
+			free_user_stub = 1;
+		} else {
+			free_user_stub = 0;
+		}
+		if ((pos = strstr(user_stub, "__HALT_COMPILER();")) == NULL)
+		{
+			if (error) {
+				spprintf(error, 0, "illegal stub for tar-based phar \"%s\"", archive->fname);
+			}
+			if (free_user_stub) {
+				efree(user_stub);
+			}
+			return EOF;
+		}
+		len = pos - user_stub + 18;
+		entry.fp = php_stream_fopen_tmpfile();
+		entry.uncompressed_filesize = len + 5;
+
+		if ((size_t)len != php_stream_write(entry.fp, user_stub, len)
+		||            5 != php_stream_write(entry.fp, " ?>\r\n", 5)) {
+			if (error) {
+				spprintf(error, 0, "unable to create stub from string in new tar-based phar \"%s\"", archive->fname);
+			}
+			if (free_user_stub) {
+				efree(user_stub);
+			}
+			php_stream_close(entry.fp);
+			return EOF;
+		}
+		entry.filename = estrndup(".phar/stub.php", sizeof(".phar/stub.php")-1);
+		entry.filename_len = sizeof(".phar/stub.php")-1;
+		zend_hash_add(&archive->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL);
+		if (free_user_stub) {
+			efree(user_stub);
+		}
+	} else {
+		if (archive->is_brandnew) {
+			/* this is a brand new phar */
+			entry.fp = php_stream_fopen_tmpfile();
+			if (sizeof(newstub)-1 != php_stream_write(entry.fp, newstub, sizeof(newstub)-1)) {
+				if (error) {
+					spprintf(error, 0, "unable to create stub in new phar \"%s\"", archive->fname);
+				}
+				return EOF;
+			}
+			entry.uncompressed_filesize = sizeof(newstub) - 1;
+			entry.filename = estrndup(".phar/stub.php", sizeof(".phar/stub.php")-1);
+			entry.filename_len = sizeof(".phar/stub.php")-1;
+			zend_hash_add(&archive->manifest, entry.filename, entry.filename_len, (void*)&entry, sizeof(phar_entry_info), NULL);
+		}
+	}
+
+	if (archive->fp && !archive->is_brandnew) {
+		oldfile = archive->fp;
+		closeoldfile = 0;
+		php_stream_rewind(oldfile);
+	} else {
+		oldfile = php_stream_open_wrapper(archive->fname, "rb", 0, NULL);
+		closeoldfile = oldfile != NULL;
+	}
+	newfile = php_stream_fopen_tmpfile();
+	if (!newfile) {
+		if (error) {
+			spprintf(error, 0, "unable to create temporary file");
+		}
+		if (closeoldfile) {
+			php_stream_close(oldfile);
+		}
+		return EOF;
+	}
+
+	pass.old = oldfile;
+	pass.new = newfile;
+	pass.error = error;
+
+	zend_hash_apply_with_argument(&archive->manifest, (apply_func_arg_t) phar_tar_writeheaders, (void *) &pass TSRMLS_CC);
+
+	if (closeoldfile) {
+		php_stream_close(oldfile);
+	}
+	/* on error in the hash iterator above, error is set */
+	if (error && *error) {
+		php_stream_close(newfile);
+		return EOF;
+	}
+	if (archive->fp) {
+		php_stream_close(archive->fp);
+	}
+
+	archive->is_brandnew = 0;
+
+	php_stream_rewind(newfile);
+
+	if (archive->donotflush) {
+		/* deferred flush */
+		archive->fp = newfile;
+	} else {
+		archive->fp = php_stream_open_wrapper(archive->fname, "w+b", IGNORE_URL|STREAM_MUST_SEEK|REPORT_ERRORS, NULL);
+		if (!archive->fp) {
+			archive->fp = newfile;
+			if (error) {
+				spprintf(error, 0, "unable to open new phar \"%s\" for writing", archive->fname);
+			}
+			return EOF;
+		}
+		php_stream_copy_to_stream(newfile, archive->fp, PHP_STREAM_COPY_ALL);
+		php_stream_close(newfile);
+		/* we could also reopen the file in "rb" mode but there is no need for that */
+	}
+	return EOF;
+}
+/* }}} */
diff --git a/ext/phar/tar.h b/ext/phar/tar.h
new file mode 100644
index 0000000000..3938518905
--- /dev/null
+++ b/ext/phar/tar.h
@@ -0,0 +1,79 @@
+#ifndef __PHAR_TAR_H
+#define __PHAR_TAR_H
+/*
+  +----------------------------------------------------------------------+
+  | TAR archive support for Phar                                         |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 2005-2008 The PHP Group                                |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.01 of the PHP license,      |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_01.txt.                                 |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Authors: Dmitry Stogov <dmitry@zend.com>                             |
+  |          Gregory Beaver <cellog@php.net>                             |
+  +----------------------------------------------------------------------+
+*/
+
+/**
+ * the format of the header block for a file, in the older UNIX-compatible
+ * TAR format
+ */
+typedef struct _old_tar_header {  /* {{{ */
+	char name[100];     /* name of file;
+	                         directory is indicated by a trailing slash (/) */
+	char mode[8];       /* file mode */
+	char uid[8];        /* owner user ID */
+	char gid[8];        /* owner group ID */
+	char size[12];      /* length of file in bytes */
+	char mtime[12];     /* modify time of file */
+	char checksum[8];   /* checksum for header */
+	char link;          /* indicator for links;
+	                         1 for a linked file,
+	                         2 for a symbolic link,
+	                         0 otherwise */
+	char linkname[100]; /* name of linked file */
+} old_tar_header;
+/* }}} */
+
+/**
+ * the new USTAR header format.
+ * Note that tar can determine that the USTAR format is being used by the
+ * presence of the null-terminated string "ustar" in the magic field.
+ */
+typedef struct _tar_header {  /* {{{ */
+	char name[100];     /* name of file */
+	char mode[8];       /* file mode   */
+	char uid[8];        /* owner user ID */
+	char gid[8];        /* owner group ID */
+	char size[12];      /* length of file in bytes */
+	char mtime[12];     /* modify time of file */
+	char checksum[8];   /* checksum for header */
+	char typeflag;      /* type of file
+	                         0 Regular file
+	                         1 Link to another file already archived
+	                         2 Symbolic link
+	                         3 Character special device
+	                         4 Block special device
+	                         5 Directory
+	                         6 FIFO special file
+	                         7 Reserved */
+	char linkname[100]; /* name of linked file */
+	char magic[6];      /* USTAR indicator */
+	char version[2];    /* USTAR version */
+	char uname[32];     /* owner user name */
+	char gname[32];     /* owner group name */
+	char devmajor[8];   /* device major number */
+	char devminor[8];   /* device minor number */
+	char prefix[155];   /* prefix for file name;
+	                       the value of the prefix field, if non-null,
+	                       is prefixed to the name field to allow names
+	                       longer then 100 characters */
+} tar_header;
+/* }}} */
+
+#endif