Open a door to changing the current abort-on-state-failure behavior:

 * Change __archive_check_magic to return a status code.
 * Change callers to use the archive_check_magic() wrapper macro,
   which calls __archive_check_magic and returns immediately
   if there's an ARCHIVE_FATAL status.
 * Update a bunch of API calls to actually do magic state checks.

I've also changed __archive_check_magic around a little bit:
 * Magic number checks still call abort().
 * State failures still call abort()
 * Starting with libarchive 3.0, state failures will return ARCHIVE_FATAL.

SVN-Revision: 2003

diff --git a/libarchive/archive.h b/libarchive/archive.h
index 5fcb688d67cdd880251a910e4ed175c16472034e..935a8a005bf34fdf0ec7f2270237d72e1fb77b05 100644 (file)
--- a/libarchive/archive.h
+++ b/libarchive/archive.h
@@ -138,13 +138,14 @@ extern "C" {
  *             (ARCHIVE_API_VERSION * 1000000 + ARCHIVE_API_FEATURE * 1000)
  * #endif
  */
-#define        ARCHIVE_VERSION_NUMBER 3000000
+/* Note: Compiler will complain if this does not match archive_entry.h! */
+#define        ARCHIVE_VERSION_NUMBER 2008900
 __LA_DECL int          archive_version_number(void);
 
 /*
  * Textual name/version of the library, useful for version displays.
  */
-#define        ARCHIVE_VERSION_STRING "libarchive 3.0.0a"
+#define        ARCHIVE_VERSION_STRING "libarchive 2.8.900a"
 __LA_DECL const char * archive_version_string(void);
 
 #if ARCHIVE_VERSION_NUMBER < 3000000

diff --git a/libarchive/archive_check_magic.c b/libarchive/archive_check_magic.c
index e27e5d827089fde73c22214c6ad9a00c5e8ffa5f..3b6888b8894c3562ac3e048a0980b331ff516e7e 100644 (file)
--- a/libarchive/archive_check_magic.c
+++ b/libarchive/archive_check_magic.c
@@ -1,5 +1,5 @@
 /*-
- * Copyright (c) 2003-2007 Tim Kientzle
+ * Copyright (c) 2003-2010 Tim Kientzle
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -87,48 +87,65 @@ state_name(unsigned s)
 }
 
 
-static void
-write_all_states(unsigned int states)
+static char *
+write_all_states(char *buff, unsigned int states)
 {
        unsigned int lowbit;
 
+       buff[0] = '\0';
+
        /* A trick for computing the lowest set bit. */
        while ((lowbit = states & (1 + ~states)) != 0) {
                states &= ~lowbit;              /* Clear the low bit. */
-               errmsg(state_name(lowbit));
+               strcat(buff, state_name(lowbit));
                if (states != 0)
-                       errmsg("/");
+                       strcat(buff, "/");
        }
+       return buff;
 }
 
 /*
- * Check magic value and current state; bail if it isn't valid.
+ * Check magic value and current state.
+ *   Magic value mismatches are fatal and result in calls to abort().
+ *   State mismatches return ARCHIVE_FATAL.
+ *   Otherwise, returns ARCHIVE_OK.
  *
  * This is designed to catch serious programming errors that violate
  * the libarchive API.
  */
-void
+int
 __archive_check_magic(struct archive *a, unsigned int magic,
     unsigned int state, const char *function)
 {
+       char states1[64];
+       char states2[64];
+
        if (a->magic != magic) {
-               errmsg("INTERNAL ERROR: Function ");
+               errmsg("PROGRAMMER ERROR: Function ");
                errmsg(function);
-               errmsg(" invoked with invalid struct archive structure.\n");
+               errmsg(" invoked with invalid archive handle.\n");
                diediedie();
        }
 
-       if (state == ARCHIVE_STATE_ANY)
-               return;
-
        if ((a->state & state) == 0) {
-               errmsg("INTERNAL ERROR: Function '");
-               errmsg(function);
-               errmsg("' invoked with archive structure in state '");
-               write_all_states(a->state);
-               errmsg("', should be in state '");
-               write_all_states(state);
-               errmsg("'\n");
+               /* If we're already FATAL, don't overwrite the error. */
+               if (a->state != ARCHIVE_STATE_FATAL)
+                       archive_set_error(a, -1,
+                           "INTERNAL ERROR: Function '%s' invoked with"
+                           " archive structure in state '%s',"
+                           " should be in state '%s'",
+                           function,
+                           write_all_states(states1, a->state),
+                           write_all_states(states2, a->state));
+               a->state = ARCHIVE_STATE_FATAL;
+#if ARCHIVE_VERSION_NUMBER < 3000000
+               // XXXX This should be identical to the old behavior.
+               errmsg(archive_error_string(a));
                diediedie();
+#else
+               // XXXX This is the proposed new behavior.
+               return (ARCHIVE_FATAL);
+#endif
        }
+       return ARCHIVE_OK;
 }

diff --git a/libarchive/archive_entry.h b/libarchive/archive_entry.h
index 103878d261b2c9d10900e9dbe5bf8486e7bdf238..d23414cddc06ff8271e32e220e60dc7994467c6d 100644 (file)
--- a/libarchive/archive_entry.h
+++ b/libarchive/archive_entry.h
@@ -28,10 +28,8 @@
 #ifndef ARCHIVE_ENTRY_H_INCLUDED
 #define        ARCHIVE_ENTRY_H_INCLUDED
 
