filter options: Use ARCHIVE_FAILED on errors

If a filter option is recognized but its value is invalid, return
ARCHIVE_FAILED instead of ARCHIVE_WARN. The latter is used for unknown
options, e.g. at the end of the option setter functions.

Signed-off-by: Tobias Stoeckmann <tobias@stoeckmann.org>

diff --git a/libarchive/archive_write_add_filter_bzip2.c b/libarchive/archive_write_add_filter_bzip2.c
index 2434528d5133b6ed33f31fdb0fa3e0760131180c..94b342d41b74a8014b22e59447c4cb291ce89e20 100644 (file)
--- a/libarchive/archive_write_add_filter_bzip2.c
+++ b/libarchive/archive_write_add_filter_bzip2.c
@@ -127,8 +127,11 @@ archive_compressor_bzip2_options(struct archive_write_filter *f,
 
        if (strcmp(key, "compression-level") == 0) {
                if (value == NULL || !(value[0] >= '0' && value[0] <= '9') ||
-                   value[1] != '\0')
-                       return (ARCHIVE_WARN);
+                   value[1] != '\0') {
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "compression-level invalid");
+                       return (ARCHIVE_FAILED);
+               }
                data->compression_level = value[0] - '0';
                /* Make '0' be a synonym for '1'. */
                /* This way, bzip2 compressor supports the same 0..9

diff --git a/libarchive/archive_write_add_filter_gzip.c b/libarchive/archive_write_add_filter_gzip.c
index b09e669b753d34eb2599b254c18de06932375520..5527544d5489d1684eae218b3eac8de5c3d2caa0 100644 (file)
--- a/libarchive/archive_write_add_filter_gzip.c
+++ b/libarchive/archive_write_add_filter_gzip.c
@@ -160,8 +160,11 @@ archive_compressor_gzip_options(struct archive_write_filter *f, const char *key,
 
        if (strcmp(key, "compression-level") == 0) {
                if (value == NULL || !(value[0] >= '0' && value[0] <= '9') ||
-                   value[1] != '\0')
-                       return (ARCHIVE_WARN);
+                   value[1] != '\0') {
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "compression-level invalid");
+                       return (ARCHIVE_FAILED);
+               }
                data->compression_level = value[0] - '0';
                return (ARCHIVE_OK);
        }

diff --git a/libarchive/archive_write_add_filter_lrzip.c b/libarchive/archive_write_add_filter_lrzip.c
index fe974c93d5d0558b5a59e1f08d2a3bf8acc5108d..cda34dc738d39ba84e8d7dedc6ae5556137b07cf 100644 (file)
--- a/libarchive/archive_write_add_filter_lrzip.c
+++ b/libarchive/archive_write_add_filter_lrzip.c
@@ -97,8 +97,11 @@ archive_write_lrzip_options(struct archive_write_filter *f, const char *key,
        struct write_lrzip *data = (struct write_lrzip *)f->data;
 
        if (strcmp(key, "compression") == 0) {
-               if (value == NULL)
-                       return (ARCHIVE_WARN);
+               if (value == NULL) {
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "compression option requires an argument");
+                       return (ARCHIVE_FAILED);
+               }
                else if (strcmp(value, "bzip2") == 0)
                        data->compression = bzip2;
                else if (strcmp(value, "gzip") == 0)
@@ -109,13 +112,19 @@ archive_write_lrzip_options(struct archive_write_filter *f, const char *key,
                        data->compression = none;
                else if (strcmp(value, "zpaq") == 0)
                        data->compression = zpaq;
-               else
-                       return (ARCHIVE_WARN);
+               else {
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "compression invalid");
+                       return (ARCHIVE_FAILED);
+               }
                return (ARCHIVE_OK);
        } else if (strcmp(key, "compression-level") == 0) {
                if (value == NULL || !(value[0] >= '1' && value[0] <= '9') ||
-                   value[1] != '\0')
-                       return (ARCHIVE_WARN);
+                   value[1] != '\0') {
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "compression-level invalid");
+                       return (ARCHIVE_FAILED);
+               }
                data->compression_level = value[0] - '0';
                return (ARCHIVE_OK);
        }

diff --git a/libarchive/archive_write_add_filter_lz4.c b/libarchive/archive_write_add_filter_lz4.c
index 24061a169521803f4cb5167698f68d137699c2df..efc408e2a3f8d964bf4eeea32438ab083192249e 100644 (file)
--- a/libarchive/archive_write_add_filter_lz4.c
+++ b/libarchive/archive_write_add_filter_lz4.c
@@ -160,8 +160,11 @@ archive_filter_lz4_options(struct archive_write_filter *f,
        if (strcmp(key, "compression-level") == 0) {
                int val;
                if (value == NULL || !((val = value[0] - '0') >= 1 && val <= 9) ||
-                   value[1] != '\0')
-                       return (ARCHIVE_WARN);
+                   value[1] != '\0') {
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "compression-level invalid");
+                       return (ARCHIVE_FAILED);
+               }
 
 #ifndef HAVE_LZ4HC_H
                if(val >= 3)
@@ -184,8 +187,11 @@ archive_filter_lz4_options(struct archive_write_filter *f,
        }
        if (strcmp(key, "block-size") == 0) {
                if (value == NULL || !(value[0] >= '4' && value[0] <= '7') ||
-                   value[1] != '\0')
-                       return (ARCHIVE_WARN);
+                   value[1] != '\0') {
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "block-size invalid");
+                       return (ARCHIVE_FAILED);
+               }
                data->block_maximum_size = value[0] - '0';
                return (ARCHIVE_OK);
        }

diff --git a/libarchive/archive_write_add_filter_lzop.c b/libarchive/archive_write_add_filter_lzop.c
index 8580e58844af23651f27903a046cb5e1cda15a77..42d62db63a13625c92938f25a941d344ec449e7f 100644 (file)
--- a/libarchive/archive_write_add_filter_lzop.c
+++ b/libarchive/archive_write_add_filter_lzop.c
@@ -211,8 +211,11 @@ archive_write_lzop_options(struct archive_write_filter *f, const char *key,
 
        if (strcmp(key, "compression-level") == 0) {
                if (value == NULL || !(value[0] >= '1' && value[0] <= '9') ||
-                   value[1] != '\0')
-                       return (ARCHIVE_WARN);
+                   value[1] != '\0') {
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "compression-level invalid");
+                       return (ARCHIVE_FAILED);
+               }
                data->compression_level = value[0] - '0';
                return (ARCHIVE_OK);
        }

diff --git a/libarchive/archive_write_add_filter_xz.c b/libarchive/archive_write_add_filter_xz.c
index 098f0c95570b68cd67fd94c685d431e4e119abde..b80c25590e69a1d3fb354a07236792e1289a701b 100644 (file)
--- a/libarchive/archive_write_add_filter_xz.c
+++ b/libarchive/archive_write_add_filter_xz.c
@@ -376,8 +376,11 @@ archive_compressor_xz_options(struct archive_write_filter *f,
 
        if (strcmp(key, "compression-level") == 0) {
                if (value == NULL || !(value[0] >= '0' && value[0] <= '9') ||
-                   value[1] != '\0')
-                       return (ARCHIVE_WARN);
+                   value[1] != '\0') {
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "compression-level invalid");
+                       return (ARCHIVE_FAILED);
+               }
                data->compression_level = value[0] - '0';
                if (data->compression_level > 9)
                        data->compression_level = 9;
@@ -385,13 +388,18 @@ archive_compressor_xz_options(struct archive_write_filter *f,
        } else if (strcmp(key, "threads") == 0) {
                char *endptr;
 
-               if (value == NULL)
-                       return (ARCHIVE_WARN);
+               if (value == NULL) {
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "threads option requires an argument");
+                       return (ARCHIVE_FAILED);
+               }
                errno = 0;
                data->threads = (int)strtoul(value, &endptr, 10);
                if (errno != 0 || *endptr != '\0') {
                        data->threads = 1;
-                       return (ARCHIVE_WARN);
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "threads invalid");
+                       return (ARCHIVE_FAILED);
                }
                if (data->threads == 0) {
 #ifdef HAVE_LZMA_STREAM_ENCODER_MT

diff --git a/libarchive/archive_write_add_filter_zstd.c b/libarchive/archive_write_add_filter_zstd.c
index d4752c24715713ce3a017f1679677d590ae98e45..7149abb2b8a8506bb75263bc05018d14b39acf44 100644 (file)
--- a/libarchive/archive_write_add_filter_zstd.c
+++ b/libarchive/archive_write_add_filter_zstd.c
@@ -245,7 +245,9 @@ archive_compressor_zstd_options(struct archive_write_filter *f, const char *key,
        if (strcmp(key, "compression-level") == 0) {
                intmax_t level;
                if (string_to_number(value, &level) != ARCHIVE_OK) {
-                       return (ARCHIVE_WARN);
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "compression-level invalid");
+                       return (ARCHIVE_FAILED);
                }
                /* If we don't have the library, hard-code the max level */
                int minimum = CLEVEL_MIN;
