diff --git a/libarchive/Makefile b/libarchive/Makefile
index ad967ee..1ee2982 100644
--- a/libarchive/Makefile
+++ b/libarchive/Makefile
@@ -2,19 +2,22 @@ CFLAGS     = -g
 INCLUDE    = -I/usr/include -I.
 LIBS       = -larchive
 
+DEFINES = -DPyUnicode_AS_STRING=PyUnicode_AS_DATA
 PYVER ?= 3.9
 
 all: __libarchive.so
 
-_libarchive_wrap.c: _libarchive.i
+_libarchive_wrap.cxx: _libarchive.i
 	#swig -python -c++ -Wall -shadow _libarchive.i
-	swig -python -Wall -shadow _libarchive.i
+	swig -python -Wall -shadow  _libarchive.i
 
 _libarchive_wrap.o: _libarchive_wrap.c
-	${CC} -c ${CFLAGS} -fPIC ${INCLUDE} $$(python${PYVER}-config --cflags) _libarchive_wrap.c
+	echo ${CC} -c ${CFLAGS} -fPIC  $$(python${PYVER}-config --cflags) _libarchive_wrap.c
+	${CC} -c ${CFLAGS} -fPIC  $$(python${PYVER}-config --cflags) ${DEFINES} _libarchive_wrap.c
+#	${CXX} -c ${CFLAGS} -fPIC  $$(python${PYVER}-config --cflags) -DPyUnicode_AS_STRING=PyUnicode_AS_DATA _libarchive_wrap.cxx
 
 __libarchive.so: _libarchive_wrap.o
 	${CC} _libarchive_wrap.o -shared $$(python${PYVER}-config --ldflags) -o __libarchive.so ${LIBS}
 
 clean:
-	rm -f *.o *.so *.pyc
+	rm -f *.o *.so *.pyc
\ No newline at end of file
diff --git a/libarchive/__init__.py b/libarchive/__init__.py
index f387896..c4861f1 100644
--- a/libarchive/__init__.py
+++ b/libarchive/__init__.py
@@ -623,6 +623,10 @@ class Archive(object):
             s.write(entry.pathname)
         s.flush()
 