-/* Needed if archive_entry.h is used without archive.h */
-#ifndef ARCHIVE_VERSION_NUMBER
-#define        ARCHIVE_VERSION_NUMBER 3000000
-#endif
+/* Note: Compiler will complain if this does not match archive.h! */
+#define        ARCHIVE_VERSION_NUMBER 2008900
 
 /*
  * Note: archive_entry.h is for use outside of libarchive; the

diff --git a/libarchive/archive_private.h b/libarchive/archive_private.h
index df83b76992c12c7bc1ed786e01bfc8a52e7eb962..862eb032f191492e6c90c0d956a792bdf4938ae0 100644 (file)
--- a/libarchive/archive_private.h
+++ b/libarchive/archive_private.h
@@ -47,13 +47,13 @@
 #define        ARCHIVE_WRITE_DISK_MAGIC (0xc001b0c5U)
 #define        ARCHIVE_READ_DISK_MAGIC (0xbadb0c5U)
 
-#define        ARCHIVE_STATE_ANY       0xFFFFU
 #define        ARCHIVE_STATE_NEW       1U
 #define        ARCHIVE_STATE_HEADER    2U
 #define        ARCHIVE_STATE_DATA      4U
 #define        ARCHIVE_STATE_EOF       0x10U
 #define        ARCHIVE_STATE_CLOSED    0x20U
 #define        ARCHIVE_STATE_FATAL     0x8000U
+#define        ARCHIVE_STATE_ANY       (0xFFFFU & ~ARCHIVE_STATE_FATAL)
 
 struct archive_vtable {
        int     (*archive_close)(struct archive *);
@@ -102,9 +102,16 @@ struct archive {
        struct archive_string   error_string;
 };
 
-/* Check magic value and state; exit if it isn't valid. */
-void   __archive_check_magic(struct archive *, unsigned int magic,
+/* Check magic value and state; return(ARCHIVE_FATAL) if it isn't valid. */
+int    __archive_check_magic(struct archive *, unsigned int magic,
            unsigned int state, const char *func);
+#define        archive_check_magic(a, expected_magic, allowed_states, function_name) \
+       do { \
+               int magic_test = __archive_check_magic((a), (expected_magic), \
+                       (allowed_states), (function_name)); \
+               if (magic_test == ARCHIVE_FATAL) \
+                       return ARCHIVE_FATAL; \
+       } while (0)
 
 void   __archive_errx(int retvalue, const char *msg) __LA_DEAD;
 

diff --git a/libarchive/archive_read.c b/libarchive/archive_read.c
index 26d3a6e40994697a7ebfa5aa3022a38c60926954..5c99e08f76410148b7583d36db947c29a469d138 100644 (file)
--- a/libarchive/archive_read.c
+++ b/libarchive/archive_read.c
@@ -115,8 +115,11 @@ archive_read_extract_set_skip_file(struct archive *_a, int64_t d, int64_t i)
 #endif
 {
        struct archive_read *a = (struct archive_read *)_a;
-       __archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_ANY,
-           "archive_read_extract_set_skip_file");
+
+       if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+               ARCHIVE_STATE_ANY, "archive_read_extract_set_skip_file"))
+               return;
+
        a->skip_file_dev = d;
        a->skip_file_ino = i;
 }
@@ -134,14 +137,12 @@ archive_read_set_format_options(struct archive *_a, const char *s)
        size_t i;
        int len, r;
 
-       __archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
            "archive_read_set_format_options");
 
        if (s == NULL || *s == '\0')
                return (ARCHIVE_OK);
        a = (struct archive_read *)_a;
-       __archive_check_magic(&a->archive, ARCHIVE_READ_MAGIC,
-           ARCHIVE_STATE_NEW, "archive_read_set_format_options");
        len = 0;
        for (i = 0; i < sizeof(a->formats)/sizeof(a->formats[0]); i++) {
                format = &a->formats[i];
@@ -181,14 +182,12 @@ archive_read_set_filter_options(struct archive *_a, const char *s)
        char key[64], val[64];
        int len, r;
 
-       __archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
            "archive_read_set_filter_options");
 
        if (s == NULL || *s == '\0')
                return (ARCHIVE_OK);
        a = (struct archive_read *)_a;
-       __archive_check_magic(&a->archive, ARCHIVE_READ_MAGIC,
-           ARCHIVE_STATE_NEW, "archive_read_set_filter_options");
        len = 0;
        for (filter = a->filter; filter != NULL; filter = filter->upstream) {
                bidder = filter->bidder;
@@ -224,7 +223,7 @@ archive_read_set_options(struct archive *_a, const char *s)
 {
        int r;
 
-       __archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
            "archive_read_set_options");
        archive_clear_error(_a);
 
@@ -308,7 +307,7 @@ archive_read_open2(struct archive *_a, void *client_data,
        struct archive_read_filter *filter;
        int e;
 
-       __archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
            "archive_read_open");
        archive_clear_error(&a->archive);
 
@@ -424,7 +423,7 @@ archive_read_next_header2(struct archive *_a, struct archive_entry *entry)
        struct archive_read *a = (struct archive_read *)_a;
        int slot, ret;
 
-       __archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC,
            ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
            "archive_read_next_header");
 
@@ -562,7 +561,7 @@ int64_t
 archive_read_header_position(struct archive *_a)
 {
        struct archive_read *a = (struct archive_read *)_a;
-       __archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC,
            ARCHIVE_STATE_ANY, "archive_read_header_position");
        return (a->header_position);
 }
@@ -682,7 +681,7 @@ archive_read_data_skip(struct archive *_a)
        int64_t offset;
 #endif
 
-       __archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA,
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA,
            "archive_read_data_skip");
 
        if (a->format->read_data_skip != NULL)
