X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=archival%2Ftar.c;h=8074c2d1a909ed1453a2c67151b32669b01a9e37;hb=8f3eb1dbab647e0ceca33f573da68ad3f2aa7086;hp=e6c134e3be34bad946b98248b4d01808fc95131a;hpb=2983330512e0f1a09ef881034a5e1c02d3fe2c7b;p=oweals%2Fbusybox.git

diff --git a/archival/tar.c b/archival/tar.c
index e6c134e3b..8074c2d1a 100644
--- a/archival/tar.c
+++ b/archival/tar.c
@@ -9,8 +9,7 @@
  * ground up.  It still has remnents of the old code lying about, but it is
  * very different now (i.e., cleaner, less global variables, etc.)
  *
- * Copyright (C) 1999,2000 by Lineo, inc. and Erik Andersen
- * Copyright (C) 1999-2002 by Erik Andersen <andersee@debian.org>
+ * Copyright (C) 1999-2003 by Erik Andersen <andersen@codepoet.org>
  *
  * Based in part in the tar implementation in sash
  *  Copyright (c) 1999 by David I. Bell
@@ -138,24 +137,20 @@ enum TarFileType {
 typedef enum TarFileType TarFileType;
 
 /* Might be faster (and bigger) if the dev/ino were stored in numeric order;) */
-static inline void addHardLinkInfo(HardLinkInfo ** hlInfoHeadPtr, dev_t dev,
-								   ino_t ino, short linkCount,
-								   const char *name)
+static inline void addHardLinkInfo(HardLinkInfo ** hlInfoHeadPtr,
+					struct stat *statbuf,
+					const char *name)
 {
 	/* Note: hlInfoHeadPtr can never be NULL! */
 	HardLinkInfo *hlInfo;
 
-	hlInfo =
-		(HardLinkInfo *) xmalloc(sizeof(HardLinkInfo) + strlen(name) + 1);
-	if (hlInfo) {
-		hlInfo->next = *hlInfoHeadPtr;
-		*hlInfoHeadPtr = hlInfo;
-		hlInfo->dev = dev;
-		hlInfo->ino = ino;
-		hlInfo->linkCount = linkCount;
-		strcpy(hlInfo->name, name);
-	}
-	return;
+	hlInfo = (HardLinkInfo *) xmalloc(sizeof(HardLinkInfo) + strlen(name));
+	hlInfo->next = *hlInfoHeadPtr;
+	*hlInfoHeadPtr = hlInfo;
+	hlInfo->dev = statbuf->st_dev;
+	hlInfo->ino = statbuf->st_ino;
+	hlInfo->linkCount = statbuf->st_nlink;
+	strcpy(hlInfo->name, name);
 }
 
 static void freeHardLinkInfo(HardLinkInfo ** hlInfoHeadPtr)
@@ -176,11 +171,10 @@ static void freeHardLinkInfo(HardLinkInfo ** hlInfoHeadPtr)
 }
 
 /* Might be faster (and bigger) if the dev/ino were stored in numeric order;) */
