libarchive-static 1.0.6 → 1.1.0

data/ext/{libarchive-2.8.4/libarchive/filter_fork.c → libarchive-3.6.2/libarchive/filter_fork_posix.c}

@@ -1,5 +1,6 @@
 /*-
  * Copyright (c) 2007 Joerg Sonnenberger
+ * Copyright (c) 2012 Michihiro NAKAJIMA 
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,10 +28,19 @@
 
 /* This capability is only available on POSIX systems. */
 #if defined(HAVE_PIPE) && defined(HAVE_FCNTL) && \
-    (defined(HAVE_FORK) || defined(HAVE_VFORK))
+    (defined(HAVE_FORK) || defined(HAVE_VFORK) || defined(HAVE_POSIX_SPAWNP))
 
 __FBSDID("$FreeBSD: head/lib/libarchive/filter_fork.c 182958 2008-09-12 05:33:00Z kientzle $");
 
+#if defined(HAVE_SYS_TYPES_H)
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_ERRNO_H
+#  include <errno.h>
+#endif
+#ifdef HAVE_STRING_H
+#  include <string.h>
+#endif
 #if defined(HAVE_POLL) && (defined(HAVE_POLL_H) || defined(HAVE_SYS_POLL_H))
 #  if defined(HAVE_POLL_H)
 #    include <poll.h>
