rpc: implemented new rpc helper tool

qubes-rpc/tar2qfile.c

@@ -0,0 +1,794 @@
+/*
+/*	$OpenBSD: tar.h,v 1.7 2003/06/02 23:32:09 millert Exp $	*/
+/*	$NetBSD: tar.h,v 1.3 1995/03/21 09:07:51 cgd Exp $	*/
+
+/*-
+ * Copyright (c) 1992 Keith Muller.
+ * Copyright (c) 1992, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Keith Muller of the University of California, San Diego.
+ *
+ * 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.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ *
+ *	@(#)tar.h	8.2 (Berkeley) 4/18/94
+ */
+
+#define _GNU_SOURCE /* For O_NOFOLLOW. */
+#include <errno.h>
+#include <ioall.h>
+#include <fcntl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <qfile-agent.c>
+
+
+
+/***************************************************
+ * Most routines extracted from the PAX project (tar.c...) *
+ ***************************************************/
+
+/*
+ * BSD PAX global data structures and constants.
+ */
+
+#define	MAXBLK		64512	/* MAX blocksize supported (posix SPEC) */
+				/* WARNING: increasing MAXBLK past 32256 */
+				/* will violate posix spec. */
+#define	MAXBLK_POSIX	32256	/* MAX blocksize supported as per POSIX */
+#define BLKMULT		512	/* blocksize must be even mult of 512 bytes */
+				/* Don't even think of changing this */
+#define DEVBLK		8192	/* default read blksize for devices */
+#define FILEBLK		10240	/* default read blksize for files */
+#define PAXPATHLEN	3072	/* maximium path length for pax. MUST be */
+
+
+/*
+ * defines and data structures common to all tar formats
+ */
+#define CHK_LEN		8		/* length of checksum field */
+#define TNMSZ		100		/* size of name field */
+#define NULLCNT		2		/* number of null blocks in trailer */
+#define CHK_OFFSET	148		/* start of chksum field */
+#define BLNKSUM		256L		/* sum of checksum field using ' ' */
+
+/*
+ * General Defines
+ */
+#define HEX		16
+#define OCT		8
+#define _PAX_		1
+#define _TFILE_BASE	"paxXXXXXXXXXX"
+
+/*
+ * General Macros
+ */
+#ifndef MIN
+#define	MIN(a,b) (((a)<(b))?(a):(b))
+#endif
+#ifndef MAX
+#define	MAX(a,b) (((a)>(b))?(a):(b))
+#endif
+#define MAJOR(x)	major(x)
+#define MINOR(x)	minor(x)
+#define TODEV(x, y)	makedev((x), (y))
+
+
+/*
+ * Values used in typeflag field in all tar formats
+ * (only REGTYPE, LNKTYPE and SYMTYPE are used in old bsd tar headers)
+ */
+#define	REGTYPE		'0'		/* Regular File */
+#define	AREGTYPE	'\0'		/* Regular File */
+#define	LNKTYPE		'1'		/* Link */
+#define	SYMTYPE		'2'		/* Symlink */
+#define	CHRTYPE		'3'		/* Character Special File */
+#define	BLKTYPE		'4'		/* Block Special File */
+#define	DIRTYPE		'5'		/* Directory */
+#define	FIFOTYPE	'6'		/* FIFO */
+#define	CONTTYPE	'7'		/* high perf file */
+
+/*
+ * GNU tar compatibility;
+ */
+#define	LONGLINKTYPE	'K'		/* Long Symlink */
+#define	LONGNAMETYPE	'L'		/* Long File */
+#define EXTHEADERTYPE	'x'		/* Extended header */
+
+/*
+ * Pad with a bit mask, much faster than doing a mod but only works on powers
+ * of 2. Macro below is for block of 512 bytes.
+ */
+#define TAR_PAD(x)	((512 - ((x) & 511)) & 511)
+
+/*
+ * Data Interchange Format - Extended tar header format - POSIX 1003.1-1990
+ */
+#define TPFSZ		155
+#define	TMAGIC		"ustar"		/* ustar and a null */
+#define	TMAGLEN		6
+#define	TVERSION	"00"		/* 00 and no null */
+#define	TVERSLEN	2
+
+typedef struct {
+	char name[TNMSZ];		/* name of entry */
+	char mode[8]; 			/* mode */
+	char uid[8]; 			/* uid */
+	char gid[8];			/* gid */
+	char size[12];			/* size */
+	char mtime[12];			/* modification time */
+	char chksum[CHK_LEN];		/* checksum */
+	char typeflag;			/* type of file. */
+	char linkname[TNMSZ];		/* linked to name */
+	char magic[TMAGLEN];		/* magic cookie */
+	char version[TVERSLEN];		/* version */
+	char uname[32];			/* ascii owner name */
+	char gname[32];			/* ascii group name */
+	char devmajor[8];		/* major device number */
+	char devminor[8];		/* minor device number */
+	char prefix[TPFSZ];		/* linked to name */
+} HD_USTAR;
+
+
+
+/*
+ * Routines for manipulating headers, trailers:
+ * asc_ul()
+ * tar_trail()
+ * tar_chksm()
+ * ustar_id()
+ */
+
+static unsigned long tar_chksm (char *, int);
+char *gnu_hack_string;          /* GNU ././@LongLink hackery */
+
+char untrusted_namebuf[MAX_PATH_LENGTH];
+
+
+/*
+ * asc_ul()
+ *	convert hex/octal character string into a u_long. We do not have to
+ *	check for overflow! (the headers in all supported formats are not large
+ *	enough to create an overflow).
+ *	NOTE: strings passed to us are NOT TERMINATED.
+ * Return:
+ *	unsigned long value
+ */
+
+u_long
+asc_ul (char *str, int len, int base)
+{
+  char *stop;
+  u_long tval = 0;
+
+  stop = str + len;
+
+  /*
+   * skip over leading blanks and zeros
+   */
+  while ((str < stop) && ((*str == ' ') || (*str == '0')))
+    ++str;
+
+  /*
+   * for each valid digit, shift running value (tval) over to next digit
+   * and add next digit
+   */
+  if (base == HEX)
+    {
+      while (str < stop)
+	{
+	  if ((*str >= '0') && (*str <= '9'))
+	    tval = (tval << 4) + (*str++ - '0');
+	  else if ((*str >= 'A') && (*str <= 'F'))
+	    tval = (tval << 4) + 10 + (*str++ - 'A');
+	  else if ((*str >= 'a') && (*str <= 'f'))
+	    tval = (tval << 4) + 10 + (*str++ - 'a');
+	  else
+	    break;
+	}
+    }
+  else
+    {
+      while ((str < stop) && (*str >= '0') && (*str <= '7'))
+	tval = (tval << 3) + (*str++ - '0');
+    }
+  return (tval);
+}
+
+
+/*
+ * tar_trail()
+ *	Called to determine if a header block is a valid trailer. We are passed
+ *	the block, the in_sync flag (which tells us we are in resync mode;
+ *	looking for a valid header), and cnt (which starts at zero) which is
+ *	used to count the number of empty blocks we have seen so far.
+ * Return:
+ *	0 if a valid trailer, -1 if not a valid trailer, or 1 if the block
+ *	could never contain a header.
+ */
+
+int
+tar_trail (char *buf,
+	   int in_resync, int *cnt)
+{
+  register int i;
+
+  /*
+   * look for all zero, trailer is two consecutive blocks of zero
+   */
+  for (i = 0; i < BLKMULT; ++i)
+    {
+      if (buf[i] != '\0')
+	break;
+    }
+
+  /*
+   * if not all zero it is not a trailer, but MIGHT be a header.
+   */
+  if (i != BLKMULT)
+    return (-1);
+
+  /*
+   * When given a zero block, we must be careful!
+   * If we are not in resync mode, check for the trailer. Have to watch
+   * out that we do not mis-identify file data as the trailer, so we do
+   * NOT try to id a trailer during resync mode. During resync mode we
+   * might as well throw this block out since a valid header can NEVER be
+   * a block of all 0 (we must have a valid file name).
+   */
+  if (!in_resync && (++*cnt >= NULLCNT))
+    return (0);
+  return (1);
+}
+
+
+/*
+ * tar_chksm()
+ *	calculate the checksum for a tar block counting the checksum field as
+ *	all blanks (BLNKSUM is that value pre-calculated, the sum of 8 blanks).
+ *	NOTE: we use len to short circuit summing 0's on write since we ALWAYS
+ *	pad headers with 0.
+ * Return:
+ *	unsigned long checksum
+ */
+
+static unsigned long
+tar_chksm (char *blk, int len)
+{
+  char *stop;
+  char *pt;
+  unsigned int chksm = BLNKSUM;	/* initial value is checksum field sum */
+
+  /*
+   * add the part of the block before the checksum field
+   */
+  pt = blk;
+  stop = blk + CHK_OFFSET;
+  while (pt < stop)
+    chksm += (*pt++ & 0xff);
+  /*
+   * move past the checksum field and keep going, spec counts the
+   * checksum field as the sum of 8 blanks (which is pre-computed as
+   * BLNKSUM).
+   * ASSUMED: len is greater than CHK_OFFSET. (len is where our 0 padding
+   * starts, no point in summing zero's)
+   */
+  pt += CHK_LEN;
+  stop = blk + len;
+  while (pt < stop)
+    chksm += (*pt++ & 0xff);
+
+  return chksm;
+}
+
+
+/*
+ * ustar_id()
+ *	determine if a block given to us is a valid ustar header. We have to
+ *	be on the lookout for those pesky blocks of all zero's
+ * Return:
+ *	0 if a ustar header, -1 otherwise
+ */
+
+int
+ustar_id (char *blk, size_t size)
+{
+  HD_USTAR *hd;
+
+  if (size < BLKMULT)
+    return (-1);
+  hd = (HD_USTAR *) blk;
+
+  /*
+   * check for block of zero's first, a simple and fast test then check
+   * ustar magic cookie. We should use TMAGLEN, but some USTAR archive
+   * programs are fouled up and create archives missing the \0. Last we
+   * check the checksum. If ok we have to assume it is a valid header.
+   */
+  if (hd->name[0] == '\0')
+    return (-1);
+  if (strncmp (hd->magic, TMAGIC, TMAGLEN - 1) != 0)
+    return (-1);
+  if (asc_ul (hd->chksum, sizeof (hd->chksum), OCT) !=
+      tar_chksm (blk, BLKMULT))
+    return (-1);
+  return (0);
+}
+
+
+
+
+/*
+ * Routines for reading tar files
+ */
+
+
+
+/*
+struct file_header {
+	unsigned int namelen;
+	unsigned int mode;
+	unsigned long long filelen;
+	unsigned int atime;
+	unsigned int atime_nsec;
+	unsigned int mtime;
+	unsigned int mtime_nsec;
+};
+*/
+
+
+
+/*
+
+
+0000cc00  76 6d 2d 74 65 6d 70 6c  61 74 65 73 2f 61 72 63  |vm-templates/arc|
+0000cc10  68 6c 69 6e 75 78 2d 78  36 34 2d 73 70 65 63 2d  |hlinux-x64-spec-|
+0000cc20  32 30 31 33 2e 30 30 30  00 00 00 00 00 00 00 00  |2013.000........|
+0000cc30  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
+*
+0000cc60  00 00 00 00 30 30 30 30  36 36 34 00 30 30 30 31  |....0000664.0001|
+0000cc70  37 35 30 00 30 30 30 31  37 35 31 00 30 37 35 30  |750.0001751.0750|
+0000cc80  32 32 30 30 30 34 30 00  31 32 32 32 31 35 32 37  |2200040.12221527|
+0000cc90  31 34 34 00 30 31 37 33  30 33 00 20 30 00 00 00  |144.017303. 0...|
+0000cca0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
+*
+0000cd00  00 75 73 74 61 72 00 30  30 6f 6d 65 00 00 00 00  |.ustar.00ome....|
+0000cd10  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
+0000cd20  00 00 00 00 00 00 00 00  00 6f 6d 65 00 00 00 00  |.........ome....|
+0000cd30  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
+0000cd40  00 00 00 00 00 00 00 00  00 30 30 30 30 30 30 30  |.........0000000|
+0000cd50  00 30 30 30 30 30 30 30  00 00 00 00 00 00 00 00  |.0000000........|
+0000cd60  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
+*
+
+// Source: http://www.mkssoftware.com/docs/man4/pax.4.asp
+struct file_header {	// PAX header is similar as file_header and can be completely ignored
+	unsigned char[100] name;
+	unsigned char[8] mode;
+	unsigned char[8] uid; // unused
+	unsigned char[8] gid; // unused
+	unsigned char[12] size; // 0 if file is a link
+	unsigned char[12] mtime;
+	unsigned char[8] chksum;
+	unsigned char[1] typeflag;
+	unsigned char[100] linkname;
+	unsigned char[6] magic; //ustar
+	unsigned char[2] version; // 00
+	unsigned char[32] uname; // unused
+	unsigned char[32] gname; // unused
+	unsigned char[8] devmajor; // unused ?
+	unsigned char[8] devminor; // unused ?
+	unsigned char[155] prefix;  // only used for files > 100 characters. could be unused ?
+};
+
+enum {
+	TYPE_REGULAR,		//0
+	TYPE_ARCHIVE_LINK,	//1
+	TYPE_SYMLINK,		//2
+	TYPE_CHARACTER_DEVICE,	//3
+	TYPE_BLOCK_DEVICE,	//4
+	TYPE_DIRECTORY,		//5
+	TYPE_FIFO,		//6
+	// Other types:
+	TYPE_EXTENDED_USAGE,	//xxxxx
+	// A-Z are available for custom usage
+};
+
+// Extended attribute:
+// length keyword=value
+// atime, charset, comment, gname, linkpath, mtime, path, size, uname
+
+*/
+
+
+
+enum {
+	NEED_NOTHING,
+	NEED_SKIP,
+	NEED_READ,
+	NEED_SYNC_TRAIL
+};
+
+
+
+/*
+ * ustar_rd()
+ *	extract the values out of block already determined to be a ustar header.
+ *	store the values in the ARCHD parameter.
+ * Return:
+ *	0
+ */
+
+int
+ustar_rd (int fd, struct file_header * untrusted_hdr, char *buf, struct stat * sb)
+{
+
+  register HD_USTAR *hd;
+  register char *dest;
+  register int cnt = 0;
+  int ret;
+  /* DISABLED: unused
+  dev_t devmajor;
+  dev_t devminor;
+  */
+
+  /*
+   * we only get proper sized buffers
+   */
+  fprintf(stderr,"Checking if valid header\n");
+  if (ustar_id (buf, BLKMULT) < 0)
+    return (-1);
+
+  fprintf(stderr,"Valid header!\n");
+  /* DISABLED: Internal to PAX
+  arcn->org_name = arcn->name;
+  arcn->sb.st_nlink = 1;
+  arcn->pat = NULL;
+  arcn->nlen = 0;
+  */
+  untrusted_hdr->namelen = 0;
+
+  hd = (HD_USTAR *) buf;
+
+  /*
+   * see if the filename is split into two parts. if, so joint the parts.
+   * we copy the prefix first and add a / between the prefix and name.
+   */
+  dest = untrusted_namebuf;
+  if (*(hd->prefix) != '\0')
+    {
+      cnt = strlen(strncpy (dest, hd->prefix,
+		     MIN(sizeof (untrusted_namebuf) - 1,TPFSZ+1)));
+      dest += cnt;
+      *dest++ = '/';
+      cnt++;
+    }
+  if (gnu_hack_string)
+    {
+      untrusted_hdr->namelen = cnt + strlen(strncpy (dest, gnu_hack_string,
+				  MIN(TNMSZ+1, sizeof (untrusted_namebuf) - cnt)));
+      free(gnu_hack_string);
+      gnu_hack_string = NULL;
+    } else
+      untrusted_hdr->namelen = cnt + strlen(strncpy (dest, hd->name,
+				  MIN(TNMSZ+1, sizeof (untrusted_namebuf) - cnt)));
+
+  fprintf(stderr,"Retrieved name len: %d\n",untrusted_hdr->namelen);
+  fprintf(stderr,"Retrieved name: %s\n",untrusted_namebuf);
+
+  /*
+   * follow the spec to the letter. we should only have mode bits, strip
+   * off all other crud we may be passed.
+   */
+  sb->st_mode = (mode_t) (asc_ul (hd->mode, sizeof (hd->mode), OCT) &
+			       0xfff);
+  untrusted_hdr->mode = sb->st_mode;
+
+  #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64
+  sb->st_size = (off_t) asc_uqd (hd->size, sizeof (hd->size), OCT);
+  #else
+  sb->st_size = (off_t) asc_ul (hd->size, sizeof (hd->size), OCT);
+  #endif
+
+  untrusted_hdr->filelen = sb->st_size;
+  untrusted_hdr->atime = (time_t) asc_ul (hd->mtime, sizeof (hd->mtime), OCT);
+  untrusted_hdr->mtime = untrusted_hdr->atime;
+  untrusted_hdr->atime_nsec = untrusted_hdr->mtime_nsec = 0;
+
+  sb->st_mtime = (time_t) asc_ul (hd->mtime, sizeof (hd->mtime), OCT);
+  sb->st_ctime = sb->st_atime = sb->st_mtime;
+
+
+  /*
+   * If we can find the ascii names for gname and uname in the password
+   * and group files we will use the uid's and gid they bind. Otherwise
+   * we use the uid and gid values stored in the header. (This is what
+   * the posix spec wants).
+   */
+  /* DISABLED: unused
+  hd->gname[sizeof (hd->gname) - 1] = '\0';
+  if (gid_name (hd->gname, &(arcn->sb.st_gid)) < 0)
+    arcn->sb.st_gid = (gid_t) asc_ul (hd->gid, sizeof (hd->gid), OCT);
+  hd->uname[sizeof (hd->uname) - 1] = '\0';
+  if (uid_name (hd->uname, &(arcn->sb.st_uid)) < 0)
+    arcn->sb.st_uid = (uid_t) asc_ul (hd->uid, sizeof (hd->uid), OCT);
+  */
+
+  /*
+   * set the defaults, these may be changed depending on the file type
+   */
+  /* Disabled: pax specific
+  arcn->ln_name[0] = '\0';
+  arcn->ln_nlen = 0;
+  arcn->pad = 0;
+  arcn->skip = 0;
+  arcn->sb.st_rdev = (dev_t) 0;
+  */
+  
+
+  /*
+   * set the mode and PAX type according to the typeflag in the header
+   */
+  switch (hd->typeflag)
+    {
+    case FIFOTYPE:
+	fprintf(stderr,"File is FIFOTYPE\n");
+      /* DISABLED: unused
+      arcn->type = PAX_FIF;
+      arcn->sb.st_mode |= S_IFIFO;
+      */
+      break;
+    case DIRTYPE:
+	fprintf(stderr,"File is DIRTYPE\n");
+      /* DISABLED: unused
+      arcn->type = PAX_DIR;
+      arcn->sb.st_mode |= S_IFDIR;
+      arcn->sb.st_nlink = 2;
+      */
+      /*
+       * Some programs that create ustar archives append a '/'
+       * to the pathname for directories. This clearly violates
+       * ustar specs, but we will silently strip it off anyway.
+       */
+/*
+      if (arcn->name[arcn->nlen - 1] == '/')
+	arcn->name[--arcn->nlen] = '\0';
+*/
+      break;
+    case BLKTYPE:
+	fprintf(stderr,"File is BLKTYPE\n");
+	break;
+    case CHRTYPE:
+	fprintf(stderr,"File is CHRTYPE\n");
+      /*
+       * this type requires the rdev field to be set.
+       */
+      if (hd->typeflag == BLKTYPE)
+	{
+/*
+	  arcn->type = PAX_BLK;
+	  arcn->sb.st_mode |= S_IFBLK;
+*/
+	}
+      else
+	{
+/*
+	  arcn->type = PAX_CHR;
+	  arcn->sb.st_mode |= S_IFCHR;
+*/
+	}
+      /* DISABLED: unused
+      devmajor = (dev_t) asc_ul (hd->devmajor, sizeof (hd->devmajor), OCT);
+      devminor = (dev_t) asc_ul (hd->devminor, sizeof (hd->devminor), OCT);
+      */
+//      arcn->sb.st_rdev = TODEV (devmajor, devminor);
+      break;
+    case SYMTYPE:
+	fprintf(stderr,"File is SYMTYPE\n");
+	break;
+    case LNKTYPE:
+	fprintf(stderr,"File is LNKTYPE\n");
+      if (hd->typeflag == SYMTYPE)
+	{
+//	  arcn->type = PAX_SLK;
+//	  arcn->sb.st_mode |= S_IFLNK;
+	}
+      else
+	{
+//	  arcn->type = PAX_HLK;
+	  /*
+	   * so printing looks better
+	   */
+//	  arcn->sb.st_mode |= S_IFREG;
+//	  arcn->sb.st_nlink = 2;
+	}
+      /*
+       * copy the link name
+       */
+//      arcn->ln_nlen = strlcpy (arcn->ln_name, hd->linkname,
+//			       MIN(TNMSZ+1,sizeof (arcn->ln_name)));
+      break;
+    case LONGLINKTYPE:
+	fprintf(stderr,"File is LONGLINKTYPE\n");
+	break;
+    case LONGNAMETYPE:
+	fprintf(stderr,"File is LONGNAMETYPE\n");
+      /*
+       * GNU long link/file; we tag these here and let the
+       * pax internals deal with it -- too ugly otherwise.
+       */
+//      arcn->type =
+//	hd->typeflag == LONGLINKTYPE ? PAX_GLL : PAX_GLF;
+//      arcn->pad = TAR_PAD(arcn->sb.st_size);
+//      arcn->skip = arcn->sb.st_size;
+//      arcn->ln_name[0] = '\0';
+//      arcn->ln_nlen = 0;
+      break;
+    case CONTTYPE:
+	fprintf(stderr,"File is CONTTYPE\n");
+	break;
+    case AREGTYPE:
+	fprintf(stderr,"File is AREGTYPE\n");
+	break;
+    case REGTYPE:
+	fprintf(stderr,"File is REGTYPE of size %d\n",sb->st_size);
+	write_headers(untrusted_hdr, untrusted_namebuf);
+	ret = copy_file(1, fd, untrusted_hdr->filelen, &crc32_sum);
+	if (ret != COPY_FILE_OK) {
+		if (ret != COPY_FILE_WRITE_ERROR)
+			gui_fatal("Copying file %s: %s", untrusted_namebuf,
+				  copy_file_status_to_str(ret));
+		else {
+			set_block(0);
+			wait_for_result();
+			exit(1);
+		}
+	}
+	// Extract extra padding
+	fprintf(stderr,"Need to remove pad:%d %d\n",sb->st_size,BLKMULT-(sb->st_size%BLKMULT));
+	ret = read(fd, buf, BLKMULT-(sb->st_size%BLKMULT));
+	fprintf(stderr,"Removed %d bytes of padding\n",ret);
+
+	// Resync trailing headers
+	return NEED_SYNC_TRAIL;
+
+	break;
+    case EXTHEADERTYPE:
+	fprintf(stderr,"Extended HEADER encountered\n");
+
+	fprintf(stderr,"Need to skip %d bytes. Skipping a full block\n",sb->st_size);
+	sb->st_size = BLKMULT;
+	while (sb->st_size > 0) {
+		sb->st_size -= read(fd, buf, MAX(sb->st_size,BLKMULT));
+		fprintf(stderr,"now at %d\n",sb->st_size);
+	}
+	
+
+	break;
+    default:
+	fprintf(stderr,"Default type detected:%c\n",hd->typeflag);
+	return NEED_SKIP;
+      /*
+       * these types have file data that follows. Set the skip and
+       * pad fields.
+       */
+//      arcn->type = PAX_REG;
+//      arcn->pad = TAR_PAD (arcn->sb.st_size);
+//      arcn->skip = arcn->sb.st_size;
+//      arcn->sb.st_mode |= S_IFREG;
+      break;
+    }
+  return NEED_READ;
+}
+
+
+
+int tar_file_processor(int fd)
+{
+	int ret;
+	int i;
+	int current;
+
+	struct file_header hdr;
+	struct stat sb;			/* stat buffer see stat(2) */
+
+	char buf[BLKMULT+1];
+	size_t size;
+
+	i=0;
+	current = NEED_READ;
+	long sync_count = 0;
+	while (size = read(fd, &buf, BLKMULT)) {
+		fprintf(stderr,"Read %d bytes\n",size);
+
+		ret = 0;
+		if (current==NEED_SYNC_TRAIL) {
+			ret = tar_trail (buf, 1, &sync_count);
+			fprintf(stderr,"Synchronizing trail: %d %d\n",ret,sync_count);
+			if (ret != 1) {
+				current = NEED_READ;
+			}
+		}
+		if (current==NEED_READ) {
+			current = ustar_rd(fd, &hdr, &buf, &sb);
+			fprintf(stderr,"Return %d\n",ret);
+		}
+		i++;
+		//if (i >= 10)
+		//	exit(0);
+	}
+
+}
+
+int main(int argc, char **argv)
+{
+	int i;
+	char *entry;
+	char *cwd;
+	char *sep;
+	int fd;
+
+	//signal(SIGPIPE, SIG_IGN);
+	// this will allow checking for possible feedback packet in the middle of transfer
+	//set_nonblock(0);
+	crc32_sum = 0;
+	cwd = getcwd(NULL, 0);
+	for (i = 1; i < argc; i++) {
+
+		if (strcmp(argv[i], "--ignore-symlinks")==0) {
+			ignore_symlinks = 1;
+			continue;
+		} else {
+			// Parse tar file
+			entry = argv[i];
+			fprintf(stderr,"Parsing file %s\n",entry);
+
+			fd = open(entry, O_RDONLY);
+			if (fd < 0)
+				fprintf(stderr,"Error opening file %s\n",entry);
+
+			tar_file_processor(fd);
+		}
+	}
+
+	if (i <= 1) {
+		// No argument specified. Use STDIN
+		fprintf(stderr,"Using STDIN");
+		tar_file_processor(fileno(stdin));
+	}
+
+	return 0;
+}
+
+
+
+
+
+