-static inline HardLinkInfo *findHardLinkInfo(HardLinkInfo * hlInfo, dev_t dev,
-											 ino_t ino)
+static inline HardLinkInfo *findHardLinkInfo(HardLinkInfo * hlInfo, struct stat *statbuf)
 {
 	while (hlInfo) {
-		if ((ino == hlInfo->ino) && (dev == hlInfo->dev))
+		if ((statbuf->st_ino == hlInfo->ino) && (statbuf->st_dev == hlInfo->dev))
 			break;
 		hlInfo = hlInfo->next;
 	}
@@ -283,7 +277,7 @@ static inline int writeTarHeader(struct TarBallInfo *tbInfo,
 		header.typeflag = REGTYPE;
 		putOctal(header.size, sizeof(header.size), statbuf->st_size);
 	} else {
-		error_msg("%s: Unknown file type", real_name);
+		bb_error_msg("%s: Unknown file type", real_name);
 		return (FALSE);
 	}
 
@@ -300,9 +294,9 @@ static inline int writeTarHeader(struct TarBallInfo *tbInfo,
 
 	/* Now write the header out to disk */
 	if ((size =
-		 full_write(tbInfo->tarFd, (char *) &header,
+		 bb_full_write(tbInfo->tarFd, (char *) &header,
 					sizeof(struct TarHeader))) < 0) {
-		error_msg(io_error, real_name, strerror(errno));
+		bb_error_msg(bb_msg_io_error, real_name);
 		return (FALSE);
 	}
 	/* Pad the header up to the tar block size */
@@ -314,21 +308,18 @@ static inline int writeTarHeader(struct TarBallInfo *tbInfo,
 	if (tbInfo->verboseFlag) {
 		FILE *vbFd = stdout;
 
-		if (tbInfo->verboseFlag == 2)	/* If the archive goes to stdout, verbose to stderr */
+		if (tbInfo->tarFd == fileno(stdout))	/* If the archive goes to stdout, verbose to stderr */
 			vbFd = stderr;
+
 		fprintf(vbFd, "%s\n", header.name);
 	}
 
 	return (TRUE);
 }
 
-# if defined CONFIG_FEATURE_TAR_EXCLUDE
+# ifdef CONFIG_FEATURE_TAR_FROM
 static inline int exclude_file(const llist_t *excluded_files, const char *file)
 {
-	if (excluded_files == NULL) {
-		return 0;
-	}
-
 	while (excluded_files) {
 		if (excluded_files->data[0] == '/') {
 			if (fnmatch(excluded_files->data, file,
@@ -349,7 +340,7 @@ static inline int exclude_file(const llist_t *excluded_files, const char *file)
 
 	return 0;
 }
-#endif
+# endif
 
 static int writeFileToTarball(const char *fileName, struct stat *statbuf,
 							  void *userData)
@@ -366,16 +357,14 @@ static int writeFileToTarball(const char *fileName, struct stat *statbuf,
 	 */
 	tbInfo->hlInfo = NULL;
 	if (statbuf->st_nlink > 1) {
-		tbInfo->hlInfo = findHardLinkInfo(tbInfo->hlInfoHead, statbuf->st_dev,
-										  statbuf->st_ino);
+		tbInfo->hlInfo = findHardLinkInfo(tbInfo->hlInfoHead, statbuf);
 		if (tbInfo->hlInfo == NULL)
-			addHardLinkInfo(&tbInfo->hlInfoHead, statbuf->st_dev,
-							statbuf->st_ino, statbuf->st_nlink, fileName);
+			addHardLinkInfo(&tbInfo->hlInfoHead, statbuf, fileName);
 	}
 
 	/* It is against the rules to archive a socket */
 	if (S_ISSOCK(statbuf->st_mode)) {
-		error_msg("%s: socket ignored", fileName);
+		bb_error_msg("%s: socket ignored", fileName);
 		return (TRUE);
 	}
 
@@ -384,7 +373,7 @@ static int writeFileToTarball(const char *fileName, struct stat *statbuf,
 	 * the new tarball */
 	if (tbInfo->statBuf.st_dev == statbuf->st_dev &&
 		tbInfo->statBuf.st_ino == statbuf->st_ino) {
-		error_msg("%s: file is the archive; skipping", fileName);
+		bb_error_msg("%s: file is the archive; skipping", fileName);
 		return (TRUE);
 	}
 
@@ -393,25 +382,25 @@ static int writeFileToTarball(const char *fileName, struct stat *statbuf,
 		static int alreadyWarned = FALSE;
 
 		if (alreadyWarned == FALSE) {
-			error_msg("Removing leading '/' from member names");
+			bb_error_msg("Removing leading '/' from member names");
 			alreadyWarned = TRUE;
 		}
 		header_name++;
 	}
 
 	if (strlen(fileName) >= NAME_SIZE) {
-		error_msg(name_longer_than_foo, NAME_SIZE);
+		bb_error_msg(bb_msg_name_longer_than_foo, NAME_SIZE);
 		return (TRUE);
 	}
 
 	if (header_name[0] == '\0')
 		return TRUE;
 
-# if defined CONFIG_FEATURE_TAR_EXCLUDE
+# ifdef CONFIG_FEATURE_TAR_FROM
 	if (exclude_file(tbInfo->excludeList, header_name)) {
 		return SKIP;
 	}
-# endif							/* CONFIG_FEATURE_TAR_EXCLUDE */
+# endif							/* CONFIG_FEATURE_TAR_FROM */
 
 	if (writeTarHeader(tbInfo, header_name, fileName, statbuf) == FALSE) {
 		return (FALSE);
@@ -421,28 +410,17 @@ static int writeFileToTarball(const char *fileName, struct stat *statbuf,
 	if ((tbInfo->hlInfo == NULL)
 		&& (S_ISREG(statbuf->st_mode))) {
 		int inputFileFd;
-		char buffer[BUFSIZ];
-		ssize_t size = 0, readSize = 0;
+		ssize_t readSize = 0;
 
 		/* open the file we want to archive, and make sure all is well */
 		if ((inputFileFd = open(fileName, O_RDONLY)) < 0) {
-			error_msg("%s: Cannot open: %s", fileName, strerror(errno));
+			bb_perror_msg("%s: Cannot open", fileName);
 			return (FALSE);
 		}
 
 		/* write the file to the archive */
-		while ((size = full_read(inputFileFd, buffer, sizeof(buffer))) > 0) {
-			if (full_write(tbInfo->tarFd, buffer, size) != size) {
-				/* Output file seems to have a problem */
-				error_msg(io_error, fileName, strerror(errno));
-				return (FALSE);
-			}
-			readSize += size;
-		}
-		if (size == -1) {
-			error_msg(io_error, fileName, strerror(errno));
-			return (FALSE);
-		}
+		readSize = bb_copyfd_eof(inputFileFd, tbInfo->tarFd);
+
 		/* Pad the file up to the tar block size */
 		for (; (readSize % TAR_BLOCK_SIZE) != 0; readSize++) {
 			write(tbInfo->tarFd, "\0", 1);
@@ -453,13 +431,14 @@ static int writeFileToTarball(const char *fileName, struct stat *statbuf,
 	return (TRUE);
 }
 
-static inline int writeTarFile(const char *tarName, const int verboseFlag,
+static inline int writeTarFile(const int tar_fd, const int verboseFlag,
 							   const llist_t *include, const llist_t *exclude, const int gzip)
 {
 #ifdef CONFIG_FEATURE_TAR_GZIP
 	int gzipDataPipe[2] = { -1, -1 };
 	int gzipStatusPipe[2] = { -1, -1 };
 	pid_t gzipPid = 0;
+	volatile int vfork_exec_errno = 0;
 #endif
 
 	int errorFlag = FALSE;
@@ -468,40 +447,30 @@ static inline int writeTarFile(const char *tarName, const int verboseFlag,
 
 	tbInfo.hlInfoHead = NULL;
 
-	/* Make sure there is at least one file to tar up.  */
-	if (include == NULL) {
-		error_msg_and_die("Cowardly refusing to create an empty archive");
-	}
-
-	/* Open the tar file for writing.  */
-	if (tarName == NULL) {
-		tbInfo.tarFd = fileno(stdout);
-		tbInfo.verboseFlag = verboseFlag ? 2 : 0;
-	} else {
-		tbInfo.tarFd = open(tarName, O_WRONLY | O_CREAT | O_TRUNC, 0644);
-		tbInfo.verboseFlag = verboseFlag ? 1 : 0;
-	}
-
-	if (tbInfo.tarFd < 0) {
-		perror_msg("Error opening '%s'", tarName);
-		freeHardLinkInfo(&tbInfo.hlInfoHead);
-		return (FALSE);
-	}
+	fchmod(tar_fd, 0644);
+	tbInfo.tarFd = tar_fd;
+	tbInfo.verboseFlag = verboseFlag;
 
 	/* Store the stat info for the tarball's file, so
 	 * can avoid including the tarball into itself....  */
 	if (fstat(tbInfo.tarFd, &tbInfo.statBuf) < 0)
-		error_msg_and_die(io_error, tarName, strerror(errno));
+		bb_perror_msg_and_die("Couldnt stat tar file");
 
 #ifdef CONFIG_FEATURE_TAR_GZIP
 	if (gzip) {
-		if (socketpair(AF_UNIX, SOCK_STREAM, 0, gzipDataPipe) < 0
-			|| pipe(gzipStatusPipe) < 0)
-			perror_msg_and_die("Failed to create gzip pipe");
+		if (pipe(gzipDataPipe) < 0 || pipe(gzipStatusPipe) < 0) {
+			bb_perror_msg_and_die("Failed to create gzip pipe");
+		}
 
 		signal(SIGPIPE, SIG_IGN);	/* we only want EPIPE on errors */
 
-		gzipPid = fork();
+# if __GNUC__
+			/* Avoid vfork clobbering */
+			(void) &include;
+			(void) &errorFlag;
+# endif
+ 
+		gzipPid = vfork();
 
 		if (gzipPid == 0) {
 			dup2(gzipDataPipe[0], 0);
@@ -514,10 +483,9 @@ static inline int writeTarFile(const char *tarName, const int verboseFlag,
 			fcntl(gzipStatusPipe[1], F_SETFD, FD_CLOEXEC);	/* close on exec shows sucess */
 
 			execl("/bin/gzip", "gzip", "-f", 0);
+			vfork_exec_errno = errno;
 
-			write(gzipStatusPipe[1], "", 1);
 			close(gzipStatusPipe[1]);
-
 			exit(-1);
 		} else if (gzipPid > 0) {
 			close(gzipDataPipe[0]);
@@ -526,11 +494,12 @@ static inline int writeTarFile(const char *tarName, const int verboseFlag,
 			while (1) {
 				char buf;
 
-				int n = read(gzipStatusPipe[0], &buf, 1);
+				int n = bb_full_read(gzipStatusPipe[0], &buf, 1);
 
-				if (n == 1)
-					error_msg_and_die("Could not exec gzip process");	/* socket was not closed => error */
-				else if ((n < 0) && (errno == EAGAIN || errno == EINTR))
+				if (n == 0 && vfork_exec_errno != 0) {
+					errno = vfork_exec_errno;
+					bb_perror_msg_and_die("Could not exec gzip process");
+				} else if ((n < 0) && (errno == EAGAIN || errno == EINTR))
 					continue;	/* try it again */
 				break;
 			}
@@ -538,7 +507,7 @@ static inline int writeTarFile(const char *tarName, const int verboseFlag,
 
 			tbInfo.tarFd = gzipDataPipe[1];
 		} else {
-			perror_msg_and_die("Failed to fork gzip process");
+			bb_perror_msg_and_die("Failed to vfork gzip process");
 		}
 	}
 #endif
@@ -567,7 +536,7 @@ static inline int writeTarFile(const char *tarName, const int verboseFlag,
 	/* Hang up the tools, close up shop, head home */
 	close(tbInfo.tarFd);
 	if (errorFlag)
-		error_msg("Error exit delayed from previous errors");
+		bb_error_msg("Error exit delayed from previous errors");
 
 	freeHardLinkInfo(&tbInfo.hlInfoHead);
 
@@ -582,117 +551,240 @@ static inline int writeTarFile(const char *tarName, const int verboseFlag,
 }
 #endif							/* tar_create */
 
-#ifdef CONFIG_FEATURE_TAR_EXCLUDE
-static const llist_t *append_file_list_to_list(const char *filename, const llist_t *list)
+#ifdef CONFIG_FEATURE_TAR_FROM
+static llist_t *append_file_list_to_list(llist_t *list)
 {
-	FILE *src_stream = xfopen(filename, "r");
-	while(1) {
-		char *line = get_line_from_file(src_stream);
-		if (line == NULL) {
-			break;
-		}
-		chomp(line);
-		list = add_to_list(list, line);
-		free(line);
+	FILE *src_stream;
+	llist_t *cur = list;
+	llist_t *tmp;
+	char *line;
+	llist_t *newlist = NULL;
+
+	while(cur) {
+		src_stream = bb_xfopen(cur->data, "r");
+		tmp = cur;
+		cur = cur->link;
+		free(tmp);
+	while((line = bb_get_chomped_line_from_file(src_stream)) != NULL) {
+			newlist = llist_add_to(newlist, line);
 	}
 	fclose(src_stream);
+	}
+	return newlist;
+}
+#endif
+
+#ifdef CONFIG_FEATURE_TAR_COMPRESS
+static char get_header_tar_Z(archive_handle_t *archive_handle)
+{
+	/* Cant lseek over pipe's */
+	archive_handle->seek = seek_by_char;
 
-	return (list);
+	/* do the decompression, and cleanup */
+	if ((bb_xread_char(archive_handle->src_fd) != 0x1f) || (bb_xread_char(archive_handle->src_fd) != 0x9d)) {
+		bb_error_msg_and_die("Invalid magic");
+	}
+
+	archive_handle->src_fd = open_transformer(archive_handle->src_fd, uncompress);
+	archive_handle->offset = 0;
+	while (get_header_tar(archive_handle) == EXIT_SUCCESS);
+
+	/* Can only do one file at a time */
+	return(EXIT_FAILURE);
 }
 #endif
 
+#define CTX_TEST	(1 << 0)
+#define CTX_EXTRACT	(1 << 1)
+#define TAR_OPT_BASEDIR  (1 << 2)
+#define TAR_OPT_TARNAME  (1 << 3)
+#define TAR_OPT_2STDOUT  (1 << 4)
+#define TAR_OPT_P        (1 << 5)
+#define TAR_OPT_VERBOSE  (1 << 6)
+#define TAR_OPT_KEEP_OLD	(1 << 7)
+
+#ifdef CONFIG_FEATURE_TAR_CREATE
+# define CTX_CREATE	(1 << 8)
+# define TAR_OPT_STR_CREATE	"c"
+# define TAR_OPT_FLAG_CREATE	1
+#else
+//# define CTX_CREATE	0
+# define TAR_OPT_STR_CREATE	""
+# define TAR_OPT_FLAG_CREATE	0
+#endif
+
+#ifdef CONFIG_FEATURE_TAR_BZIP2
+# define TAR_OPT_BZIP2	(1 << (8 + TAR_OPT_FLAG_CREATE)) 
+# define TAR_OPT_STR_BZIP2	"j"
+# define TAR_OPT_FLAG_BZIP2	1
+#else
+# define TAR_OPT_STR_BZIP2	""
+# define TAR_OPT_FLAG_BZIP2	0
+#endif
+
+#ifdef CONFIG_FEATURE_TAR_FROM
+# define TAR_OPT_FROM_FILE	(1 << (8 + TAR_OPT_FLAG_CREATE + TAR_OPT_FLAG_BZIP2))
+# define TAR_OPT_EXCLUDE_FROM	(1 << (8 + TAR_OPT_FLAG_CREATE + TAR_OPT_FLAG_BZIP2 + 1))
+# define TAR_OPT_STR_FROM	"T:X:"
+# define TAR_OPT_FLAG_FROM	2
+#else
+# define TAR_OPT_STR_FROM	""
+# define TAR_OPT_FLAG_FROM	0
+#endif
+
+#ifdef CONFIG_FEATURE_TAR_GZIP
+# define TAR_OPT_GZIP	(1 << (8 + TAR_OPT_FLAG_CREATE + TAR_OPT_FLAG_BZIP2 + TAR_OPT_FLAG_FROM))
+# define TAR_OPT_STR_GZIP	"z"
+# define TAR_OPT_FLAG_GZIP	1
+#else
+# define TAR_OPT_STR_GZIP	""
+# define TAR_OPT_FLAG_GZIP	0
+#endif
+
+#ifdef CONFIG_FEATURE_TAR_COMPRESS
+# define TAR_OPT_UNCOMPRESS	(1 << (8 + TAR_OPT_FLAG_CREATE + TAR_OPT_FLAG_BZIP2 + TAR_OPT_FLAG_FROM + TAR_OPT_FLAG_GZIP))
+# define TAR_OPT_STR_COMPRESS	"Z"
+#else 
+# define TAR_OPT_STR_COMPRESS	""
+#endif
+
+static const char tar_options[]="txC:f:Opvk" \
+	TAR_OPT_STR_CREATE \
+	TAR_OPT_STR_BZIP2 \
+	TAR_OPT_STR_FROM \
+	TAR_OPT_STR_GZIP \
+	TAR_OPT_STR_COMPRESS;
+
+#ifdef CONFIG_FEATURE_TAR_LONG_OPTIONS
+static const struct option tar_long_options[] = {
+	{ "list",			0,	NULL,	't' },
+	{ "extract",		0,	NULL,	'x' },
+	{ "directory",		1,	NULL,	'C' },
+	{ "file",			1,	NULL,	'f'	},
+	{ "to-stdout",		0,	NULL,	'O' },
+	{ "same-permissions",	0,	NULL,	'p' },
+	{ "verbose",		0,	NULL,	'v' },
+	{ "keep-old",		0,	NULL,	'k' },
+# ifdef CONFIG_FEATURE_TAR_CREATE
+	{ "create",			0,	NULL,	'c' },
+# endif
+# ifdef CONFIG_FEATURE_TAR_BZIP2
+	{ "bzip2",			0,	NULL,	'j' },
+# endif
+# ifdef CONFIG_FEATURE_TAR_FROM
+	{ "from-file",		1,	NULL,	'T' },
+	{ "exclude-from",	1,	NULL,	'X' },
+# endif
+# ifdef CONFIG_FEATURE_TAR_GZIP
+	{ "gzip",			0,	NULL,	'z' },
+# endif
+# ifdef CONFIG_FEATURE_TAR_COMPRESS
+	{ "compress",		0,	NULL,	'Z' },
+# endif
+	{ 0,                 0, 0, 0 }
+};
+#endif
+
 int tar_main(int argc, char **argv)
 {
-#ifdef CONFIG_FEATURE_TAR_GZIP
 	char (*get_header_ptr)(archive_handle_t *) = get_header_tar;
-#endif
 	archive_handle_t *tar_handle;
-	int opt;
 	char *base_dir = NULL;
-
-#ifdef CONFIG_FEATURE_TAR_CREATE
-	char *src_filename = NULL;
-	unsigned char tar_create = FALSE;
-#endif
+	const char *tar_filename = "-";
+	unsigned long opt;
+	unsigned long ctx_flag = 0;
 
 	if (argc < 2) {
-		show_usage();
+		bb_show_usage();
+	}
+
+	/* Prepend '-' to the first argument if required */
+	if (argv[1][0] != '-') {
+		char *tmp;
+
+		bb_xasprintf(&tmp, "-%s", argv[1]);
+		argv[1] = tmp;
 	}
 
 	/* Initialise default values */
 	tar_handle = init_handle();
-	tar_handle->src_fd = fileno(stdin);
-	tar_handle->flags = ARCHIVE_CREATE_LEADING_DIRS;
+	tar_handle->flags = ARCHIVE_CREATE_LEADING_DIRS | ARCHIVE_PRESERVE_DATE | ARCHIVE_EXTRACT_UNCONDITIONAL;
 
-	while ((opt = getopt(argc, argv, "ctxT:X:C:f:Opvz")) != -1) {
-		switch (opt) {
-			/* One and only one of these is required */
-#ifdef CONFIG_FEATURE_TAR_CREATE
-		case 'c':
-			tar_create = TRUE;
-			break;
+	bb_opt_complementaly = "c~tx:t~cx:x~ct:X*:T*";
+#ifdef CONFIG_FEATURE_TAR_LONG_OPTIONS
+	bb_applet_long_options = tar_long_options;
 #endif
-		case 't':
-			if ((tar_handle->action_header == header_list) || 
-				(tar_handle->action_header == header_verbose_list)) {
-				tar_handle->action_header = header_verbose_list;
-			} else {
-				tar_handle->action_header = header_list;
-			}
-			break;
-		case 'x':
-			tar_handle->action_data = data_extract_all;
-			break;
 
-			/* These are optional */
-			/* Exclude or Include files listed in <filename> */
-#ifdef CONFIG_FEATURE_TAR_EXCLUDE
-		case 'X':
-			tar_handle->reject =
-				append_file_list_to_list(optarg, tar_handle->reject);
-			break;
+	opt = bb_getopt_ulflags(argc, argv, tar_options,
+				&base_dir,      /* Change to dir <optarg> */
+				&tar_filename /* archive filename */
+#ifdef CONFIG_FEATURE_TAR_FROM
+				, NULL,
+				&(tar_handle->reject)
 #endif
-		case 'T':
-			/* by default a list is an include list */
-			break;
-		case 'C':		/* Change to dir <optarg> */
-			base_dir = optarg;
-			break;
-		case 'f':		/* archive filename */
+				);
+
+	/* Check one and only one context option was given */
+	if(opt & 0x80000000UL) {
+		bb_show_usage();
+	}
 #ifdef CONFIG_FEATURE_TAR_CREATE
-			src_filename = optarg;
+	ctx_flag = opt & (CTX_CREATE | CTX_TEST | CTX_EXTRACT);
+#else
+	ctx_flag = opt & (CTX_TEST | CTX_EXTRACT);
 #endif
-			tar_handle->src_fd = xopen(optarg, O_RDONLY);
-			break;
-		case 'O':		/* To stdout */
-			tar_handle->action_data = data_extract_to_stdout;
-			break;
-		case 'p':
-			tar_handle->flags |= ARCHIVE_PRESERVE_DATE;
-			break;
-		case 'v':
-			if ((tar_handle->action_header == header_list) || 
-				(tar_handle->action_header == header_verbose_list)) {
-				tar_handle->action_header = header_verbose_list;
-			} else {
-				tar_handle->action_header = header_list;
-			}
-			break;
+	if (ctx_flag == 0) {
+		bb_show_usage();
+	}
+	if(ctx_flag & CTX_TEST) {
+		if ((tar_handle->action_header == header_list) || 
+			(tar_handle->action_header == header_verbose_list)) {
+			tar_handle->action_header = header_verbose_list;
+		} else {
+			tar_handle->action_header = header_list;
+		}
+	}
+	if(ctx_flag & CTX_EXTRACT) {
+		if (tar_handle->action_data != data_extract_to_stdout)
+			tar_handle->action_data = data_extract_all;
+		}
+	if(opt & TAR_OPT_2STDOUT) {
+		/* To stdout */
+		tar_handle->action_data = data_extract_to_stdout;
+	}
+	if(opt & TAR_OPT_VERBOSE) {
+		if ((tar_handle->action_header == header_list) || 
+			(tar_handle->action_header == header_verbose_list)) 
+		{
+		tar_handle->action_header = header_verbose_list;
+		} else {
+			tar_handle->action_header = header_list;
+		}
+	}
+	if (opt & TAR_OPT_KEEP_OLD) {
+		tar_handle->flags &= ~ARCHIVE_EXTRACT_UNCONDITIONAL;
+	}
+
 #ifdef CONFIG_FEATURE_TAR_GZIP
-		case 'z':
-			get_header_ptr = get_header_tar_gz;
-			break;
+	if(opt & TAR_OPT_GZIP) {
+		get_header_ptr = get_header_tar_gz;
+	}
 #endif
 #ifdef CONFIG_FEATURE_TAR_BZIP2
-			/* Not enabled yet */
-		case 'j':
-			archive_handle->archive_action = bunzip2;
-			break;
+	if(opt & TAR_OPT_BZIP2) {
+		get_header_ptr = get_header_tar_bz2;
+	}
 #endif
-		default:
-			show_usage();
-		}
+#ifdef CONFIG_FEATURE_TAR_COMPRESS
+	if(opt & TAR_OPT_UNCOMPRESS) {
+		get_header_ptr = get_header_tar_Z;
 	}
+#endif
+#ifdef CONFIG_FEATURE_TAR_FROM
+	if(opt & TAR_OPT_EXCLUDE_FROM) {
+		tar_handle->reject = append_file_list_to_list(tar_handle->reject);
+	}
+#endif
 
 	/* Check if we are reading from stdin */
 	if ((argv[optind]) && (*argv[optind] == '-')) {
@@ -703,26 +795,54 @@ int tar_main(int argc, char **argv)
 	/* Setup an array of filenames to work with */
 	/* TODO: This is the same as in ar, seperate function ? */
 	while (optind < argc) {
-		char absolute_path[PATH_MAX];
-
-		realpath(argv[optind], absolute_path);
-		tar_handle->accept = add_to_list(tar_handle->accept, absolute_path);
+		char *filename_ptr = last_char_is(argv[optind], '/');
+		if (filename_ptr) {
+			*filename_ptr = '\0';
+		}
+		tar_handle->accept = llist_add_to(tar_handle->accept, argv[optind]);
 		optind++;
-#ifdef CONFIG_FEATURE_TAR_EXCLUDE
-		if (tar_handle->reject) {
-			tar_handle->filter = filter_accept_reject_list;
+	}
+
+	if ((tar_handle->accept) || (tar_handle->reject)) {
+		tar_handle->filter = filter_accept_reject_list;
+	}
+
+	/* Open the tar file */
+	{
+		FILE *tar_stream;
+		int flags;
+
+#ifdef CONFIG_FEATURE_TAR_CREATE
+		if (opt & CTX_CREATE) {
+			/* Make sure there is at least one file to tar up.  */
+			if (tar_handle->accept == NULL) {
+				bb_error_msg_and_die("Cowardly refusing to create an empty archive");
+			}
+			tar_stream = stdout;
+			flags = O_WRONLY | O_CREAT | O_EXCL;
+			unlink(tar_filename);
 		} else
 #endif
-			tar_handle->filter = filter_accept_list;
+		{
+			tar_stream = stdin;
+			flags = O_RDONLY;
 		}
 
-	if ((base_dir) && (chdir(base_dir))) {
-		perror_msg_and_die("Couldnt chdir");
+		if ((tar_filename[0] == '-') && (tar_filename[1] == '\0')) {
+			tar_handle->src_fd = fileno(tar_stream);
+			tar_handle->seek = seek_by_char;
+		} else {
+			tar_handle->src_fd = bb_xopen(tar_filename, flags);
 		}
+	}
+
+	if ((base_dir) && (chdir(base_dir))) {
+		bb_perror_msg_and_die("Couldnt chdir to %s", base_dir);
+	}
 
 #ifdef CONFIG_FEATURE_TAR_CREATE
 	/* create an archive */
-	if (tar_create == TRUE) {
+	if (opt & CTX_CREATE) {
 		int verboseFlag = FALSE;
 		int gzipFlag = FALSE;
 
@@ -730,26 +850,40 @@ int tar_main(int argc, char **argv)
 		if (get_header_ptr == get_header_tar_gz) {
 			gzipFlag = TRUE;
 		}
-# endif
-		if (tar_handle->action_header == header_verbose_list) {
+# endif /* CONFIG_FEATURE_TAR_GZIP */
+# ifdef CONFIG_FEATURE_TAR_BZIP2
+		if (get_header_ptr == get_header_tar_bz2) {
+			bb_error_msg_and_die("Creating bzip2 compressed archives is not currently supported.");
+		}
+# endif /* CONFIG_FEATURE_TAR_BZIP2 */
+
+		if ((tar_handle->action_header == header_list) || 
+				(tar_handle->action_header == header_verbose_list)) {
 			verboseFlag = TRUE;
-	}
-		writeTarFile(src_filename, verboseFlag, tar_handle->accept,
+		}
+		writeTarFile(tar_handle->src_fd, verboseFlag, tar_handle->accept,
 			tar_handle->reject, gzipFlag);
 	} else 
-#endif
-#ifdef CONFIG_FEATURE_TAR_GZIP
-		if (get_header_ptr == get_header_tar_gz) {
-			get_header_tar_gz(tar_handle);
-		} else
-#endif
-			while (get_header_tar(tar_handle) == EXIT_SUCCESS);
+#endif /* CONFIG_FEATURE_TAR_CREATE */
+	{
+		while (get_header_ptr(tar_handle) == EXIT_SUCCESS);
+
+		/* Ckeck that every file that should have been extracted was */
+		while (tar_handle->accept) {
+			if (find_list_entry(tar_handle->reject, tar_handle->accept->data) == NULL) {
+				if (find_list_entry(tar_handle->passed, tar_handle->accept->data) == NULL) {
+					bb_error_msg_and_die("%s: Not found in archive\n", tar_handle->accept->data);
+				}
+			}
+			tar_handle->accept = tar_handle->accept->link;
+		}
+	}
 
 #ifdef CONFIG_FEATURE_CLEAN_UP
 	if (tar_handle->src_fd != fileno(stdin)) {
 		close(tar_handle->src_fd);
 	}
-#endif
+#endif /* CONFIG_FEATURE_CLEAN_UP */
 
 	return(EXIT_SUCCESS);
 }