libarchive-static 1.0.6 → 1.1.0

data/ext/libarchive-3.6.2/libarchive/archive_write_set_format_private.h

@@ -0,0 +1,42 @@
+/*-
+ * Copyright (c) 2020 Martin Matuska
+ * 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.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef ARCHIVE_WRITE_SET_FORMAT_PRIVATE_H_INCLUDED
+#define ARCHIVE_WRITE_SET_FORMAT_PRIVATE_H_INCLUDED
+
+#ifndef __LIBARCHIVE_BUILD
+#ifndef __LIBARCHIVE_TEST
+#error This header is only to be used internally to libarchive.
+#endif
+#endif
+
+#include "archive.h"
+#include "archive_entry.h"
+
+void __archive_write_entry_filetype_unsupported(struct archive *a,
+    struct archive_entry *entry, const char *format);
+#endif

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

@@ -0,0 +1,125 @@
+/*-
+ * Copyright (c) 2013 Marek Kubica
+ * 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"
+
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+
+#include "archive_entry.h"
+#include "archive_write_private.h"
+
+static ssize_t	archive_write_raw_data(struct archive_write *,
+		    const void *buff, size_t s);
+static int	archive_write_raw_free(struct archive_write *);
+static int	archive_write_raw_header(struct archive_write *,
+		    struct archive_entry *);
+
+struct raw {
+        int entries_written;
+};
+
+/*
+ * Set output format to 'raw' format.
+ */
+int
+archive_write_set_format_raw(struct archive *_a)
+{
+	struct archive_write *a = (struct archive_write *)_a;
+	struct raw *raw;
+
+	archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+	    ARCHIVE_STATE_NEW, "archive_write_set_format_raw");
+
+	/* If someone else was already registered, unregister them. */
+	if (a->format_free != NULL)
+		(a->format_free)(a);
+
+	raw = (struct raw *)calloc(1, sizeof(*raw));
+	if (raw == NULL) {
+		archive_set_error(&a->archive, ENOMEM, "Can't allocate raw data");
+		return (ARCHIVE_FATAL);
+	}
+	raw->entries_written = 0;
+	a->format_data = raw;
+	a->format_name = "raw";
+        /* no options exist for this format */
+	a->format_options = NULL;
+	a->format_write_header = archive_write_raw_header;
+	a->format_write_data = archive_write_raw_data;
+	a->format_finish_entry = NULL;
+        /* nothing needs to be done on closing */
+	a->format_close = NULL;
+	a->format_free = archive_write_raw_free;
+	a->archive.archive_format = ARCHIVE_FORMAT_RAW;
+	a->archive.archive_format_name = "RAW";
+	return (ARCHIVE_OK);
+}
+
+static int
+archive_write_raw_header(struct archive_write *a, struct archive_entry *entry)
+{
+	struct raw *raw = (struct raw *)a->format_data;
+
+	if (archive_entry_filetype(entry) != AE_IFREG) {
+		archive_set_error(&a->archive, ERANGE,
+		    "Raw format only supports filetype AE_IFREG");
+		return (ARCHIVE_FATAL);
+	}
+
+
+	if (raw->entries_written > 0) {
+		archive_set_error(&a->archive, ERANGE,
+		    "Raw format only supports one entry per archive");
+		return (ARCHIVE_FATAL);
+	}
+	raw->entries_written++;
+
+	return (ARCHIVE_OK);
+}
+
+static ssize_t
+archive_write_raw_data(struct archive_write *a, const void *buff, size_t s)
+{
+	int ret;
+
+	ret = __archive_write_output(a, buff, s);
+	if (ret >= 0)
+		return (s);
+	else
+		return (ret);
+}
+
+static int
+archive_write_raw_free(struct archive_write *a)
+{
+	struct raw *raw;
+
+	raw = (struct raw *)a->format_data;
+	free(raw);
+	a->format_data = NULL;
+	return (ARCHIVE_OK);
+}

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