@@ -720,7 +719,7 @@ archive_read_data_block(struct archive *_a,
 #endif
 {
        struct archive_read *a = (struct archive_read *)_a;
-       __archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA,
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA,
            "archive_read_data_block");
 
        if (a->format->read_data == NULL) {
@@ -772,10 +771,11 @@ _archive_read_close(struct archive *_a)
        struct archive_read *a = (struct archive_read *)_a;
        int r = ARCHIVE_OK, r1 = ARCHIVE_OK;
 
-       __archive_check_magic(&a->archive, ARCHIVE_READ_MAGIC,
-           ARCHIVE_STATE_ANY, "archive_read_close");
+       archive_check_magic(&a->archive, ARCHIVE_READ_MAGIC,
+           ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_close");
        archive_clear_error(&a->archive);
-       a->archive.state = ARCHIVE_STATE_CLOSED;
+       if (a->archive.state != ARCHIVE_STATE_FATAL)
+               a->archive.state = ARCHIVE_STATE_CLOSED;
 
        /* TODO: Clean up the formatters. */
 
@@ -798,9 +798,12 @@ _archive_read_free(struct archive *_a)
        int slots;
        int r = ARCHIVE_OK;
 
-       __archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_ANY,
-           "archive_read_free");
-       if (a->archive.state != ARCHIVE_STATE_CLOSED)
+       if (_a == NULL)
+               return (ARCHIVE_OK);
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+           ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_free");
+       if (a->archive.state != ARCHIVE_STATE_CLOSED
+           && a->archive.state != ARCHIVE_STATE_FATAL)
                r = archive_read_close(&a->archive);
 
        /* Call cleanup functions registered by optional components. */
@@ -893,7 +896,7 @@ __archive_read_register_format(struct archive_read *a,
 {
        int i, number_slots;
 
-       __archive_check_magic(&a->archive,
+       archive_check_magic(&a->archive,
            ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
            "__archive_read_register_format");
 
@@ -928,10 +931,6 @@ __archive_read_get_bidder(struct archive_read *a)
 {
        int i, number_slots;
 
-       __archive_check_magic(&a->archive,
-           ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
-           "__archive_read_get_bidder");
-
        number_slots = sizeof(a->bidders) / sizeof(a->bidders[0]);
 
        for (i = 0; i < number_slots; i++) {

diff --git a/libarchive/archive_read_data_into_fd.c b/libarchive/archive_read_data_into_fd.c
index 1ede6c61ee01d9a32451bbfd1d360cb41f8408c5..afe55a7734966930050e1737691056c7ce3ea648 100644 (file)
--- a/libarchive/archive_read_data_into_fd.c
+++ b/libarchive/archive_read_data_into_fd.c
@@ -59,7 +59,8 @@ archive_read_data_into_fd(struct archive *a, int fd)
 #endif
        off_t output_offset;
 
-       __archive_check_magic(a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA, "archive_read_data_into_fd");
+       archive_check_magic(a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA,
+           "archive_read_data_into_fd");
 
        total_written = 0;
        output_offset = 0;

diff --git a/libarchive/archive_read_disk.c b/libarchive/archive_read_disk.c
index 5fc0aee0ab1e3ab1bc9a2cd04a04dcf63fcf3467..ba03a38fdc85ef15b1dc6f7ff47d4c79afe10b6d 100644 (file)
--- a/libarchive/archive_read_disk.c
+++ b/libarchive/archive_read_disk.c
@@ -64,9 +64,12 @@ archive_read_disk_gname(struct archive *_a, int64_t gid)
 #endif
 {
        struct archive_read_disk *a = (struct archive_read_disk *)_a;
-       if (a->lookup_gname != NULL)
-               return ((*a->lookup_gname)(a->lookup_gname_data, gid));
-       return (NULL);
+       if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
+               ARCHIVE_STATE_ANY, "archive_read_disk_gname"))
+               return (NULL);
+       if (a->lookup_gname == NULL)
+               return (NULL);
+       return ((*a->lookup_gname)(a->lookup_gname_data, gid));
 }
 
 #if ARCHIVE_VERSION_NUMBER < 3000000
@@ -78,9 +81,12 @@ archive_read_disk_uname(struct archive *_a, int64_t uid)
 #endif
 {
        struct archive_read_disk *a = (struct archive_read_disk *)_a;
-       if (a->lookup_uname != NULL)
-               return ((*a->lookup_uname)(a->lookup_uname_data, uid));
-       return (NULL);
+       if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
+               ARCHIVE_STATE_ANY, "archive_read_disk_uname"))
+               return (NULL);
+       if (a->lookup_uname == NULL)
+               return (NULL);
+       return ((*a->lookup_uname)(a->lookup_uname_data, uid));
 }
 
 #if ARCHIVE_VERSION_NUMBER < 3000000
@@ -98,7 +104,7 @@ archive_read_disk_set_gname_lookup(struct archive *_a,
 #endif
 {
        struct archive_read_disk *a = (struct archive_read_disk *)_a;
-       __archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,
            ARCHIVE_STATE_ANY, "archive_read_disk_set_gname_lookup");
 
        if (a->cleanup_gname != NULL && a->lookup_gname_data != NULL)
@@ -125,7 +131,7 @@ archive_read_disk_set_uname_lookup(struct archive *_a,
 #endif
 {
        struct archive_read_disk *a = (struct archive_read_disk *)_a;
-       __archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_READ_DISK_MAGIC,
            ARCHIVE_STATE_ANY, "archive_read_disk_set_uname_lookup");
 
        if (a->cleanup_uname != NULL && a->lookup_uname_data != NULL)
@@ -163,11 +169,16 @@ _archive_read_free(struct archive *_a)
 {
        struct archive_read_disk *a = (struct archive_read_disk *)_a;
 
+       if (_a == NULL)
+               return (ARCHIVE_OK);
+       archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
+           ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_free");
        if (a->cleanup_gname != NULL && a->lookup_gname_data != NULL)
                (a->cleanup_gname)(a->lookup_gname_data);
        if (a->cleanup_uname != NULL && a->lookup_uname_data != NULL)
                (a->cleanup_uname)(a->lookup_uname_data);
        archive_string_free(&a->archive.error_string);
+       a->archive.magic = 0;
        free(a);
        return (ARCHIVE_OK);
 }
@@ -175,6 +186,8 @@ _archive_read_free(struct archive *_a)
 static int
 _archive_read_close(struct archive *_a)
 {
+       archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
+           ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_close");
        (void)_a; /* UNUSED */
        return (ARCHIVE_OK);
 }
@@ -183,6 +196,8 @@ int
 archive_read_disk_set_symlink_logical(struct archive *_a)
 {
        struct archive_read_disk *a = (struct archive_read_disk *)_a;
+       archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
+           ARCHIVE_STATE_ANY, "archive_read_disk_set_symlink_logical");
        a->symlink_mode = 'L';
        a->follow_symlinks = 1;
        return (ARCHIVE_OK);
@@ -192,6 +207,8 @@ int
 archive_read_disk_set_symlink_physical(struct archive *_a)
 {
        struct archive_read_disk *a = (struct archive_read_disk *)_a;
+       archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
+           ARCHIVE_STATE_ANY, "archive_read_disk_set_symlink_physical");
        a->symlink_mode = 'P';
        a->follow_symlinks = 0;
        return (ARCHIVE_OK);
@@ -201,6 +218,8 @@ int
 archive_read_disk_set_symlink_hybrid(struct archive *_a)
 {
        struct archive_read_disk *a = (struct archive_read_disk *)_a;
+       archive_check_magic(_a, ARCHIVE_READ_DISK_MAGIC,
+           ARCHIVE_STATE_ANY, "archive_read_disk_set_symlink_hybrid");
        a->symlink_mode = 'H';
        a->follow_symlinks = 1; /* Follow symlinks initially. */
        return (ARCHIVE_OK);

diff --git a/libarchive/archive_read_support_format_ar.c b/libarchive/archive_read_support_format_ar.c
index cfbd4cae5aaffe660a519525d7c932141eec2fb1..94836706f593f39a648a0e85fae492f5e65a4ace 100644 (file)
--- a/libarchive/archive_read_support_format_ar.c
+++ b/libarchive/archive_read_support_format_ar.c
@@ -101,6 +101,9 @@ archive_read_support_format_ar(struct archive *_a)
        struct ar *ar;
        int r;
 
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_read_support_format_ar");
+
        ar = (struct ar *)malloc(sizeof(*ar));
        if (ar == NULL) {
                archive_set_error(&a->archive, ENOMEM,

diff --git a/libarchive/archive_read_support_format_cpio.c b/libarchive/archive_read_support_format_cpio.c
index 04cceba417dfbbdaf41b54a149ecffa978774ab7..d3bd0275e332aee94bd5dd6bc59226d3aa80bfcf 100644 (file)
--- a/libarchive/archive_read_support_format_cpio.c
+++ b/libarchive/archive_read_support_format_cpio.c
@@ -176,6 +176,9 @@ archive_read_support_format_cpio(struct archive *_a)
        struct cpio *cpio;
        int r;
 
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_read_support_format_cpio");
+
        cpio = (struct cpio *)malloc(sizeof(*cpio));
        if (cpio == NULL) {
                archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");

diff --git a/libarchive/archive_read_support_format_empty.c b/libarchive/archive_read_support_format_empty.c
index d19c766a642847c3eb7cda1ab7ede2c29c9cedc1..73f51b694e19869e89e7cc91a3c12f710d53fd19 100644 (file)
--- a/libarchive/archive_read_support_format_empty.c
+++ b/libarchive/archive_read_support_format_empty.c
@@ -47,6 +47,9 @@ archive_read_support_format_empty(struct archive *_a)
        struct archive_read *a = (struct archive_read *)_a;
        int r;
 
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_read_support_format_empty");
+
        r = __archive_read_register_format(a,
            NULL,
            NULL,

diff --git a/libarchive/archive_read_support_format_iso9660.c b/libarchive/archive_read_support_format_iso9660.c
index 1694a91a702c221da86c9d3628d64b20733ea6b6..b667cf8794f3b3bd490f3772d00ebba2b365c983 100644 (file)
--- a/libarchive/archive_read_support_format_iso9660.c
+++ b/libarchive/archive_read_support_format_iso9660.c
@@ -426,6 +426,9 @@ archive_read_support_format_iso9660(struct archive *_a)
        struct iso9660 *iso9660;
        int r;
 
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_read_support_format_iso9660");
+
        iso9660 = (struct iso9660 *)malloc(sizeof(*iso9660));
        if (iso9660 == NULL) {
                archive_set_error(&a->archive, ENOMEM, "Can't allocate iso9660 data");

diff --git a/libarchive/archive_read_support_format_mtree.c b/libarchive/archive_read_support_format_mtree.c
index f9d6ca896e3f8ff6daded4a7b242a9fed4e5faa3..f938c07b80c6141224dcfa95a77eadb0785f1140 100644 (file)
--- a/libarchive/archive_read_support_format_mtree.c
+++ b/libarchive/archive_read_support_format_mtree.c
@@ -144,6 +144,9 @@ archive_read_support_format_mtree(struct archive *_a)
        struct mtree *mtree;
        int r;
 
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_read_support_format_mtree");
+
        mtree = (struct mtree *)malloc(sizeof(*mtree));
        if (mtree == NULL) {
                archive_set_error(&a->archive, ENOMEM,

diff --git a/libarchive/archive_read_support_format_raw.c b/libarchive/archive_read_support_format_raw.c
index 89e6940d758e5b2a97532d75f66e428c41a06204..ea7b26c3083fe75a0b7ab985776e7b650c4cfc95 100644 (file)
--- a/libarchive/archive_read_support_format_raw.c
+++ b/libarchive/archive_read_support_format_raw.c
@@ -63,6 +63,9 @@ archive_read_support_format_raw(struct archive *_a)
        struct archive_read *a = (struct archive_read *)_a;
        int r;
 
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_read_support_format_raw");
+
        info = (struct raw_info *)calloc(1, sizeof(*info));
        if (info == NULL) {
                archive_set_error(&a->archive, ENOMEM,

diff --git a/libarchive/archive_read_support_format_tar.c b/libarchive/archive_read_support_format_tar.c
index c60d04baae922872bf872c8c53e66d7914b0e55c..b96ac72432aece68642b7eb5258028f498bf182b 100644 (file)
--- a/libarchive/archive_read_support_format_tar.c
+++ b/libarchive/archive_read_support_format_tar.c
@@ -239,6 +239,8 @@ static wchar_t      *utf8_decode(struct tar *, const char *, size_t length);
 int
 archive_read_support_format_gnutar(struct archive *a)
 {
+       archive_check_magic(a, ARCHIVE_READ_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_read_support_format_gnutar");
        return (archive_read_support_format_tar(a));
 }
 
@@ -250,6 +252,9 @@ archive_read_support_format_tar(struct archive *_a)
        struct tar *tar;
        int r;
 
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_read_support_format_tar");
+
        tar = (struct tar *)malloc(sizeof(*tar));
        if (tar == NULL) {
                archive_set_error(&a->archive, ENOMEM,

diff --git a/libarchive/archive_read_support_format_xar.c b/libarchive/archive_read_support_format_xar.c
index 76452c43142c21eb14c2acc936e85a5448963ca3..02c3b53a3b2f656778e55c82aed083b6165c9ba4 100644 (file)
--- a/libarchive/archive_read_support_format_xar.c
+++ b/libarchive/archive_read_support_format_xar.c
@@ -73,6 +73,8 @@ int
 archive_read_support_format_xar(struct archive *_a)
 {
        struct archive_read *a = (struct archive_read *)_a;
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_read_support_format_xar");
 
        archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
            "Xar not supported on this platform");
@@ -435,6 +437,9 @@ archive_read_support_format_xar(struct archive *_a)
        struct archive_read *a = (struct archive_read *)_a;
        int r;
 
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_read_support_format_xar");
+
        xar = (struct xar *)calloc(1, sizeof(*xar));
        if (xar == NULL) {
                archive_set_error(&a->archive, ENOMEM,

diff --git a/libarchive/archive_read_support_format_zip.c b/libarchive/archive_read_support_format_zip.c
index 044d9de59628bea0fac198cd20657ece6a19b30a..8f04b54288000083edb153000a69e615366c5068 100644 (file)
--- a/libarchive/archive_read_support_format_zip.c
+++ b/libarchive/archive_read_support_format_zip.c
@@ -156,6 +156,9 @@ archive_read_support_format_zip(struct archive *_a)
        struct zip *zip;
        int r;
 
+       archive_check_magic(_a, ARCHIVE_READ_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_read_support_format_zip");
+
        zip = (struct zip *)malloc(sizeof(*zip));
        if (zip == NULL) {
                archive_set_error(&a->archive, ENOMEM, "Can't allocate zip data");

diff --git a/libarchive/archive_write.c b/libarchive/archive_write.c
index bca4b7962fe03ae82f33b11f7d5e2bcea5abfdcb..1a6c80c29e34de41a0d0a5cd1af9a13e19513ea9 100644 (file)
--- a/libarchive/archive_write.c
+++ b/libarchive/archive_write.c
@@ -143,7 +143,7 @@ archive_write_set_format_options(struct archive *_a, const char *s)
        char key[64], val[64];
        int len, r, ret = ARCHIVE_OK;
 
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
            ARCHIVE_STATE_NEW, "archive_write_set_format_options");
        archive_clear_error(&a->archive);
 
@@ -188,7 +188,7 @@ archive_write_set_compressor_options(struct archive *_a, const char *s)
        int len, r;
        int ret = ARCHIVE_OK;
 
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
            ARCHIVE_STATE_NEW, "archive_write_set_compressor_options");
        archive_clear_error(&a->archive);
 
@@ -251,7 +251,7 @@ int
 archive_write_set_bytes_per_block(struct archive *_a, int bytes_per_block)
 {
        struct archive_write *a = (struct archive_write *)_a;
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
            ARCHIVE_STATE_NEW, "archive_write_set_bytes_per_block");
        a->bytes_per_block = bytes_per_block;
        return (ARCHIVE_OK);
@@ -264,7 +264,7 @@ int
 archive_write_get_bytes_per_block(struct archive *_a)
 {
        struct archive_write *a = (struct archive_write *)_a;
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
            ARCHIVE_STATE_ANY, "archive_write_get_bytes_per_block");
        return (a->bytes_per_block);
 }
@@ -277,7 +277,7 @@ int
 archive_write_set_bytes_in_last_block(struct archive *_a, int bytes)
 {
        struct archive_write *a = (struct archive_write *)_a;
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
            ARCHIVE_STATE_ANY, "archive_write_set_bytes_in_last_block");
        a->bytes_in_last_block = bytes;
        return (ARCHIVE_OK);
@@ -290,7 +290,7 @@ int
 archive_write_get_bytes_in_last_block(struct archive *_a)
 {
        struct archive_write *a = (struct archive_write *)_a;
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
            ARCHIVE_STATE_ANY, "archive_write_get_bytes_in_last_block");
        return (a->bytes_in_last_block);
 }
@@ -309,7 +309,7 @@ archive_write_set_skip_file(struct archive *_a, int64_t d, int64_t i)
 #endif
 {
        struct archive_write *a = (struct archive_write *)_a;
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
            ARCHIVE_STATE_ANY, "archive_write_set_skip_file");
        a->skip_file_dev = d;
        a->skip_file_ino = i;
@@ -324,8 +324,7 @@ __archive_write_allocate_filter(struct archive *_a)
 {
        struct archive_write *a = (struct archive_write *)_a;
        struct archive_write_filter *f;
-       __archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
-           ARCHIVE_STATE_NEW, "archive_write_allocate_filter");
+
        f = calloc(1, sizeof(*f));
        f->archive = _a;
        if (a->filter_first == NULL)
@@ -344,6 +343,8 @@ __archive_write_filter(struct archive_write_filter *f,
     const void *buff, size_t length)
 {
        int r;
+       if (length == 0)
+               return(ARCHIVE_OK);
        r = (f->write)(f, buff, length);
        f->bytes_written += length;
        return (r);
@@ -535,7 +536,7 @@ archive_write_open(struct archive *_a, void *client_data,
        struct archive_write_filter *client_filter;
        int ret;
 
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
            ARCHIVE_STATE_NEW, "archive_write_open");
        archive_clear_error(&a->archive);
 
@@ -567,24 +568,17 @@ _archive_write_close(struct archive *_a)
        struct archive_write *a = (struct archive_write *)_a;
        int r = ARCHIVE_OK, r1 = ARCHIVE_OK;
 
-       /*
-        * It's perfectly reasonable to call close() as part of
-        * routine cleanup, even after an error, so we're a little
-        * tolerant of being called in odd states.
-        */
-       if (a->archive.state & ARCHIVE_STATE_FATAL)
-               return (ARCHIVE_FATAL);
-       archive_clear_error(&a->archive);
-       if (a->archive.state & (ARCHIVE_STATE_NEW | ARCHIVE_STATE_CLOSED))
-               return (ARCHIVE_OK);
-
-       __archive_check_magic(&a->archive,
-           ARCHIVE_WRITE_MAGIC,
-           ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL,
            "archive_write_close");
+       if (a->archive.state == ARCHIVE_STATE_NEW
+           || a->archive.state == ARCHIVE_STATE_CLOSED)
+               return (ARCHIVE_OK); // Okay to close() when not open.
+
+       archive_clear_error(&a->archive);
 
        /* Finish the last entry. */
-       if (a->archive.state & ARCHIVE_STATE_DATA)
+       if (a->archive.state == ARCHIVE_STATE_DATA)
                r = ((a->format_finish_entry)(a));
 
        /* Finish off the archive. */
@@ -601,7 +595,8 @@ _archive_write_close(struct archive *_a)
        if (r1 < r)
                r = r1;
 
-       a->archive.state = ARCHIVE_STATE_CLOSED;
+       if (a->archive.state != ARCHIVE_STATE_FATAL)
+               a->archive.state = ARCHIVE_STATE_CLOSED;
        return (r);
 }
 
@@ -638,10 +633,12 @@ _archive_write_free(struct archive *_a)
        struct archive_write *a = (struct archive_write *)_a;
        int r = ARCHIVE_OK, r1;
 
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
-           ARCHIVE_STATE_ANY, "archive_write_free");
-       if (a->archive.state != ARCHIVE_STATE_CLOSED
-           && a->archive.state != ARCHIVE_STATE_FATAL)
+       if (_a == NULL)
+               return (ARCHIVE_OK);
+       /* It is okay to call free() in state FATAL. */
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_write_free");
+       if (a->archive.state != ARCHIVE_STATE_FATAL)
                r = archive_write_close(&a->archive);
 
        /* Release format resources. */
@@ -671,7 +668,7 @@ _archive_write_header(struct archive *_a, struct archive_entry *entry)
        struct archive_write *a = (struct archive_write *)_a;
        int ret, r2;
 
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
            ARCHIVE_STATE_DATA | ARCHIVE_STATE_HEADER, "archive_write_header");
        archive_clear_error(&a->archive);
 
@@ -712,7 +709,7 @@ _archive_write_finish_entry(struct archive *_a)
        struct archive_write *a = (struct archive_write *)_a;
        int ret = ARCHIVE_OK;
 
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
            ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
            "archive_write_finish_entry");
        if (a->archive.state & ARCHIVE_STATE_DATA)
@@ -728,7 +725,7 @@ static ssize_t
 _archive_write_data(struct archive *_a, const void *buff, size_t s)
 {
        struct archive_write *a = (struct archive_write *)_a;
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
            ARCHIVE_STATE_DATA, "archive_write_data");
        archive_clear_error(&a->archive);
        return ((a->format_write_data)(a, buff, s));

diff --git a/libarchive/archive_write_add_filter_bzip2.c b/libarchive/archive_write_add_filter_bzip2.c
index 6d1b35679ae4ba71f356d94345706e2d054f805c..35d29b95939127bf5405d2f9afbd70ccc8127873 100644 (file)
--- a/libarchive/archive_write_add_filter_bzip2.c
+++ b/libarchive/archive_write_add_filter_bzip2.c
@@ -100,8 +100,8 @@ archive_write_add_filter_bzip2(struct archive *_a)
        struct archive_write_filter *f = __archive_write_allocate_filter(_a);
        struct private_data *data;
 
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
-           ARCHIVE_STATE_NEW, "archive_write_set_compression_bzip2");
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_add_filter_bzip2");
 
        data = calloc(1, sizeof(*data));
        if (data == NULL) {

diff --git a/libarchive/archive_write_add_filter_compress.c b/libarchive/archive_write_add_filter_compress.c
index 7e3ef6bbc637bd1489e0d43a7ef3a2b0c5895ecf..0ae98ea5a1075fe8666a99b48e39c1e8fbf8115e 100644 (file)
--- a/libarchive/archive_write_add_filter_compress.c
+++ b/libarchive/archive_write_add_filter_compress.c
@@ -132,8 +132,8 @@ archive_write_add_filter_compress(struct archive *_a)
        struct archive_write *a = (struct archive_write *)_a;
        struct archive_write_filter *f = __archive_write_allocate_filter(_a);
 
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
-           ARCHIVE_STATE_NEW, "archive_write_set_compression_compress");
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_add_filter_compress");
        f->open = &archive_compressor_compress_open;
        f->code = ARCHIVE_COMPRESSION_COMPRESS;
        f->name = "compress";

diff --git a/libarchive/archive_write_add_filter_gzip.c b/libarchive/archive_write_add_filter_gzip.c
index 23dabe5387217c2463db23e2fc0c4a1b08dfd41e..786ae98ac020149328e8e2c41c52c8b936151340 100644 (file)
--- a/libarchive/archive_write_add_filter_gzip.c
+++ b/libarchive/archive_write_add_filter_gzip.c
@@ -101,8 +101,8 @@ archive_write_add_filter_gzip(struct archive *_a)
        struct archive_write *a = (struct archive_write *)_a;
        struct archive_write_filter *f = __archive_write_allocate_filter(_a);
        struct private_data *data;
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
-           ARCHIVE_STATE_NEW, "archive_write_set_compression_gzip");
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_add_filter_gzip");
 
        data = calloc(1, sizeof(*data));
        if (data == NULL) {

diff --git a/libarchive/archive_write_add_filter_program.c b/libarchive/archive_write_add_filter_program.c
index 90c5f11d47d8daba1e6d9c543b1566b14e5e59ae..3dcc9df7bcca7b30d09208735f4bd8d244539f75 100644 (file)
--- a/libarchive/archive_write_add_filter_program.c
+++ b/libarchive/archive_write_add_filter_program.c
@@ -102,8 +102,8 @@ archive_write_add_filter_program(struct archive *_a, const char *cmd)
        struct archive_write *a = (struct archive_write *)_a;
        struct private_data *data;
        static const char *prefix = "Program: ";
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
-           ARCHIVE_STATE_NEW, "archive_write_set_compression_program");
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_add_filter_program");
        data = calloc(1, sizeof(*data));
        if (data == NULL) {
                archive_set_error(&a->archive, ENOMEM, "Out of memory");

diff --git a/libarchive/archive_write_add_filter_xz.c b/libarchive/archive_write_add_filter_xz.c
index 2e21c60aeafa5023cedbb358cbe4e1537320f70c..83cdb63572d43ca1634d875062caacc5f7dbb5e7 100644 (file)
--- a/libarchive/archive_write_add_filter_xz.c
+++ b/libarchive/archive_write_add_filter_xz.c
@@ -107,8 +107,6 @@ common_setup(struct archive_write_filter *f)
 {
        struct private_data *data;
        struct archive_write *a = (struct archive_write *)f->archive;
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
-           ARCHIVE_STATE_NEW, "archive_write_add_filter_xz");
        data = calloc(1, sizeof(*data));
        if (data == NULL) {
                archive_set_error(&a->archive, ENOMEM, "Out of memory");
@@ -129,8 +127,13 @@ common_setup(struct archive_write_filter *f)
 int
 archive_write_add_filter_xz(struct archive *_a)
 {
-       struct archive_write_filter *f = __archive_write_allocate_filter(_a);
-       int r = common_setup(f);
+       struct archive_write_filter *f;
+       int r;
+
+       archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_add_filter_xz");
+       f = __archive_write_allocate_filter(_a);
+       r = common_setup(f);
        if (r == ARCHIVE_OK) {
                f->code = ARCHIVE_COMPRESSION_XZ;
                f->name = "xz";
@@ -144,8 +147,13 @@ archive_write_add_filter_xz(struct archive *_a)
 int
 archive_write_add_filter_lzma(struct archive *_a)
 {
-       struct archive_write_filter *f = __archive_write_allocate_filter(_a);
-       int r = common_setup(f);
+       struct archive_write_filter *f;
+       int r;
+
+       archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_add_filter_lzma");
+       f = __archive_write_allocate_filter(_a);
+       r = common_setup(f);
        if (r == ARCHIVE_OK) {
                f->code = ARCHIVE_COMPRESSION_LZMA;
                f->name = "lzma";

diff --git a/libarchive/archive_write_disk.c b/libarchive/archive_write_disk.c
index 5f5ade9de941868f4e35fa57593ab76f3e251735..92dbe35e9f65c1983bfa2fc6eba74554cd3446e6 100644 (file)
--- a/libarchive/archive_write_disk.c
+++ b/libarchive/archive_write_disk.c
@@ -360,7 +360,7 @@ _archive_write_disk_header(struct archive *_a, struct archive_entry *entry)
        struct fixup_entry *fe;
        int ret, r;
 
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
            ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
            "archive_write_disk_header");
        archive_clear_error(&a->archive);
@@ -598,7 +598,7 @@ archive_write_disk_set_skip_file(struct archive *_a, int64_t d, int64_t i)
 #endif
 {
        struct archive_write_disk *a = (struct archive_write_disk *)_a;
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
            ARCHIVE_STATE_ANY, "archive_write_disk_set_skip_file");
        a->skip_file_dev = d;
        a->skip_file_ino = i;
@@ -698,7 +698,7 @@ _archive_write_disk_data_block(struct archive *_a,
        struct archive_write_disk *a = (struct archive_write_disk *)_a;
        ssize_t r;
 
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
            ARCHIVE_STATE_DATA, "archive_write_data_block");
 
        a->offset = offset;
@@ -718,7 +718,7 @@ _archive_write_disk_data(struct archive *_a, const void *buff, size_t size)
 {
        struct archive_write_disk *a = (struct archive_write_disk *)_a;
 
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
            ARCHIVE_STATE_DATA, "archive_write_data");
 
        return (write_data_block(a, buff, size));
@@ -730,7 +730,7 @@ _archive_write_disk_finish_entry(struct archive *_a)
        struct archive_write_disk *a = (struct archive_write_disk *)_a;
        int ret = ARCHIVE_OK;
 
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
            ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
            "archive_write_finish_entry");
        if (a->archive.state & ARCHIVE_STATE_HEADER)
@@ -870,7 +870,7 @@ archive_write_disk_set_group_lookup(struct archive *_a,
 #endif
 {
        struct archive_write_disk *a = (struct archive_write_disk *)_a;
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
            ARCHIVE_STATE_ANY, "archive_write_disk_set_group_lookup");
 
        a->lookup_gid = lookup_gid;
@@ -894,7 +894,7 @@ archive_write_disk_set_user_lookup(struct archive *_a,
 #endif
 {
        struct archive_write_disk *a = (struct archive_write_disk *)_a;
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
            ARCHIVE_STATE_ANY, "archive_write_disk_set_user_lookup");
 
        a->lookup_uid = lookup_uid;
@@ -1309,7 +1309,7 @@ _archive_write_disk_close(struct archive *_a)
        struct fixup_entry *next, *p;
        int ret;
 
-       __archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
+       archive_check_magic(&a->archive, ARCHIVE_WRITE_DISK_MAGIC,
            ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
            "archive_write_disk_close");
        ret = _archive_write_disk_finish_entry(&a->archive);
@@ -1373,8 +1373,13 @@ _archive_write_disk_close(struct archive *_a)
 static int
 _archive_write_disk_free(struct archive *_a)
 {
-       struct archive_write_disk *a = (struct archive_write_disk *)_a;
+       struct archive_write_disk *a;
        int ret;
+       if (_a == NULL)
+               return (ARCHIVE_OK);
+       archive_check_magic(_a, ARCHIVE_WRITE_DISK_MAGIC,
+           ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_write_disk_free");
+       a = (struct archive_write_disk *)_a;
        ret = _archive_write_disk_close(&a->archive);
        if (a->cleanup_gid != NULL && a->lookup_gid_data != NULL)
                (a->cleanup_gid)(a->lookup_gid_data);
@@ -1385,6 +1390,7 @@ _archive_write_disk_free(struct archive *_a)
        archive_string_free(&a->_name_data);
        archive_string_free(&a->archive.error_string);
        archive_string_free(&a->path_safe);
+       a->archive.magic = 0;
        free(a);
        return (ret);
 }

diff --git a/libarchive/archive_write_set_format_ar.c b/libarchive/archive_write_set_format_ar.c
index 3e70f363f80f43bd799a3e97bb1e00039c383df6..efe2725f27153315f985ffcd39176f45307e5894 100644 (file)
--- a/libarchive/archive_write_set_format_ar.c
+++ b/libarchive/archive_write_set_format_ar.c
@@ -86,7 +86,11 @@ int
 archive_write_set_format_ar_bsd(struct archive *_a)
 {
        struct archive_write *a = (struct archive_write *)_a;
-       int r = archive_write_set_format_ar(a);
+       int r;
+
+       archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_set_format_ar_bsd");
+       r = archive_write_set_format_ar(a);
        if (r == ARCHIVE_OK) {
                a->archive.archive_format = ARCHIVE_FORMAT_AR_BSD;
                a->archive.archive_format_name = "ar (BSD)";
@@ -98,7 +102,11 @@ int
 archive_write_set_format_ar_svr4(struct archive *_a)
 {
        struct archive_write *a = (struct archive_write *)_a;
-       int r = archive_write_set_format_ar(a);
+       int r;
+
+       archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_set_format_ar_svr4");
+       r = archive_write_set_format_ar(a);
        if (r == ARCHIVE_OK) {
                a->archive.archive_format = ARCHIVE_FORMAT_AR_GNU;
                a->archive.archive_format_name = "ar (GNU/SVR4)";

diff --git a/libarchive/archive_write_set_format_by_name.c b/libarchive/archive_write_set_format_by_name.c
index 3c08d060615e5f636b7bdb341e1633e631f2c001..0851c1ec66c7c4c508054e754ea8ee0960f4310a 100644 (file)
--- a/libarchive/archive_write_set_format_by_name.c
+++ b/libarchive/archive_write_set_format_by_name.c
@@ -75,5 +75,6 @@ archive_write_set_format_by_name(struct archive *a, const char *name)
        }
 
        archive_set_error(a, EINVAL, "No such format '%s'", name);
+       a->state = ARCHIVE_STATE_FATAL;
        return (ARCHIVE_FATAL);
 }

diff --git a/libarchive/archive_write_set_format_cpio.c b/libarchive/archive_write_set_format_cpio.c
index 29a6fb6e02b3eec31f1b95c8e61af48e7e5e6388..28e91e192f81e3772e1b6ee9d3e08ff8efc8b5b4 100644 (file)
--- a/libarchive/archive_write_set_format_cpio.c
+++ b/libarchive/archive_write_set_format_cpio.c
@@ -85,6 +85,9 @@ archive_write_set_format_cpio(struct archive *_a)
        struct archive_write *a = (struct archive_write *)_a;
        struct cpio *cpio;
 
+       archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_set_format_cpio");
+
        /* If someone else was already registered, unregister them. */
        if (a->format_destroy != NULL)
                (a->format_destroy)(a);

diff --git a/libarchive/archive_write_set_format_cpio_newc.c b/libarchive/archive_write_set_format_cpio_newc.c
index bf4f7435b98c5ece24188415bb8bda5324e5532e..b9d21c52d364356a0d521d74ba9e82c1699cf5d2 100644 (file)
--- a/libarchive/archive_write_set_format_cpio_newc.c
+++ b/libarchive/archive_write_set_format_cpio_newc.c
@@ -87,6 +87,9 @@ archive_write_set_format_cpio_newc(struct archive *_a)
        struct archive_write *a = (struct archive_write *)_a;
        struct cpio *cpio;
 
+       archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_set_format_cpio_newc");
+
        /* If someone else was already registered, unregister them. */
        if (a->format_destroy != NULL)
                (a->format_destroy)(a);

diff --git a/libarchive/archive_write_set_format_iso9660.c b/libarchive/archive_write_set_format_iso9660.c
index e7bfaf368496190451d21bc20b3306c33f3887e8..5329d8211123235780aa115720e6911f8ab0d0bb 100644 (file)
--- a/libarchive/archive_write_set_format_iso9660.c
+++ b/libarchive/archive_write_set_format_iso9660.c
@@ -1158,6 +1158,9 @@ archive_write_set_format_iso9660(struct archive *_a)
        struct archive_write *a = (struct archive_write *)_a;
        struct iso9660 *iso9660;
 
+       archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_set_format_iso9660");
+
        /* If another format was already registered, unregister it. */
        if (a->format_destroy != NULL)
                (a->format_destroy)(a);

diff --git a/libarchive/archive_write_set_format_mtree.c b/libarchive/archive_write_set_format_mtree.c
index 054cbc14318806a79c6414e17eeda05a24b51346..5b2bf02244e57c89f3dc0bb9970cdee92074b72a 100644 (file)
--- a/libarchive/archive_write_set_format_mtree.c
+++ b/libarchive/archive_write_set_format_mtree.c
@@ -1015,6 +1015,9 @@ archive_write_set_format_mtree(struct archive *_a)
        struct archive_write *a = (struct archive_write *)_a;
        struct mtree_writer *mtree;
 
+       archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_set_format_mtree");
+
        if (a->format_destroy != NULL)
                (a->format_destroy)(a);
 

diff --git a/libarchive/archive_write_set_format_pax.c b/libarchive/archive_write_set_format_pax.c
index cab8f3756f4f2b5f6d598dd70ec5cae6e57edfb9..771de2a5f3add1ed8f26060be639a39fb4aef6ea 100644 (file)
--- a/libarchive/archive_write_set_format_pax.c
+++ b/libarchive/archive_write_set_format_pax.c
@@ -99,6 +99,10 @@ archive_write_set_format_pax_restricted(struct archive *_a)
 {
        struct archive_write *a = (struct archive_write *)_a;
        int r;
+
+       archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_set_format_pax_restricted");
+
        r = archive_write_set_format_pax(&a->archive);
        a->archive.archive_format = ARCHIVE_FORMAT_TAR_PAX_RESTRICTED;
        a->archive.archive_format_name = "restricted POSIX pax interchange";
@@ -114,6 +118,9 @@ archive_write_set_format_pax(struct archive *_a)
        struct archive_write *a = (struct archive_write *)_a;
        struct pax *pax;
 
+       archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_set_format_pax");
+
        if (a->format_destroy != NULL)
                (a->format_destroy)(a);
 

diff --git a/libarchive/archive_write_set_format_shar.c b/libarchive/archive_write_set_format_shar.c
index 727a6e40115ac3ac01053218d739cadf84826ea0..52bb93c924bde25c69136f261bf60934eb3e02b3 100644 (file)
--- a/libarchive/archive_write_set_format_shar.c
+++ b/libarchive/archive_write_set_format_shar.c
@@ -106,6 +106,9 @@ archive_write_set_format_shar(struct archive *_a)
        struct archive_write *a = (struct archive_write *)_a;
        struct shar *shar;
 
+       archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_set_format_shar");
+
        /* If someone else was already registered, unregister them. */
        if (a->format_destroy != NULL)
                (a->format_destroy)(a);

diff --git a/libarchive/archive_write_set_format_ustar.c b/libarchive/archive_write_set_format_ustar.c
index a76081ce1d6c46be82addb9fed9ce76e21c86ff4..8885b74616e823c876b3dc0fe089d352eb80ad38 100644 (file)
--- a/libarchive/archive_write_set_format_ustar.c
+++ b/libarchive/archive_write_set_format_ustar.c
@@ -162,6 +162,9 @@ archive_write_set_format_ustar(struct archive *_a)
        struct archive_write *a = (struct archive_write *)_a;
        struct ustar *ustar;
 
+       archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_set_format_ustar");
+
        /* If someone else was already registered, unregister them. */
        if (a->format_destroy != NULL)
                (a->format_destroy)(a);

diff --git a/libarchive/archive_write_set_format_zip.c b/libarchive/archive_write_set_format_zip.c
index b857df2e477842cf5684b7510c8fbf985a3d186f..4ed1bfa79ec502058571c64fd00342d551c26b02 100644 (file)
--- a/libarchive/archive_write_set_format_zip.c
+++ b/libarchive/archive_write_set_format_zip.c
@@ -227,6 +227,9 @@ archive_write_set_format_zip(struct archive *_a)
        struct archive_write *a = (struct archive_write *)_a;
        struct zip *zip;
 
+       archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
+           ARCHIVE_STATE_NEW, "archive_write_set_format_zip");
+
        /* If another format was already registered, unregister it. */
        if (a->format_destroy != NULL)
                (a->format_destroy)(a);