@@ -263,14 +265,18 @@ archive_compressor_zstd_options(struct archive_write_filter *f, const char *key,
                }
 #endif
                if (level < minimum || level > maximum) {
-                       return (ARCHIVE_WARN);
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "compression-level out of range");
+                       return (ARCHIVE_FAILED);
                }
                data->compression_level = (int)level;
                return (ARCHIVE_OK);
        } else if (strcmp(key, "threads") == 0) {
                intmax_t threads;
                if (string_to_number(value, &threads) != ARCHIVE_OK) {
-                       return (ARCHIVE_WARN);
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "threads invalid");
+                       return (ARCHIVE_FAILED);
                }
 
 #if defined(HAVE_SYSCONF) && defined(_SC_NPROCESSORS_ONLN)
@@ -286,7 +292,9 @@ archive_compressor_zstd_options(struct archive_write_filter *f, const char *key,
                }
 #endif
                if (threads < 0 || threads > INT_MAX) {
-                       return (ARCHIVE_WARN);
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "threads out of rnage");
+                       return (ARCHIVE_FAILED);
                }
                data->threads = (int)threads;
                return (ARCHIVE_OK);
@@ -296,26 +304,34 @@ archive_compressor_zstd_options(struct archive_write_filter *f, const char *key,
                return (ARCHIVE_OK);
        } else if (strcmp(key, "min-frame-in") == 0) {
                if (string_to_size(value, &data->min_frame_in) != ARCHIVE_OK) {
-                       return (ARCHIVE_WARN);
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "min-frame-in invalid");
+                       return (ARCHIVE_FAILED);
                }
                return (ARCHIVE_OK);
        } else if (strcmp(key, "min-frame-out") == 0 ||
            strcmp(key, "min-frame-size") == 0) {
                if (string_to_size(value, &data->min_frame_out) != ARCHIVE_OK) {
-                       return (ARCHIVE_WARN);
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "min-frame-out invalid");
+                       return (ARCHIVE_FAILED);
                }
                return (ARCHIVE_OK);
        } else if (strcmp(key, "max-frame-in") == 0 ||
            strcmp(key, "max-frame-size") == 0) {
                if (string_to_size(value, &data->max_frame_in) != ARCHIVE_OK ||
                    data->max_frame_in < 1024) {
-                       return (ARCHIVE_WARN);
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "max-frame-size invalid");
+                       return (ARCHIVE_FAILED);
                }
                return (ARCHIVE_OK);
        } else if (strcmp(key, "max-frame-out") == 0) {
                if (string_to_size(value, &data->max_frame_out) != ARCHIVE_OK ||
                    data->max_frame_out < 1024) {
-                       return (ARCHIVE_WARN);
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "max-frame-out invalid");
+                       return (ARCHIVE_FAILED);
                }
                return (ARCHIVE_OK);
 #endif