@@ -42,6 +42,7 @@ __FBSDID("$FreeBSD: head/lib/libarchive/archive_write_set_format_shar.c 189438 2
 #include "archive_entry.h"
 #include "archive_private.h"
 #include "archive_write_private.h"
+#include "archive_write_set_format_private.h"
 
 struct shar {
 	int			 dump;
@@ -59,8 +60,8 @@ struct shar {
 	struct archive_string	 quoted_name;
 };
 
-static int	archive_write_shar_finish(struct archive_write *);
-static int	archive_write_shar_destroy(struct archive_write *);
+static int	archive_write_shar_close(struct archive_write *);
+static int	archive_write_shar_free(struct archive_write *);
 static int	archive_write_shar_header(struct archive_write *,
 		    struct archive_entry *);
 static ssize_t	archive_write_shar_data_sed(struct archive_write *,
@@ -106,25 +107,25 @@ archive_write_set_format_shar(struct archive *_a)
 	struct archive_write *a = (struct archive_write *)_a;
 	struct shar *shar;
 
+	archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+	    ARCHIVE_STATE_NEW, "archive_write_set_format_shar");
+
 	/* If someone else was already registered, unregister them. */
-	if (a->format_destroy != NULL)
-		(a->format_destroy)(a);
+	if (a->format_free != NULL)
+		(a->format_free)(a);
 
-	shar = (struct shar *)malloc(sizeof(*shar));
+	shar = (struct shar *)calloc(1, sizeof(*shar));
 	if (shar == NULL) {
 		archive_set_error(&a->archive, ENOMEM, "Can't allocate shar data");
 		return (ARCHIVE_FATAL);
 	}
-	memset(shar, 0, sizeof(*shar));
 	archive_string_init(&shar->work);
 	archive_string_init(&shar->quoted_name);
 	a->format_data = shar;
-
-	a->pad_uncompressed = 0;
 	a->format_name = "shar";
 	a->format_write_header = archive_write_shar_header;
-	a->format_finish = archive_write_shar_finish;
-	a->format_destroy = archive_write_shar_destroy;
+	a->format_close = archive_write_shar_close;
+	a->format_free = archive_write_shar_free;
 	a->format_write_data = archive_write_shar_data_sed;
 	a->format_finish_entry = archive_write_shar_finish_entry;
 	a->archive.archive_format = ARCHIVE_FORMAT_SHAR_BASE;
@@ -169,8 +170,7 @@ archive_write_shar_header(struct archive_write *a, struct archive_entry *entry)
 	}
 
 	/* Save the entry for the closing. */
-	if (shar->entry)
-		archive_entry_free(shar->entry);
+	archive_entry_free(shar->entry);
 	shar->entry = archive_entry_clone(entry);
 	name = archive_entry_pathname(entry);
 
@@ -195,8 +195,8 @@ archive_write_shar_header(struct archive_write *a, struct archive_entry *entry)
 		archive_entry_set_size(entry, 0);
 		if (archive_entry_hardlink(entry) == NULL &&
 		    archive_entry_symlink(entry) == NULL) {
-			archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
-			    "shar format cannot archive this");
+			__archive_write_entry_filetype_unsupported(
+			    &a->archive, entry, "shar");
 			return (ARCHIVE_WARN);
 		}
 	}
@@ -266,12 +266,12 @@ archive_write_shar_header(struct archive_write *a, struct archive_entry *entry)
 				    shar->quoted_name.s, shar->quoted_name.s);
 			} else {
 				if (shar->dump) {
+					unsigned int mode = archive_entry_mode(entry) & 0777;
 					archive_string_sprintf(&shar->work,
 					    "uudecode -p > %s << 'SHAR_END'\n",
 					    shar->quoted_name.s);
 					archive_string_sprintf(&shar->work,
-					    "begin %o ",
-					    archive_entry_mode(entry) & 0777);
+					    "begin %o ", mode);
 					shar_quote(&shar->work, name, 0);
 					archive_strcat(&shar->work, "\n");
 				} else {
@@ -289,8 +289,7 @@ archive_write_shar_header(struct archive_write *a, struct archive_entry *entry)
 			    "mkdir -p %s > /dev/null 2>&1\n",
 			    shar->quoted_name.s);
 			/* Record that we just created this directory. */
-			if (shar->last_dir != NULL)
-				free(shar->last_dir);
+			free(shar->last_dir);
 
 			shar->last_dir = strdup(name);
 			/* Trim a trailing '/'. */