+    def add_passphrase(self, password):
+        '''Adds a password to the archive.'''
+        _libarchive.archive_read_add_passphrase(self._a, password)
+
 
 class SeekableArchive(Archive):
     '''A class that provides random-access to archive entries. It does this by using one
diff --git a/libarchive/_libarchive.i b/libarchive/_libarchive.i
index ccf48f2..6b0bc27 100644
--- a/libarchive/_libarchive.i
+++ b/libarchive/_libarchive.i
@@ -153,8 +153,8 @@ extern int		 archive_read_free(struct archive *);
 extern int archive_read_open_filename(struct archive *,
 		     const char *_filename, size_t _block_size);
 extern int archive_read_open_memory(struct archive *,
-		     void * buff, size_t size);
-extern int archive_read_open_memory2(struct archive *a, void *buff,
+		     const void * buff, size_t size);
+extern int archive_read_open_memory2(struct archive *a, void const *buff,
 		     size_t size, size_t read_size);
 extern int archive_read_open_fd(struct archive *, int _fd,
 		     size_t _block_size);
@@ -169,39 +169,107 @@ extern int archive_read_next_header2(struct archive *,
 extern const struct stat	*archive_entry_stat(struct archive_entry *);
 extern __LA_INT64_T		 archive_read_header_position(struct archive *);
 
+/*
+ * Set read options.
+ */
+/* Apply option to the format only. */
+extern int archive_read_set_format_option(struct archive *_a,
+			    const char *m, const char *o,
+			    const char *v);
+/* Apply option to the filter only. */
+extern int archive_read_set_filter_option(struct archive *_a,
+			    const char *m, const char *o,
+			    const char *v);
+/* Apply option to both the format and the filter. */
+extern int archive_read_set_option(struct archive *_a,
+			    const char *m, const char *o,
+			    const char *v);
+/* Apply option string to both the format and the filter. */
+extern int archive_read_set_options(struct archive *_a,
+			    const char *opts);
+
+/*
+ * Add a decryption passphrase.
+ */
+extern int archive_read_add_passphrase(struct archive *, const char *);
 /* data */
 extern int archive_read_data_skip(struct archive *);
 extern int archive_read_data_into_fd(struct archive *, int fd);
 
-/* FILTERS */
+#if ARCHIVE_VERSION_NUMBER < 4000000
+extern int archive_read_support_compression_all(struct archive *);
+extern int archive_read_support_compression_bzip2(struct archive *);
+extern int archive_read_support_compression_compress(struct archive *);
+extern int archive_read_support_compression_gzip(struct archive *);
+extern int archive_read_support_compression_lzip(struct archive *);
+extern int archive_read_support_compression_lzma(struct archive *);
+extern int archive_read_support_compression_none(struct archive *);
+extern int archive_read_support_compression_program(struct archive *, const char *command);
+extern int archive_read_support_compression_program_signature
+		(struct archive *, const char *,
+		 const void * /* match */, size_t);
+
+extern int archive_read_support_compression_rpm(struct archive *);
+extern int archive_read_support_compression_uu(struct archive *);
+extern int archive_read_support_compression_xz(struct archive *);
+#endif
+
 extern int archive_read_support_filter_all(struct archive *);
 extern int archive_read_support_filter_bzip2(struct archive *);
 extern int archive_read_support_filter_compress(struct archive *);
 extern int archive_read_support_filter_gzip(struct archive *);
+extern int archive_read_support_filter_grzip(struct archive *);
+extern int archive_read_support_filter_lrzip(struct archive *);
+extern int archive_read_support_filter_lz4(struct archive *);
 extern int archive_read_support_filter_lzip(struct archive *);
 extern int archive_read_support_filter_lzma(struct archive *);
+extern int archive_read_support_filter_lzop(struct archive *);
 extern int archive_read_support_filter_none(struct archive *);
+extern int archive_read_support_filter_program(struct archive *,
+		     const char *command);
+extern int archive_read_support_filter_program_signature
+		(struct archive *, const char * /* cmd */,
+				    const void * /* match */, size_t);
 extern int archive_read_support_filter_rpm(struct archive *);
 extern int archive_read_support_filter_uu(struct archive *);
 extern int archive_read_support_filter_xz(struct archive *);
 
-/* FORMATS */
-extern int archive_read_support_format_all(struct archive *);
 extern int archive_read_support_format_7zip(struct archive *);
+extern int archive_read_support_format_all(struct archive *);
 extern int archive_read_support_format_ar(struct archive *);
+extern int archive_read_support_format_by_code(struct archive *, int);
 extern int archive_read_support_format_cab(struct archive *);
 extern int archive_read_support_format_cpio(struct archive *);
 extern int archive_read_support_format_empty(struct archive *);
 extern int archive_read_support_format_gnutar(struct archive *);
 extern int archive_read_support_format_iso9660(struct archive *);
 extern int archive_read_support_format_lha(struct archive *);
-/*extern int archive_read_support_format_mtree(struct archive *);*/
+/* extern int archive_read_support_format_mtree(struct archive *); */
 extern int archive_read_support_format_rar(struct archive *);
 extern int archive_read_support_format_raw(struct archive *);
 extern int archive_read_support_format_tar(struct archive *);
+extern int archive_read_support_format_warc(struct archive *);
 extern int archive_read_support_format_xar(struct archive *);
+/* archive_read_support_format_zip() enables both streamable and seekable
+ * zip readers. */
 extern int archive_read_support_format_zip(struct archive *);
-/*extern int archive_read_support_format_by_code(struct archive *, int);*/
+/* Reads Zip archives as stream from beginning to end.  Doesn't
+ * correctly handle SFX ZIP files or ZIP archives that have been modified
+ * in-place. */
+extern int archive_read_support_format_zip_streamable(struct archive *);
+/* Reads starting from central directory; requires seekable input. */
+extern int archive_read_support_format_zip_seekable(struct archive *);
+
+/* Functions to manually set the format and filters to be used. This is
+ * useful to bypass the bidding process when the format and filters to use
+ * is known in advance.
+ */
+extern int archive_read_set_format(struct archive *, int);
+extern int archive_read_append_filter(struct archive *, int);
+extern int archive_read_append_filter_program(struct archive *,
+    const char *);
+extern int archive_read_append_filter_program_signature
+    (struct archive *, const char *, const void * /* match */, size_t);
 
 /* ARCHIVE WRITING */
 extern struct archive	*archive_write_new(void);
@@ -282,8 +350,8 @@ extern void	archive_entry_set_link(struct archive_entry *, const char *);
 //extern int		 archive_entry_symlink_type(struct archive_entry *);
 extern const wchar_t	*archive_entry_symlink_w(struct archive_entry *);
 
-//__LA_DECL void	archive_entry_copy_link(struct archive_entry *, const char *);
-//__LA_DECL void	archive_entry_copy_link_w(struct archive_entry *, const wchar_t *);
+//extern void	archive_entry_copy_link(struct archive_entry *, const char *);
+//extern void	archive_entry_copy_link_w(struct archive_entry *, const wchar_t *);
 
 /* The names for symlink modes here correspond to an old BSD
  * command-line argument convention: -L, -P, -H */
@@ -318,8 +386,8 @@ extern const char	*archive_error_string(struct archive *);
 
 
 /* CONSTANTS */
-#define	ARCHIVE_VERSION_NUMBER 3005003
-#define	ARCHIVE_VERSION_STRING "libarchive 3.5.2"
+#define	ARCHIVE_VERSION_NUMBER 3002002
+#define	ARCHIVE_VERSION_STRING "libarchive 3.2.2"
 #define	ARCHIVE_EOF	  1	/* Found end of archive. */
 #define	ARCHIVE_OK	  0	/* Operation was successful. */
 #define	ARCHIVE_RETRY	(-10)	/* Retry might succeed. */
@@ -337,6 +405,10 @@ extern const char	*archive_error_string(struct archive *);
 #define	ARCHIVE_FILTER_UU	7
 #define	ARCHIVE_FILTER_RPM	8
 #define	ARCHIVE_FILTER_LZIP	9
+#define	ARCHIVE_FILTER_LRZIP	10
+#define	ARCHIVE_FILTER_LZOP	11
+#define	ARCHIVE_FILTER_GRZIP	12
+#define	ARCHIVE_FILTER_LZ4	13
 
 #define	ARCHIVE_FORMAT_BASE_MASK		0xff0000
 #define	ARCHIVE_FORMAT_CPIO			0x10000
@@ -368,21 +440,49 @@ extern const char	*archive_error_string(struct archive *);
 #define	ARCHIVE_FORMAT_CAB			0xC0000
 #define	ARCHIVE_FORMAT_RAR			0xD0000
 #define	ARCHIVE_FORMAT_7ZIP			0xE0000
+#define	ARCHIVE_FORMAT_WARC			0xF0000
 
+/* Default: Do not try to set owner/group. */
 #define	ARCHIVE_EXTRACT_OWNER			(0x0001)
+/* Default: Do obey umask, do not restore SUID/SGID/SVTX bits. */
 #define	ARCHIVE_EXTRACT_PERM			(0x0002)
+/* Default: Do not restore mtime/atime. */
 #define	ARCHIVE_EXTRACT_TIME			(0x0004)
+/* Default: Replace existing files. */
 #define	ARCHIVE_EXTRACT_NO_OVERWRITE 		(0x0008)
+/* Default: Try create first, unlink only if create fails with EEXIST. */
 #define	ARCHIVE_EXTRACT_UNLINK			(0x0010)
+/* Default: Do not restore ACLs. */
 #define	ARCHIVE_EXTRACT_ACL			(0x0020)
+/* Default: Do not restore fflags. */
 #define	ARCHIVE_EXTRACT_FFLAGS			(0x0040)
+/* Default: Do not restore xattrs. */
 #define	ARCHIVE_EXTRACT_XATTR 			(0x0080)
+/* Default: Do not try to guard against extracts redirected by symlinks. */
+/* Note: With ARCHIVE_EXTRACT_UNLINK, will remove any intermediate symlink. */
 #define	ARCHIVE_EXTRACT_SECURE_SYMLINKS		(0x0100)
+/* Default: Do not reject entries with '..' as path elements. */
 #define	ARCHIVE_EXTRACT_SECURE_NODOTDOT		(0x0200)
+/* Default: Create parent directories as needed. */
 #define	ARCHIVE_EXTRACT_NO_AUTODIR		(0x0400)
+/* Default: Overwrite files, even if one on disk is newer. */
 #define	ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER	(0x0800)
+/* Detect blocks of 0 and write holes instead. */
 #define	ARCHIVE_EXTRACT_SPARSE			(0x1000)
+/* Default: Do not restore Mac extended metadata. */
+/* This has no effect except on Mac OS. */
 #define	ARCHIVE_EXTRACT_MAC_METADATA		(0x2000)
+/* Default: Use HFS+ compression if it was compressed. */
+/* This has no effect except on Mac OS v10.6 or later. */
+#define	ARCHIVE_EXTRACT_NO_HFS_COMPRESSION	(0x4000)
+/* Default: Do not use HFS+ compression if it was not compressed. */
+/* This has no effect except on Mac OS v10.6 or later. */
+#define	ARCHIVE_EXTRACT_HFS_COMPRESSION_FORCED	(0x8000)
+/* Default: Do not reject entries with absolute paths */
+#define ARCHIVE_EXTRACT_SECURE_NOABSOLUTEPATHS (0x10000)
+/* Default: Do not clear no-change flags when unlinking object */
+#define	ARCHIVE_EXTRACT_CLEAR_NOCHANGE_FFLAGS	(0x20000)
+
 
 %inline %{
 PyObject *archive_read_data_into_str(struct archive *archive, int len) {
diff --git a/libarchive/_libarchive.py b/libarchive/_libarchive.py
index bff869a..36aadd7 100644
--- a/libarchive/_libarchive.py
+++ b/libarchive/_libarchive.py
@@ -95,12 +95,63 @@ def archive_entry_stat(arg1):
 def archive_read_header_position(arg1):
     return __libarchive.archive_read_header_position(arg1)
 
+def archive_read_set_format_option(_a, m, o, v):
+    return __libarchive.archive_read_set_format_option(_a, m, o, v)
+
+def archive_read_set_filter_option(_a, m, o, v):
+    return __libarchive.archive_read_set_filter_option(_a, m, o, v)
+
+def archive_read_set_option(_a, m, o, v):
+    return __libarchive.archive_read_set_option(_a, m, o, v)
+
+def archive_read_set_options(_a, opts):
+    return __libarchive.archive_read_set_options(_a, opts)
+
+def archive_read_add_passphrase(arg1, arg2):
+    return __libarchive.archive_read_add_passphrase(arg1, arg2)
+
 def archive_read_data_skip(arg1):
     return __libarchive.archive_read_data_skip(arg1)
 
 def archive_read_data_into_fd(arg1, fd):
     return __libarchive.archive_read_data_into_fd(arg1, fd)
 
+def archive_read_support_compression_all(arg1):
+    return __libarchive.archive_read_support_compression_all(arg1)
+
+def archive_read_support_compression_bzip2(arg1):
+    return __libarchive.archive_read_support_compression_bzip2(arg1)
+
+def archive_read_support_compression_compress(arg1):
+    return __libarchive.archive_read_support_compression_compress(arg1)
+
+def archive_read_support_compression_gzip(arg1):
+    return __libarchive.archive_read_support_compression_gzip(arg1)
+
+def archive_read_support_compression_lzip(arg1):
+    return __libarchive.archive_read_support_compression_lzip(arg1)
+
+def archive_read_support_compression_lzma(arg1):
+    return __libarchive.archive_read_support_compression_lzma(arg1)
+
+def archive_read_support_compression_none(arg1):
+    return __libarchive.archive_read_support_compression_none(arg1)
+
+def archive_read_support_compression_program(arg1, command):
+    return __libarchive.archive_read_support_compression_program(arg1, command)
+
+def archive_read_support_compression_program_signature(arg1, arg2, arg3, arg4):
+    return __libarchive.archive_read_support_compression_program_signature(arg1, arg2, arg3, arg4)
+
+def archive_read_support_compression_rpm(arg1):
+    return __libarchive.archive_read_support_compression_rpm(arg1)
+
+def archive_read_support_compression_uu(arg1):
+    return __libarchive.archive_read_support_compression_uu(arg1)
+
+def archive_read_support_compression_xz(arg1):
+    return __libarchive.archive_read_support_compression_xz(arg1)
+
 def archive_read_support_filter_all(arg1):
     return __libarchive.archive_read_support_filter_all(arg1)
 
@@ -113,15 +164,33 @@ def archive_read_support_filter_compress(arg1):
 def archive_read_support_filter_gzip(arg1):
     return __libarchive.archive_read_support_filter_gzip(arg1)
 
+def archive_read_support_filter_grzip(arg1):
+    return __libarchive.archive_read_support_filter_grzip(arg1)
+
+def archive_read_support_filter_lrzip(arg1):
+    return __libarchive.archive_read_support_filter_lrzip(arg1)
+
+def archive_read_support_filter_lz4(arg1):
+    return __libarchive.archive_read_support_filter_lz4(arg1)
+
 def archive_read_support_filter_lzip(arg1):
     return __libarchive.archive_read_support_filter_lzip(arg1)
 
 def archive_read_support_filter_lzma(arg1):
     return __libarchive.archive_read_support_filter_lzma(arg1)
 
+def archive_read_support_filter_lzop(arg1):
+    return __libarchive.archive_read_support_filter_lzop(arg1)
+
 def archive_read_support_filter_none(arg1):
     return __libarchive.archive_read_support_filter_none(arg1)
 
+def archive_read_support_filter_program(arg1, command):
+    return __libarchive.archive_read_support_filter_program(arg1, command)
+
+def archive_read_support_filter_program_signature(arg1, arg2, arg3, arg4):
+    return __libarchive.archive_read_support_filter_program_signature(arg1, arg2, arg3, arg4)
+
 def archive_read_support_filter_rpm(arg1):
     return __libarchive.archive_read_support_filter_rpm(arg1)
 
@@ -131,15 +200,18 @@ def archive_read_support_filter_uu(arg1):
 def archive_read_support_filter_xz(arg1):
     return __libarchive.archive_read_support_filter_xz(arg1)
 
-def archive_read_support_format_all(arg1):
-    return __libarchive.archive_read_support_format_all(arg1)
-
 def archive_read_support_format_7zip(arg1):
     return __libarchive.archive_read_support_format_7zip(arg1)
 
+def archive_read_support_format_all(arg1):
+    return __libarchive.archive_read_support_format_all(arg1)
+
 def archive_read_support_format_ar(arg1):
     return __libarchive.archive_read_support_format_ar(arg1)
 
+def archive_read_support_format_by_code(arg1, arg2):
+    return __libarchive.archive_read_support_format_by_code(arg1, arg2)
+
 def archive_read_support_format_cab(arg1):
     return __libarchive.archive_read_support_format_cab(arg1)
 
@@ -167,12 +239,33 @@ def archive_read_support_format_raw(arg1):
 def archive_read_support_format_tar(arg1):
     return __libarchive.archive_read_support_format_tar(arg1)
 
+def archive_read_support_format_warc(arg1):
+    return __libarchive.archive_read_support_format_warc(arg1)
+
 def archive_read_support_format_xar(arg1):
     return __libarchive.archive_read_support_format_xar(arg1)
 
 def archive_read_support_format_zip(arg1):
     return __libarchive.archive_read_support_format_zip(arg1)
 
+def archive_read_support_format_zip_streamable(arg1):
+    return __libarchive.archive_read_support_format_zip_streamable(arg1)
+
+def archive_read_support_format_zip_seekable(arg1):
+    return __libarchive.archive_read_support_format_zip_seekable(arg1)
+
+def archive_read_set_format(arg1, arg2):
+    return __libarchive.archive_read_set_format(arg1, arg2)
+
+def archive_read_append_filter(arg1, arg2):
+    return __libarchive.archive_read_append_filter(arg1, arg2)
+
+def archive_read_append_filter_program(arg1, arg2):
+    return __libarchive.archive_read_append_filter_program(arg1, arg2)
+
+def archive_read_append_filter_program_signature(arg1, arg2, arg3, arg4):
+    return __libarchive.archive_read_append_filter_program_signature(arg1, arg2, arg3, arg4)
+
 def archive_write_new():
     return __libarchive.archive_write_new()
 
diff --git a/libarchive/_libarchive_wrap.c b/libarchive/_libarchive_wrap.c
index def83ec..aa9555a 100644
--- a/libarchive/_libarchive_wrap.c
+++ b/libarchive/_libarchive_wrap.c
@@ -3316,14 +3316,14 @@ SWIGINTERN PyObject *_wrap_archive_read_open_memory(PyObject *SWIGUNUSEDPARM(sel
   arg1 = (struct archive *)(argp1);
   res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_open_memory" "', argument " "2"" of type '" "void *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_open_memory" "', argument " "2"" of type '" "void const *""'"); 
   }
   ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
   if (!SWIG_IsOK(ecode3)) {
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "archive_read_open_memory" "', argument " "3"" of type '" "size_t""'");
   } 
   arg3 = (size_t)(val3);
-  result = (int)archive_read_open_memory(arg1,arg2,arg3);
+  result = (int)archive_read_open_memory(arg1,(void const *)arg2,arg3);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3355,7 +3355,7 @@ SWIGINTERN PyObject *_wrap_archive_read_open_memory2(PyObject *SWIGUNUSEDPARM(se
   arg1 = (struct archive *)(argp1);
   res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_open_memory2" "', argument " "2"" of type '" "void *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_open_memory2" "', argument " "2"" of type '" "void const *""'"); 
   }
   ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
   if (!SWIG_IsOK(ecode3)) {
@@ -3367,7 +3367,7 @@ SWIGINTERN PyObject *_wrap_archive_read_open_memory2(PyObject *SWIGUNUSEDPARM(se
     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "archive_read_open_memory2" "', argument " "4"" of type '" "size_t""'");
   } 
   arg4 = (size_t)(val4);
-  result = (int)archive_read_open_memory2(arg1,arg2,arg3,arg4);
+  result = (int)archive_read_open_memory2(arg1,(void const *)arg2,arg3,arg4);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3537,60 +3537,934 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_archive_read_set_format_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  int res4 ;
+  char *buf4 = 0 ;
+  int alloc4 = 0 ;
+  PyObject *swig_obj[4] ;
+  int result;
+  
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_set_format_option", 4, 4, swig_obj)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_set_format_option" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_set_format_option" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = (char *)(buf2);
+  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "archive_read_set_format_option" "', argument " "3"" of type '" "char const *""'");
+  }
+  arg3 = (char *)(buf3);
+  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "archive_read_set_format_option" "', argument " "4"" of type '" "char const *""'");
+  }
+  arg4 = (char *)(buf4);
+  result = (int)archive_read_set_format_option(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
+  resultobj = SWIG_From_int((int)(result));
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_set_filter_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  int res4 ;
+  char *buf4 = 0 ;
+  int alloc4 = 0 ;
+  PyObject *swig_obj[4] ;
+  int result;
+  
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_set_filter_option", 4, 4, swig_obj)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_set_filter_option" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_set_filter_option" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = (char *)(buf2);
+  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "archive_read_set_filter_option" "', argument " "3"" of type '" "char const *""'");
+  }
+  arg3 = (char *)(buf3);
+  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "archive_read_set_filter_option" "', argument " "4"" of type '" "char const *""'");
+  }
+  arg4 = (char *)(buf4);
+  result = (int)archive_read_set_filter_option(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
+  resultobj = SWIG_From_int((int)(result));
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_set_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  int res4 ;
+  char *buf4 = 0 ;
+  int alloc4 = 0 ;
+  PyObject *swig_obj[4] ;
+  int result;
+  
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_set_option", 4, 4, swig_obj)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_set_option" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_set_option" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = (char *)(buf2);
+  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "archive_read_set_option" "', argument " "3"" of type '" "char const *""'");
+  }
+  arg3 = (char *)(buf3);
+  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "archive_read_set_option" "', argument " "4"" of type '" "char const *""'");
+  }
+  arg4 = (char *)(buf4);
+  result = (int)archive_read_set_option(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
+  resultobj = SWIG_From_int((int)(result));
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
+  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_set_options(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  char *arg2 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  PyObject *swig_obj[2] ;
+  int result;
+  
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_set_options", 2, 2, swig_obj)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_set_options" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_set_options" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = (char *)(buf2);
+  result = (int)archive_read_set_options(arg1,(char const *)arg2);
+  resultobj = SWIG_From_int((int)(result));
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_add_passphrase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  char *arg2 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  PyObject *swig_obj[2] ;
+  int result;
+  
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_add_passphrase", 2, 2, swig_obj)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_add_passphrase" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_add_passphrase" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = (char *)(buf2);
+  result = (int)archive_read_add_passphrase(arg1,(char const *)arg2);
+  resultobj = SWIG_From_int((int)(result));
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_archive_read_data_skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  PyObject *swig_obj[1] ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_data_skip" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_data_skip(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_data_into_fd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject *swig_obj[2] ;
+  int result;
+  
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_data_into_fd", 2, 2, swig_obj)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_data_into_fd" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "archive_read_data_into_fd" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = (int)(val2);
+  result = (int)archive_read_data_into_fd(arg1,arg2);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_compression_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_compression_all" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_compression_all(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_compression_bzip2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_compression_bzip2" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_compression_bzip2(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_compression_compress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_compression_compress" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_compression_compress(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_compression_gzip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_compression_gzip" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_compression_gzip(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_compression_lzip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_compression_lzip" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_compression_lzip(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_compression_lzma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_compression_lzma" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_compression_lzma(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_compression_none(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_compression_none" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_compression_none(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_compression_program(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  char *arg2 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  PyObject *swig_obj[2] ;
+  int result;
+  
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_support_compression_program", 2, 2, swig_obj)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_compression_program" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_support_compression_program" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = (char *)(buf2);
+  result = (int)archive_read_support_compression_program(arg1,(char const *)arg2);
+  resultobj = SWIG_From_int((int)(result));
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_compression_program_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  char *arg2 = (char *) 0 ;
+  void *arg3 = (void *) 0 ;
+  size_t arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int res3 ;
+  size_t val4 ;
+  int ecode4 = 0 ;
+  PyObject *swig_obj[4] ;
+  int result;
+  
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_support_compression_program_signature", 4, 4, swig_obj)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_compression_program_signature" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_support_compression_program_signature" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = (char *)(buf2);
+  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "archive_read_support_compression_program_signature" "', argument " "3"" of type '" "void const *""'"); 
+  }
+  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "archive_read_support_compression_program_signature" "', argument " "4"" of type '" "size_t""'");
+  } 
+  arg4 = (size_t)(val4);
+  result = (int)archive_read_support_compression_program_signature(arg1,(char const *)arg2,(void const *)arg3,arg4);
+  resultobj = SWIG_From_int((int)(result));
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_compression_rpm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_compression_rpm" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_compression_rpm(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_compression_uu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_compression_uu" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_compression_uu(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_compression_xz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_compression_xz" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_compression_xz(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_all" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_filter_all(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_bzip2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_bzip2" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_filter_bzip2(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_compress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_compress" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_filter_compress(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_gzip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_gzip" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_filter_gzip(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_grzip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_grzip" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_filter_grzip(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_lrzip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_lrzip" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_filter_lrzip(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_lz4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_lz4" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_filter_lz4(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_lzip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_lzip" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_filter_lzip(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_lzma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_lzma" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_filter_lzma(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_lzop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_lzop" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_filter_lzop(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_none(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject *swig_obj[1] ;
+  int result;
+  
+  if (!args) SWIG_fail;
+  swig_obj[0] = args;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_none" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  result = (int)archive_read_support_filter_none(arg1);
+  resultobj = SWIG_From_int((int)(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_program(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  char *arg2 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  PyObject *swig_obj[2] ;
   int result;
   
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_support_filter_program", 2, 2, swig_obj)) SWIG_fail;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_data_skip" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_program" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_data_skip(arg1);
+  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_support_filter_program" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = (char *)(buf2);
+  result = (int)archive_read_support_filter_program(arg1,(char const *)arg2);
   resultobj = SWIG_From_int((int)(result));
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
 fail:
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_data_into_fd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_program_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
-  int arg2 ;
+  char *arg2 = (char *) 0 ;
+  void *arg3 = (void *) 0 ;
+  size_t arg4 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  int val2 ;
-  int ecode2 = 0 ;
-  PyObject *swig_obj[2] ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int res3 ;
+  size_t val4 ;
+  int ecode4 = 0 ;
+  PyObject *swig_obj[4] ;
   int result;
   
-  if (!SWIG_Python_UnpackTuple(args, "archive_read_data_into_fd", 2, 2, swig_obj)) SWIG_fail;
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_support_filter_program_signature", 4, 4, swig_obj)) SWIG_fail;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_data_into_fd" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_program_signature" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "archive_read_data_into_fd" "', argument " "2"" of type '" "int""'");
+  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_support_filter_program_signature" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = (char *)(buf2);
+  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "archive_read_support_filter_program_signature" "', argument " "3"" of type '" "void const *""'"); 
+  }
+  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "archive_read_support_filter_program_signature" "', argument " "4"" of type '" "size_t""'");
   } 
-  arg2 = (int)(val2);
-  result = (int)archive_read_data_into_fd(arg1,arg2);
+  arg4 = (size_t)(val4);
+  result = (int)archive_read_support_filter_program_signature(arg1,(char const *)arg2,(void const *)arg3,arg4);
   resultobj = SWIG_From_int((int)(result));
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
 fail:
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_filter_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_rpm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3602,10 +4476,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_filter_all(PyObject *SWIGUNUSEDP
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_all" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_rpm" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_filter_all(arg1);
+  result = (int)archive_read_support_filter_rpm(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3613,7 +4487,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_filter_bzip2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_uu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3625,10 +4499,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_filter_bzip2(PyObject *SWIGUNUSE
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_bzip2" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_uu" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_filter_bzip2(arg1);
+  result = (int)archive_read_support_filter_uu(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3636,7 +4510,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_filter_compress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_filter_xz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3648,10 +4522,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_filter_compress(PyObject *SWIGUN
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_compress" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_xz" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_filter_compress(arg1);
+  result = (int)archive_read_support_filter_xz(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3659,7 +4533,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_filter_gzip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_7zip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3671,10 +4545,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_filter_gzip(PyObject *SWIGUNUSED
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_gzip" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_7zip" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_filter_gzip(arg1);
+  result = (int)archive_read_support_format_7zip(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3682,7 +4556,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_filter_lzip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3694,10 +4568,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_filter_lzip(PyObject *SWIGUNUSED
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_lzip" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_all" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_filter_lzip(arg1);
+  result = (int)archive_read_support_format_all(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3705,7 +4579,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_filter_lzma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_ar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3717,10 +4591,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_filter_lzma(PyObject *SWIGUNUSED
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_lzma" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_ar" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_filter_lzma(arg1);
+  result = (int)archive_read_support_format_ar(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3728,22 +4602,29 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_filter_none(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_by_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
+  int arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  PyObject *swig_obj[1] ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject *swig_obj[2] ;
   int result;
   
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_support_format_by_code", 2, 2, swig_obj)) SWIG_fail;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_none" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_by_code" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_filter_none(arg1);
+  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "archive_read_support_format_by_code" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = (int)(val2);
+  result = (int)archive_read_support_format_by_code(arg1,arg2);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3751,7 +4632,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_filter_rpm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_cab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3763,10 +4644,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_filter_rpm(PyObject *SWIGUNUSEDP
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_rpm" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_cab" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_filter_rpm(arg1);
+  result = (int)archive_read_support_format_cab(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3774,7 +4655,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_filter_uu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_cpio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3786,10 +4667,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_filter_uu(PyObject *SWIGUNUSEDPA
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_uu" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_cpio" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_filter_uu(arg1);
+  result = (int)archive_read_support_format_cpio(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3797,7 +4678,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_filter_xz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3809,10 +4690,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_filter_xz(PyObject *SWIGUNUSEDPA
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_filter_xz" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_empty" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_filter_xz(arg1);
+  result = (int)archive_read_support_format_empty(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3820,7 +4701,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_gnutar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3832,10 +4713,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_format_all(PyObject *SWIGUNUSEDP
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_all" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_gnutar" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_all(arg1);
+  result = (int)archive_read_support_format_gnutar(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3843,7 +4724,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_7zip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_iso9660(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3855,10 +4736,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_format_7zip(PyObject *SWIGUNUSED
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_7zip" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_iso9660" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_7zip(arg1);
+  result = (int)archive_read_support_format_iso9660(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3866,7 +4747,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_ar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_lha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3878,10 +4759,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_format_ar(PyObject *SWIGUNUSEDPA
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_ar" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_lha" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_ar(arg1);
+  result = (int)archive_read_support_format_lha(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3889,7 +4770,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_cab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_rar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3901,10 +4782,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_format_cab(PyObject *SWIGUNUSEDP
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_cab" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_rar" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_cab(arg1);
+  result = (int)archive_read_support_format_rar(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3912,7 +4793,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_cpio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3924,10 +4805,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_format_cpio(PyObject *SWIGUNUSED
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_cpio" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_raw" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_cpio(arg1);
+  result = (int)archive_read_support_format_raw(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3935,7 +4816,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_tar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3947,10 +4828,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_format_empty(PyObject *SWIGUNUSE
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_empty" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_tar" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_empty(arg1);
+  result = (int)archive_read_support_format_tar(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3958,7 +4839,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_gnutar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_warc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3970,10 +4851,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_format_gnutar(PyObject *SWIGUNUS
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_gnutar" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_warc" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_gnutar(arg1);
+  result = (int)archive_read_support_format_warc(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -3981,7 +4862,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_iso9660(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_xar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -3993,10 +4874,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_format_iso9660(PyObject *SWIGUNU
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_iso9660" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_xar" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_iso9660(arg1);
+  result = (int)archive_read_support_format_xar(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -4004,7 +4885,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_lha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_zip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -4016,10 +4897,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_format_lha(PyObject *SWIGUNUSEDP
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_lha" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_zip" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_lha(arg1);
+  result = (int)archive_read_support_format_zip(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -4027,7 +4908,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_rar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_zip_streamable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -4039,10 +4920,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_format_rar(PyObject *SWIGUNUSEDP
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_rar" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_zip_streamable" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_rar(arg1);
+  result = (int)archive_read_support_format_zip_streamable(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -4050,7 +4931,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_raw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_support_format_zip_seekable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
   void *argp1 = 0 ;
@@ -4062,10 +4943,10 @@ SWIGINTERN PyObject *_wrap_archive_read_support_format_raw(PyObject *SWIGUNUSEDP
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_raw" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_zip_seekable" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_raw(arg1);
+  result = (int)archive_read_support_format_zip_seekable(arg1);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -4073,22 +4954,29 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_tar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_set_format(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
+  int arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  PyObject *swig_obj[1] ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject *swig_obj[2] ;
   int result;
   
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_set_format", 2, 2, swig_obj)) SWIG_fail;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_tar" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_set_format" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_tar(arg1);
+  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "archive_read_set_format" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = (int)(val2);
+  result = (int)archive_read_set_format(arg1,arg2);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -4096,22 +4984,29 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_xar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_append_filter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
+  int arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  PyObject *swig_obj[1] ;
+  int val2 ;
+  int ecode2 = 0 ;
+  PyObject *swig_obj[2] ;
   int result;
   
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_append_filter", 2, 2, swig_obj)) SWIG_fail;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_xar" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_append_filter" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_xar(arg1);
+  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "archive_read_append_filter" "', argument " "2"" of type '" "int""'");
+  } 
+  arg2 = (int)(val2);
+  result = (int)archive_read_append_filter(arg1,arg2);
   resultobj = SWIG_From_int((int)(result));
   return resultobj;
 fail:
@@ -4119,25 +5014,82 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_archive_read_support_format_zip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_archive_read_append_filter_program(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   struct archive *arg1 = (struct archive *) 0 ;
+  char *arg2 = (char *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  PyObject *swig_obj[1] ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  PyObject *swig_obj[2] ;
   int result;
   
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_append_filter_program", 2, 2, swig_obj)) SWIG_fail;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_support_format_zip" "', argument " "1"" of type '" "struct archive *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_append_filter_program" "', argument " "1"" of type '" "struct archive *""'"); 
   }
   arg1 = (struct archive *)(argp1);
-  result = (int)archive_read_support_format_zip(arg1);
+  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_append_filter_program" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = (char *)(buf2);
+  result = (int)archive_read_append_filter_program(arg1,(char const *)arg2);
+  resultobj = SWIG_From_int((int)(result));
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return resultobj;
+fail:
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_archive_read_append_filter_program_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  struct archive *arg1 = (struct archive *) 0 ;
+  char *arg2 = (char *) 0 ;
+  void *arg3 = (void *) 0 ;
+  size_t arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  int res3 ;
+  size_t val4 ;
+  int ecode4 = 0 ;
+  PyObject *swig_obj[4] ;
+  int result;
+  
+  if (!SWIG_Python_UnpackTuple(args, "archive_read_append_filter_program_signature", 4, 4, swig_obj)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_archive, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "archive_read_append_filter_program_signature" "', argument " "1"" of type '" "struct archive *""'"); 
+  }
+  arg1 = (struct archive *)(argp1);
+  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "archive_read_append_filter_program_signature" "', argument " "2"" of type '" "char const *""'");
+  }
+  arg2 = (char *)(buf2);
+  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "archive_read_append_filter_program_signature" "', argument " "3"" of type '" "void const *""'"); 
+  }
+  ecode4 = SWIG_AsVal_size_t(swig_obj[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "archive_read_append_filter_program_signature" "', argument " "4"" of type '" "size_t""'");
+  } 
+  arg4 = (size_t)(val4);
+  result = (int)archive_read_append_filter_program_signature(arg1,(char const *)arg2,(void const *)arg3,arg4);
   resultobj = SWIG_From_int((int)(result));
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return resultobj;
 fail:
+  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
   return NULL;
 }
 
@@ -5662,21 +6614,45 @@ static PyMethodDef SwigMethods[] = {
 	 { "archive_read_next_header2", _wrap_archive_read_next_header2, METH_VARARGS, NULL},
 	 { "archive_entry_stat", _wrap_archive_entry_stat, METH_O, NULL},
 	 { "archive_read_header_position", _wrap_archive_read_header_position, METH_O, NULL},
+	 { "archive_read_set_format_option", _wrap_archive_read_set_format_option, METH_VARARGS, NULL},
+	 { "archive_read_set_filter_option", _wrap_archive_read_set_filter_option, METH_VARARGS, NULL},
+	 { "archive_read_set_option", _wrap_archive_read_set_option, METH_VARARGS, NULL},
+	 { "archive_read_set_options", _wrap_archive_read_set_options, METH_VARARGS, NULL},
+	 { "archive_read_add_passphrase", _wrap_archive_read_add_passphrase, METH_VARARGS, NULL},
 	 { "archive_read_data_skip", _wrap_archive_read_data_skip, METH_O, NULL},
 	 { "archive_read_data_into_fd", _wrap_archive_read_data_into_fd, METH_VARARGS, NULL},
+	 { "archive_read_support_compression_all", _wrap_archive_read_support_compression_all, METH_O, NULL},
+	 { "archive_read_support_compression_bzip2", _wrap_archive_read_support_compression_bzip2, METH_O, NULL},
+	 { "archive_read_support_compression_compress", _wrap_archive_read_support_compression_compress, METH_O, NULL},
+	 { "archive_read_support_compression_gzip", _wrap_archive_read_support_compression_gzip, METH_O, NULL},
+	 { "archive_read_support_compression_lzip", _wrap_archive_read_support_compression_lzip, METH_O, NULL},
+	 { "archive_read_support_compression_lzma", _wrap_archive_read_support_compression_lzma, METH_O, NULL},
+	 { "archive_read_support_compression_none", _wrap_archive_read_support_compression_none, METH_O, NULL},
+	 { "archive_read_support_compression_program", _wrap_archive_read_support_compression_program, METH_VARARGS, NULL},
+	 { "archive_read_support_compression_program_signature", _wrap_archive_read_support_compression_program_signature, METH_VARARGS, NULL},
+	 { "archive_read_support_compression_rpm", _wrap_archive_read_support_compression_rpm, METH_O, NULL},
+	 { "archive_read_support_compression_uu", _wrap_archive_read_support_compression_uu, METH_O, NULL},
+	 { "archive_read_support_compression_xz", _wrap_archive_read_support_compression_xz, METH_O, NULL},
 	 { "archive_read_support_filter_all", _wrap_archive_read_support_filter_all, METH_O, NULL},
 	 { "archive_read_support_filter_bzip2", _wrap_archive_read_support_filter_bzip2, METH_O, NULL},
 	 { "archive_read_support_filter_compress", _wrap_archive_read_support_filter_compress, METH_O, NULL},
 	 { "archive_read_support_filter_gzip", _wrap_archive_read_support_filter_gzip, METH_O, NULL},
+	 { "archive_read_support_filter_grzip", _wrap_archive_read_support_filter_grzip, METH_O, NULL},
+	 { "archive_read_support_filter_lrzip", _wrap_archive_read_support_filter_lrzip, METH_O, NULL},
+	 { "archive_read_support_filter_lz4", _wrap_archive_read_support_filter_lz4, METH_O, NULL},
 	 { "archive_read_support_filter_lzip", _wrap_archive_read_support_filter_lzip, METH_O, NULL},
 	 { "archive_read_support_filter_lzma", _wrap_archive_read_support_filter_lzma, METH_O, NULL},
+	 { "archive_read_support_filter_lzop", _wrap_archive_read_support_filter_lzop, METH_O, NULL},
 	 { "archive_read_support_filter_none", _wrap_archive_read_support_filter_none, METH_O, NULL},
+	 { "archive_read_support_filter_program", _wrap_archive_read_support_filter_program, METH_VARARGS, NULL},
+	 { "archive_read_support_filter_program_signature", _wrap_archive_read_support_filter_program_signature, METH_VARARGS, NULL},
 	 { "archive_read_support_filter_rpm", _wrap_archive_read_support_filter_rpm, METH_O, NULL},
 	 { "archive_read_support_filter_uu", _wrap_archive_read_support_filter_uu, METH_O, NULL},
 	 { "archive_read_support_filter_xz", _wrap_archive_read_support_filter_xz, METH_O, NULL},
-	 { "archive_read_support_format_all", _wrap_archive_read_support_format_all, METH_O, NULL},
 	 { "archive_read_support_format_7zip", _wrap_archive_read_support_format_7zip, METH_O, NULL},
+	 { "archive_read_support_format_all", _wrap_archive_read_support_format_all, METH_O, NULL},
 	 { "archive_read_support_format_ar", _wrap_archive_read_support_format_ar, METH_O, NULL},
+	 { "archive_read_support_format_by_code", _wrap_archive_read_support_format_by_code, METH_VARARGS, NULL},
 	 { "archive_read_support_format_cab", _wrap_archive_read_support_format_cab, METH_O, NULL},
 	 { "archive_read_support_format_cpio", _wrap_archive_read_support_format_cpio, METH_O, NULL},
 	 { "archive_read_support_format_empty", _wrap_archive_read_support_format_empty, METH_O, NULL},
@@ -5686,8 +6662,15 @@ static PyMethodDef SwigMethods[] = {
 	 { "archive_read_support_format_rar", _wrap_archive_read_support_format_rar, METH_O, NULL},
 	 { "archive_read_support_format_raw", _wrap_archive_read_support_format_raw, METH_O, NULL},
 	 { "archive_read_support_format_tar", _wrap_archive_read_support_format_tar, METH_O, NULL},
+	 { "archive_read_support_format_warc", _wrap_archive_read_support_format_warc, METH_O, NULL},
 	 { "archive_read_support_format_xar", _wrap_archive_read_support_format_xar, METH_O, NULL},
 	 { "archive_read_support_format_zip", _wrap_archive_read_support_format_zip, METH_O, NULL},
+	 { "archive_read_support_format_zip_streamable", _wrap_archive_read_support_format_zip_streamable, METH_O, NULL},
+	 { "archive_read_support_format_zip_seekable", _wrap_archive_read_support_format_zip_seekable, METH_O, NULL},
+	 { "archive_read_set_format", _wrap_archive_read_set_format, METH_VARARGS, NULL},
+	 { "archive_read_append_filter", _wrap_archive_read_append_filter, METH_VARARGS, NULL},
+	 { "archive_read_append_filter_program", _wrap_archive_read_append_filter_program, METH_VARARGS, NULL},
+	 { "archive_read_append_filter_program_signature", _wrap_archive_read_append_filter_program_signature, METH_VARARGS, NULL},
 	 { "archive_write_new", _wrap_archive_write_new, METH_NOARGS, NULL},
 	 { "archive_write_free", _wrap_archive_write_free, METH_O, NULL},
 	 { "archive_write_open", _wrap_archive_write_open, METH_VARARGS, NULL},