@@ -323,22 +339,30 @@ archive_compressor_zstd_options(struct archive_write_filter *f, const char *key,
        else if (strcmp(key, "long") == 0) {
                intmax_t long_distance;
                if (string_to_number(value, &long_distance) != ARCHIVE_OK) {
-                       return (ARCHIVE_WARN);
+                       archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "long invalid");
+                       return (ARCHIVE_FAILED);
                }
 #if HAVE_ZSTD_H && HAVE_ZSTD_compressStream && ZSTD_VERSION_NUMBER >= MINVER_LONG
                ZSTD_bounds bounds = ZSTD_cParam_getBounds(ZSTD_c_windowLog);
                if (ZSTD_isError(bounds.error)) {
                        int max_distance = ((int)(sizeof(size_t) == 4 ? 30 : 31));
-                       if (((int)long_distance) < 10 || (int)long_distance > max_distance)
-                               return (ARCHIVE_WARN);
+                       if (((int)long_distance) < 10 || (int)long_distance > max_distance) {
+                               archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "long out of range");
+                               return (ARCHIVE_FAILED);
+                       }
                } else {
-                       if ((int)long_distance < bounds.lowerBound || (int)long_distance > bounds.upperBound)
-                               return (ARCHIVE_WARN);
+                       if ((int)long_distance < bounds.lowerBound || (int)long_distance > bounds.upperBound) {
+                               archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+                           "long out of range");
+                               return (ARCHIVE_FAILED);
+                       }
                }
 #else
                int max_distance = ((int)(sizeof(size_t) == 4 ? 30 : 31));
                if (((int)long_distance) < 10 || (int)long_distance > max_distance)
-                   return (ARCHIVE_WARN);
+                   return (ARCHIVE_FAILED);
 #endif
                data->long_distance = (int)long_distance;
                return (ARCHIVE_OK);