@@ -47,17 +57,38 @@ __FBSDID("$FreeBSD: head/lib/libarchive/filter_fork.c 182958 2008-09-12 05:33:00
 #ifdef HAVE_FCNTL_H
 #  include <fcntl.h>
 #endif
+#ifdef HAVE_SPAWN_H
+#  include <spawn.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+#endif
 #ifdef HAVE_UNISTD_H
 #  include <unistd.h>
 #endif
 
+#include "archive.h"
+#include "archive_cmdline_private.h"
+
 #include "filter_fork.h"
 
-pid_t
-__archive_create_child(const char *path, int *child_stdin, int *child_stdout)
+int
+__archive_create_child(const char *cmd, int *child_stdin, int *child_stdout,
+		pid_t *out_child)
 {
-	pid_t child;
+	pid_t child = -1;
 	int stdin_pipe[2], stdout_pipe[2], tmp;
+#if HAVE_POSIX_SPAWNP
+	posix_spawn_file_actions_t actions;
+	int r;
+#endif
+	struct archive_cmdline *cmdline;
+
+	cmdline = __archive_cmdline_allocate();
+	if (cmdline == NULL)
+		goto state_allocated;
+	if (__archive_cmdline_parse(cmdline, cmd) != ARCHIVE_OK)
+		goto state_allocated;
 
 	if (pipe(stdin_pipe) == -1)
 		goto state_allocated;
@@ -76,14 +107,53 @@ __archive_create_child(const char *path, int *child_stdin, int *child_stdout)
 		stdout_pipe[1] = tmp;
 	}
 
+#if HAVE_POSIX_SPAWNP
+
+	r = posix_spawn_file_actions_init(&actions);
+	if (r != 0) {
+		errno = r;
+		goto stdout_opened;
+	}
+	r = posix_spawn_file_actions_addclose(&actions, stdin_pipe[1]);
+	if (r != 0)
+		goto actions_inited;
+	r = posix_spawn_file_actions_addclose(&actions, stdout_pipe[0]);
+	if (r != 0)
+		goto actions_inited;
+	/* Setup for stdin. */
+	r = posix_spawn_file_actions_adddup2(&actions, stdin_pipe[0], 0);
+	if (r != 0)
+		goto actions_inited;
+	if (stdin_pipe[0] != 0 /* stdin */) {
+		r = posix_spawn_file_actions_addclose(&actions, stdin_pipe[0]);
+		if (r != 0)
+			goto actions_inited;
+	}
+	/* Setup for stdout. */
+	r = posix_spawn_file_actions_adddup2(&actions, stdout_pipe[1], 1);
+	if (r != 0)
+		goto actions_inited;
+	if (stdout_pipe[1] != 1 /* stdout */) {
+		r = posix_spawn_file_actions_addclose(&actions, stdout_pipe[1]);
+		if (r != 0)
+			goto actions_inited;
+	}
+	r = posix_spawnp(&child, cmdline->path, &actions, NULL,
+		cmdline->argv, NULL);
+	if (r != 0)
+		goto actions_inited;
+	posix_spawn_file_actions_destroy(&actions);
+
+#else /* HAVE_POSIX_SPAWNP */
+
 #if HAVE_VFORK
-	switch ((child = vfork())) {
+	child = vfork();
 #else
-	switch ((child = fork())) {
+	child = fork();
 #endif
-	case -1:
+	if (child == -1)
 		goto stdout_opened;
-	case 0:
+	if (child == 0) {
 		close(stdin_pipe[1]);
 		close(stdout_pipe[0]);
 		if (dup2(stdin_pipe[0], 0 /* stdin */) == -1)
@@ -94,20 +164,28 @@ __archive_create_child(const char *path, int *child_stdin, int *child_stdout)
 			_exit(254);
 		if (stdout_pipe[1] != 1 /* stdout */)
 			close(stdout_pipe[1]);
-		execlp(path, path, (char *)NULL);
+		execvp(cmdline->path, cmdline->argv);
 		_exit(254);
-	default:
-		close(stdin_pipe[0]);
-		close(stdout_pipe[1]);
-
-		*child_stdin = stdin_pipe[1];
-		fcntl(*child_stdin, F_SETFL, O_NONBLOCK);
-		*child_stdout = stdout_pipe[0];
-		fcntl(*child_stdout, F_SETFL, O_NONBLOCK);
 	}
+#endif /* HAVE_POSIX_SPAWNP */
+
+	close(stdin_pipe[0]);
+	close(stdout_pipe[1]);
+
+	*child_stdin = stdin_pipe[1];
+	fcntl(*child_stdin, F_SETFL, O_NONBLOCK);
+	*child_stdout = stdout_pipe[0];
+	fcntl(*child_stdout, F_SETFL, O_NONBLOCK);
+	__archive_cmdline_free(cmdline);
 
-	return child;
+	*out_child = child;
+	return ARCHIVE_OK;
 
+#if HAVE_POSIX_SPAWNP
+actions_inited:
+	errno = r;
+	posix_spawn_file_actions_destroy(&actions);
+#endif
 stdout_opened:
 	close(stdout_pipe[0]);
 	close(stdout_pipe[1]);
@@ -115,7 +193,8 @@ stdin_opened:
 	close(stdin_pipe[0]);
 	close(stdin_pipe[1]);
 state_allocated:
-	return -1;
+	__archive_cmdline_free(cmdline);
+	return ARCHIVE_FAILED;
 }
 
 void

data/ext/libarchive-3.6.2/libarchive/filter_fork_windows.c

@@ -0,0 +1,236 @@
+/*-
+ * Copyright (c) 2009-2012 Michihiro NAKAJIMA
+ * 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.
+ */
+
+#include "archive_platform.h"
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#include "archive_cmdline_private.h"
+#include "archive_string.h"
+
+#include "filter_fork.h"
+
+/* There are some editions of Windows ("nano server," for example) that
+ * do not host user32.dll. If we want to keep running on those editions,
+ * we need to delay-load WaitForInputIdle. */
+static void *
+la_GetFunctionUser32(const char *name)
+{
+	static HINSTANCE lib;
+	static int set;
+	if (!set) {
+		set = 1;
+		lib = LoadLibrary(TEXT("user32.dll"));
+	}
+	if (lib == NULL) {
+		return NULL;
+	}
+	return (void *)GetProcAddress(lib, name);
+}
+
+static int
+la_WaitForInputIdle(HANDLE hProcess, DWORD dwMilliseconds)
+{
+	static DWORD (WINAPI *f)(HANDLE, DWORD);
+	static int set;
+
+	if (!set) {
+		set = 1;
+		f = la_GetFunctionUser32("WaitForInputIdle");
+	}
+
+	if (!f) {
+		/* An inability to wait for input idle is
+		 * not _good_, but it is not catastrophic. */
+		return WAIT_FAILED;
+	}
+	return (*f)(hProcess, dwMilliseconds);
+}
+
+int
+__archive_create_child(const char *cmd, int *child_stdin, int *child_stdout,
+		HANDLE *out_child)
+{
+	HANDLE childStdout[2], childStdin[2],childStderr;
+	SECURITY_ATTRIBUTES secAtts;
+	STARTUPINFOA staInfo;
+	PROCESS_INFORMATION childInfo;
+	struct archive_string cmdline;
+	struct archive_string fullpath;
+	struct archive_cmdline *acmd;
+	char *arg0, *ext;
+	int i, l;
+	DWORD fl, fl_old;
+	HANDLE child;
+
+	childStdout[0] = childStdout[1] = INVALID_HANDLE_VALUE;
+	childStdin[0] = childStdin[1] = INVALID_HANDLE_VALUE;
+	childStderr = INVALID_HANDLE_VALUE;
+	archive_string_init(&cmdline);
+	archive_string_init(&fullpath);
+
+	acmd = __archive_cmdline_allocate();
+	if (acmd == NULL)
+		goto fail;
+	if (__archive_cmdline_parse(acmd, cmd) != ARCHIVE_OK)
+		goto fail;
+
+	/*
+	 * Search the full path of 'path'.
+	 * NOTE: This does not need if we give CreateProcessA 'path' as
+	 * a part of the cmdline and give CreateProcessA NULL as first
+	 * parameter, but I do not like that way.
+	 */
+	ext = strrchr(acmd->path, '.');
+	if (ext == NULL || strlen(ext) > 4)
+		/* 'path' does not have a proper extension, so we have to
+		 * give SearchPath() ".exe" as the extension. */
+		ext = ".exe";
+	else
+		ext = NULL;/* 'path' has an extension. */
+
+	fl = MAX_PATH;
+	do {
+		if (archive_string_ensure(&fullpath, fl) == NULL)
+			goto fail;
+		fl_old = fl;
+		fl = SearchPathA(NULL, acmd->path, ext, fl, fullpath.s,
+			&arg0);
+	} while (fl != 0 && fl > fl_old);
+	if (fl == 0)
+		goto fail;
+
+	/*
+	 * Make a command line.
+	 */
+	for (l = 0, i = 0;  acmd->argv[i] != NULL; i++) {
+		if (i == 0)
+			continue;
+		l += (int)strlen(acmd->argv[i]) + 1;
+	}
+	if (archive_string_ensure(&cmdline, l + 1) == NULL)
+		goto fail;
+	for (i = 0;  acmd->argv[i] != NULL; i++) {
+		if (i == 0) {
+			const char *p, *sp;
+
+			if ((p = strchr(acmd->argv[i], '/')) != NULL ||
+			    (p = strchr(acmd->argv[i], '\\')) != NULL)
+				p++;
+			else
+				p = acmd->argv[i];
+			if ((sp = strchr(p, ' ')) != NULL)
+				archive_strappend_char(&cmdline, '"');
+			archive_strcat(&cmdline, p);
+			if (sp != NULL)
+				archive_strappend_char(&cmdline, '"');
+		} else {
+			archive_strappend_char(&cmdline, ' ');
+			archive_strcat(&cmdline, acmd->argv[i]);
+		}
+	}
+	if (i <= 1) {
+		const char *sp;
+
+		if ((sp = strchr(arg0, ' ')) != NULL)
+			archive_strappend_char(&cmdline, '"');
+		archive_strcat(&cmdline, arg0);
+		if (sp != NULL)
+			archive_strappend_char(&cmdline, '"');
+	}
+
+	secAtts.nLength = sizeof(SECURITY_ATTRIBUTES);
+	secAtts.bInheritHandle = TRUE;
+	secAtts.lpSecurityDescriptor = NULL;
+	if (CreatePipe(&childStdout[0], &childStdout[1], &secAtts, 0) == 0)
+		goto fail;
+	if (!SetHandleInformation(childStdout[0], HANDLE_FLAG_INHERIT, 0))
+		goto fail;
+	if (CreatePipe(&childStdin[0], &childStdin[1], &secAtts, 0) == 0)
+		goto fail;
+	if (!SetHandleInformation(childStdin[1], HANDLE_FLAG_INHERIT, 0))
+		goto fail;
+	if (DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_ERROR_HANDLE),
+	    GetCurrentProcess(), &childStderr, 0, TRUE,
+	    DUPLICATE_SAME_ACCESS) == 0)
+		goto fail;
+
+	memset(&staInfo, 0, sizeof(staInfo));
+	staInfo.cb = sizeof(staInfo);
+	staInfo.hStdError = childStderr;
+	staInfo.hStdOutput = childStdout[1];
+	staInfo.hStdInput = childStdin[0];
+	staInfo.wShowWindow = SW_HIDE;
+	staInfo.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
+	if (CreateProcessA(fullpath.s, cmdline.s, NULL, NULL, TRUE, 0,
+	      NULL, NULL, &staInfo, &childInfo) == 0)
+		goto fail;
+	la_WaitForInputIdle(childInfo.hProcess, INFINITE);
+	CloseHandle(childInfo.hProcess);
+	CloseHandle(childInfo.hThread);
+
+	*child_stdout = _open_osfhandle((intptr_t)childStdout[0], _O_RDONLY);
+	*child_stdin = _open_osfhandle((intptr_t)childStdin[1], _O_WRONLY);
+	
+	child = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
+		childInfo.dwProcessId);
+	if (child == NULL) // INVALID_HANDLE_VALUE ?
+		goto fail;
+
+	*out_child = child;
+
+	CloseHandle(childStdout[1]);
+	CloseHandle(childStdin[0]);
+
+	archive_string_free(&cmdline);
+	archive_string_free(&fullpath);
+	__archive_cmdline_free(acmd);
+	return ARCHIVE_OK;
+
+fail:
+	if (childStdout[0] != INVALID_HANDLE_VALUE)
+		CloseHandle(childStdout[0]);
+	if (childStdout[1] != INVALID_HANDLE_VALUE)
+		CloseHandle(childStdout[1]);
+	if (childStdin[0] != INVALID_HANDLE_VALUE)
+		CloseHandle(childStdin[0]);
+	if (childStdin[1] != INVALID_HANDLE_VALUE)
+		CloseHandle(childStdin[1]);
+	if (childStderr != INVALID_HANDLE_VALUE)
+		CloseHandle(childStderr);
+	archive_string_free(&cmdline);
+	archive_string_free(&fullpath);
+	__archive_cmdline_free(acmd);
+	return ARCHIVE_FAILED;
+}
+
+void
+__archive_check_child(int in, int out)
+{
+	(void)in; /* UNUSED */
+	(void)out; /* UNUSED */
+	Sleep(100);
+}
+
+#endif /* _WIN32 && !__CYGWIN__ */