contrib/libarchive/libarchive/test/test_open_failure.c

   1 /*-
   2  * Copyright (c) 2003-2010 Tim Kientzle
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25 #include "test.h"
  26 __FBSDID("$FreeBSD$");
  27
  28 #define MAGIC 123456789
  29 struct my_data {
  30         int magic;
  31         int read_return;
  32         int read_called;
  33         int write_return;
  34         int write_called;
  35         int open_return;
  36         int open_called;
  37         int close_return;
  38         int close_called;
  39 };
  40
  41 static ssize_t
  42 my_read(struct archive *a, void *_private, const void **buff)
  43 {
  44         struct my_data *private = (struct my_data *)_private;
  45         assertEqualInt(MAGIC, private->magic);
  46         ++private->read_called;
  47         return (private->read_return);
  48 }
  49
  50 static ssize_t
  51 my_write(struct archive *a, void *_private, const void *buff, size_t s)
  52 {
  53         struct my_data *private = (struct my_data *)_private;
  54         assertEqualInt(MAGIC, private->magic);
  55         ++private->write_called;
  56         return (private->write_return);
  57 }
  58
  59 static int
  60 my_open(struct archive *a, void *_private)
  61 {
  62         struct my_data *private = (struct my_data *)_private;
  63         assertEqualInt(MAGIC, private->magic);
  64         ++private->open_called;
  65         return (private->open_return);
  66 }
  67
  68 static int
  69 my_close(struct archive *a, void *_private)
  70 {
  71         struct my_data *private = (struct my_data *)_private;
  72         assertEqualInt(MAGIC, private->magic);
  73         ++private->close_called;
  74         return (private->close_return);
  75 }
  76
  77
  78 DEFINE_TEST(test_open_failure)
  79 {
  80         struct archive *a;
  81         struct my_data private;
  82
  83         memset(&private, 0, sizeof(private));
  84         private.magic = MAGIC;
  85         private.open_return = ARCHIVE_FATAL;
  86         a = archive_read_new();
  87         assert(a != NULL);
  88         assertEqualInt(ARCHIVE_FATAL,
  89             archive_read_open(a, &private, my_open, my_read, my_close));
  90         assertEqualInt(1, private.open_called);
  91         assertEqualInt(0, private.read_called);
  92         assertEqualInt(1, private.close_called);
  93         assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
  94         assertEqualInt(1, private.open_called);
  95         assertEqualInt(0, private.read_called);
  96         assertEqualInt(1, private.close_called);
  97
  98         memset(&private, 0, sizeof(private));
  99         private.magic = MAGIC;
 100         private.open_return = ARCHIVE_FAILED;
 101         a = archive_read_new();
 102         assert(a != NULL);
 103         assertEqualInt(ARCHIVE_FAILED,
 104             archive_read_open(a, &private, my_open, my_read, my_close));
 105         assertEqualInt(1, private.open_called);
 106         assertEqualInt(0, private.read_called);
 107         assertEqualInt(1, private.close_called);
 108         assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
 109         assertEqualInt(1, private.open_called);
 110         assertEqualInt(0, private.read_called);
 111         assertEqualInt(1, private.close_called);
 112
 113         memset(&private, 0, sizeof(private));
 114         private.magic = MAGIC;
 115         private.open_return = ARCHIVE_WARN;
 116         a = archive_read_new();
 117         assert(a != NULL);
 118         assertEqualInt(ARCHIVE_WARN,
 119             archive_read_open(a, &private, my_open, my_read, my_close));
 120         assertEqualInt(1, private.open_called);
 121         assertEqualInt(0, private.read_called);
 122         assertEqualInt(1, private.close_called);
 123         assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
 124         assertEqualInt(1, private.open_called);
 125         assertEqualInt(0, private.read_called);
 126         assertEqualInt(1, private.close_called);
 127
 128         memset(&private, 0, sizeof(private));
 129         private.magic = MAGIC;
 130         private.open_return = ARCHIVE_OK;
 131         private.read_return = ARCHIVE_FATAL;
 132         a = archive_read_new();
 133         assert(a != NULL);
 134         assertEqualInt(ARCHIVE_OK,
 135             archive_read_support_compression_compress(a));
 136         assertEqualInt(ARCHIVE_OK, archive_read_support_format_tar(a));
 137         assertEqualInt(ARCHIVE_FATAL,
 138             archive_read_open(a, &private, my_open, my_read, my_close));
 139         assertEqualInt(1, private.open_called);
 140         assertEqualInt(1, private.read_called);
 141         assertEqualInt(1, private.close_called);
 142         assertEqualInt(ARCHIVE_OK, archive_read_finish(a));
 143         assertEqualInt(1, private.open_called);
 144         assertEqualInt(1, private.read_called);
 145         assertEqualInt(1, private.close_called);
 146
 147         memset(&private, 0, sizeof(private));
 148         private.magic = MAGIC;
 149         private.open_return = ARCHIVE_FATAL;
 150         a = archive_write_new();
 151         assert(a != NULL);
 152         assertEqualInt(ARCHIVE_FATAL,
 153             archive_write_open(a, &private, my_open, my_write, my_close));
 154         assertEqualInt(1, private.open_called);
 155         assertEqualInt(0, private.write_called);
 156         // Broken in 2.8, fixed in 3.0
 157         //assertEqualInt(1, private.close_called);
 158         assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 159         assertEqualInt(1, private.open_called);
 160         assertEqualInt(0, private.write_called);
 161         assertEqualInt(1, private.close_called);
 162
 163         memset(&private, 0, sizeof(private));
 164         private.magic = MAGIC;
 165         private.open_return = ARCHIVE_FATAL;
 166         a = archive_write_new();
 167         assert(a != NULL);
 168         archive_write_set_compression_compress(a);
 169         archive_write_set_format_zip(a);
 170         assertEqualInt(ARCHIVE_FATAL,
 171             archive_write_open(a, &private, my_open, my_write, my_close));
 172         assertEqualInt(1, private.open_called);
 173         assertEqualInt(0, private.write_called);
 174         // Broken in 2.8, fixed in 3.0
 175         //assertEqualInt(1, private.close_called);
 176         assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 177         assertEqualInt(1, private.open_called);
 178         assertEqualInt(0, private.write_called);
 179         assertEqualInt(1, private.close_called);
 180
 181         memset(&private, 0, sizeof(private));
 182         private.magic = MAGIC;
 183         private.open_return = ARCHIVE_FATAL;
 184         a = archive_write_new();
 185         assert(a != NULL);
 186         archive_write_set_compression_gzip(a);
 187         assertEqualInt(ARCHIVE_FATAL,
 188             archive_write_open(a, &private, my_open, my_write, my_close));
 189         assertEqualInt(1, private.open_called);
 190         assertEqualInt(0, private.write_called);
 191         // Broken in 2.8, fixed in 3.0
 192         //assertEqualInt(1, private.close_called);
 193         assertEqualInt(ARCHIVE_OK, archive_write_finish(a));
 194         assertEqualInt(1, private.open_called);
 195         assertEqualInt(0, private.write_called);
 196         assertEqualInt(1, private.close_called);
 197
 198 }