@@ -308,15 +307,15 @@ archive_write_shar_header(struct archive_write *a, struct archive_entry *entry)
 			break;
 		case AE_IFCHR:
 			archive_string_sprintf(&shar->work,
-			    "mknod %s c %d %d\n", shar->quoted_name.s,
-			    archive_entry_rdevmajor(entry),
-			    archive_entry_rdevminor(entry));
+			    "mknod %s c %ju %ju\n", shar->quoted_name.s,
+			    (uintmax_t)archive_entry_rdevmajor(entry),
+			    (uintmax_t)archive_entry_rdevminor(entry));
 			break;
 		case AE_IFBLK:
 			archive_string_sprintf(&shar->work,
-			    "mknod %s b %d %d\n", shar->quoted_name.s,
-			    archive_entry_rdevmajor(entry),
-			    archive_entry_rdevminor(entry));
+			    "mknod %s b %ju %ju\n", shar->quoted_name.s,
+			    (uintmax_t)archive_entry_rdevmajor(entry),
+			    (uintmax_t)archive_entry_rdevminor(entry));
 			break;
 		default:
 			return (ARCHIVE_WARN);
@@ -349,11 +348,13 @@ archive_write_shar_data_sed(struct archive_write *a, const void *buff, size_t n)
 	 * twice before entering the loop, so make sure three additional
 	 * bytes can be written.
 	 */
-	if (archive_string_ensure(&shar->work, ensured + 3) == NULL)
-		__archive_errx(1, "Out of memory");
+	if (archive_string_ensure(&shar->work, ensured + 3) == NULL) {
+		archive_set_error(&a->archive, ENOMEM, "Out of memory");
+		return (ARCHIVE_FATAL);
+	}
 
 	if (shar->work.length > ensured) {
-		ret = (*a->compressor.write)(a, shar->work.s,
+		ret = __archive_write_output(a, shar->work.s,
 		    shar->work.length);
 		if (ret != ARCHIVE_OK)
 			return (ARCHIVE_FATAL);
@@ -377,7 +378,7 @@ archive_write_shar_data_sed(struct archive_write *a, const void *buff, size_t n)
 
 		if (buf >= buf_end) {
 			shar->work.length = buf - shar->work.s;
-			ret = (*a->compressor.write)(a, shar->work.s,
+			ret = __archive_write_output(a, shar->work.s,
 			    shar->work.length);
 			if (ret != ARCHIVE_OK)
 				return (ARCHIVE_FATAL);
@@ -406,16 +407,18 @@ uuencode_group(const char _in[3], char out[4])
 	out[3] = UUENC( 0x3f & t );
 }
 
-static void
-uuencode_line(struct shar *shar, const char *inbuf, size_t len)
+static int
+_uuencode_line(struct archive_write *a, struct shar *shar, const char *inbuf, size_t len)
 {
-	char tmp_buf[3], *buf;
+	char *buf;
 	size_t alloc_len;
 
 	/* len <= 45 -> expanded to 60 + len byte + new line */
 	alloc_len = shar->work.length + 62;
-	if (archive_string_ensure(&shar->work, alloc_len) == NULL)
-		__archive_errx(1, "Out of memory");
+	if (archive_string_ensure(&shar->work, alloc_len) == NULL) {
+		archive_set_error(&a->archive, ENOMEM, "Out of memory");
+		return (ARCHIVE_FATAL);
+	}
 
 	buf = shar->work.s + shar->work.length;
 	*buf++ = UUENC(len);
@@ -426,21 +429,33 @@ uuencode_line(struct shar *shar, const char *inbuf, size_t len)
 		buf += 4;
 	}
 	if (len != 0) {
+		char tmp_buf[3];
 		tmp_buf[0] = inbuf[0];
 		if (len == 1)
 			tmp_buf[1] = '\0';
 		else
 			tmp_buf[1] = inbuf[1];
 		tmp_buf[2] = '\0';
-		uuencode_group(inbuf, buf);
+		uuencode_group(tmp_buf, buf);
 		buf += 4;
 	}
 	*buf++ = '\n';
-	if ((buf - shar->work.s) > (ptrdiff_t)(shar->work.length + 62))
-		__archive_errx(1, "Buffer overflow");
+	if ((buf - shar->work.s) > (ptrdiff_t)(shar->work.length + 62)) {
+		archive_set_error(&a->archive,
+		    ARCHIVE_ERRNO_MISC, "Buffer overflow");
+		return (ARCHIVE_FATAL);
+	}
 	shar->work.length = buf - shar->work.s;
+	return (ARCHIVE_OK);
 }
 
+#define uuencode_line(__a, __shar, __inbuf, __len) \
+	do { \
+		int r = _uuencode_line(__a, __shar, __inbuf, __len); \
+		if (r != ARCHIVE_OK) \
+			return (ARCHIVE_FATAL); \
+	} while (0)
+
 static ssize_t
 archive_write_shar_data_uuencode(struct archive_write *a, const void *buff,
     size_t length)
@@ -464,7 +479,7 @@ archive_write_shar_data_uuencode(struct archive_write *a, const void *buff,
 			shar->outpos += n;
 			return length;
 		}
-		uuencode_line(shar, shar->outbuff, 45);
+		uuencode_line(a, shar, shar->outbuff, 45);
 		src += n;
 		n = length - n;
 	} else {
@@ -472,13 +487,13 @@ archive_write_shar_data_uuencode(struct archive_write *a, const void *buff,
 	}
 
 	while (n >= 45) {
-		uuencode_line(shar, src, 45);
+		uuencode_line(a, shar, src, 45);
 		src += 45;
 		n -= 45;
 
 		if (shar->work.length < 65536)
 			continue;
-		ret = (*a->compressor.write)(a, shar->work.s,
+		ret = __archive_write_output(a, shar->work.s,
 		    shar->work.length);
 		if (ret != ARCHIVE_OK)
 			return (ARCHIVE_FATAL);
@@ -506,7 +521,7 @@ archive_write_shar_finish_entry(struct archive_write *a)
 		/* Finish uuencoded data. */
 		if (shar->has_data) {
 			if (shar->outpos > 0)
-				uuencode_line(shar, shar->outbuff,
+				uuencode_line(a, shar, shar->outbuff,
 				    shar->outpos);
 			archive_strcat(&shar->work, "`\nend\n");
 			archive_strcat(&shar->work, "SHAR_END\n");
@@ -517,7 +532,7 @@ archive_write_shar_finish_entry(struct archive_write *a)
 		 * directories; defer that to end of script.
 		 */
 		archive_string_sprintf(&shar->work, "chmod %o ",
-		    archive_entry_mode(shar->entry) & 07777);
+		    (unsigned int)(archive_entry_mode(shar->entry) & 07777));
 		shar_quote(&shar->work, archive_entry_pathname(shar->entry), 1);
 		archive_strcat(&shar->work, "\n");
 
@@ -531,14 +546,14 @@ archive_write_shar_finish_entry(struct archive_write *a)
 				archive_strcat(&shar->work, ":");
 				shar_quote(&shar->work, g, 1);
 			}
+			archive_strcat(&shar->work, " ");
 			shar_quote(&shar->work,
 			    archive_entry_pathname(shar->entry), 1);
 			archive_strcat(&shar->work, "\n");
 		}
 
 		if ((p = archive_entry_fflags_text(shar->entry)) != NULL) {
-			archive_string_sprintf(&shar->work, "chflags %s ",
-			    p, archive_entry_pathname(shar->entry));
+			archive_string_sprintf(&shar->work, "chflags %s ", p);
 			shar_quote(&shar->work,
 			    archive_entry_pathname(shar->entry), 1);
 			archive_strcat(&shar->work, "\n");
@@ -561,7 +576,7 @@ archive_write_shar_finish_entry(struct archive_write *a)
 	if (shar->work.length < 65536)
 		return (ARCHIVE_OK);
 
-	ret = (*a->compressor.write)(a, shar->work.s, shar->work.length);
+	ret = __archive_write_output(a, shar->work.s, shar->work.length);
 	if (ret != ARCHIVE_OK)
 		return (ARCHIVE_FATAL);
 	archive_string_empty(&shar->work);
@@ -570,7 +585,7 @@ archive_write_shar_finish_entry(struct archive_write *a)
 }
 
 static int
-archive_write_shar_finish(struct archive_write *a)
+archive_write_shar_close(struct archive_write *a)
 {
 	struct shar *shar;
 	int ret;
@@ -593,7 +608,7 @@ archive_write_shar_finish(struct archive_write *a)
 
 	archive_strcat(&shar->work, "exit\n");
 
-	ret = (*a->compressor.write)(a, shar->work.s, shar->work.length);
+	ret = __archive_write_output(a, shar->work.s, shar->work.length);
 	if (ret != ARCHIVE_OK)
 		return (ARCHIVE_FATAL);
 
@@ -608,7 +623,7 @@ archive_write_shar_finish(struct archive_write *a)
 }
 
 static int
-archive_write_shar_destroy(struct archive_write *a)
+archive_write_shar_free(struct archive_write *a)
 {
 	struct shar *shar;