contrib/libarchive/libarchive/test/test_archive_read_add_passphrase.c

   1 /*-
   2  * Copyright (c) 2011 Tim Kientzle
   3  * Copyright (c) 2014 Michihiro NAKAJIMA
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "test.h"
  28 __FBSDID("$FreeBSD$");
  29
  30 struct archive_read;
  31 extern void __archive_read_reset_passphrase(struct archive_read *);
  32 extern const char * __archive_read_next_passphrase(struct archive_read *);
  33
  34 static void
  35 test(int pristine)
  36 {
  37         struct archive* a = archive_read_new();
  38
  39         if (!pristine) {
  40                 archive_read_support_filter_all(a);
  41                 archive_read_support_format_all(a);
  42         }
  43
  44         assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass1"));
  45         /* An empty passphrase cannot be accepted. */
  46         assertEqualInt(ARCHIVE_FAILED, archive_read_add_passphrase(a, ""));
  47         /* NULL passphrases cannot be accepted. */
  48         assertEqualInt(ARCHIVE_FAILED, archive_read_add_passphrase(a, NULL));
  49
  50         archive_read_free(a);
  51 }
  52
  53 DEFINE_TEST(test_archive_read_add_passphrase)
  54 {
  55         test(1);
  56         test(0);
  57 }
  58
  59 DEFINE_TEST(test_archive_read_add_passphrase_incorrect_sequance)
  60 {
  61         struct archive* a = archive_read_new();
  62         struct archive_read *ar = (struct archive_read *)a;
  63
  64         assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass1"));
  65
  66         /* No call of __archive_read_reset_passphrase() leads to
  67          * get NULL even if a user has passed a passphrases. */
  68         assertEqualString(NULL, __archive_read_next_passphrase(ar));
  69
  70         archive_read_free(a);
  71 }
  72
  73 DEFINE_TEST(test_archive_read_add_passphrase_single)
  74 {
  75         struct archive* a = archive_read_new();
  76         struct archive_read *ar = (struct archive_read *)a;
  77
  78         assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass1"));
  79
  80         __archive_read_reset_passphrase(ar);
  81         /* Fist call, we should get "pass1" as a passphrase. */
  82         assertEqualString("pass1", __archive_read_next_passphrase(ar));
  83         /* Second call, we should get NULL which means all the pssphrases
  84          * are passed already. */
  85         assertEqualString(NULL, __archive_read_next_passphrase(ar));
  86
  87         archive_read_free(a);
  88 }
  89
  90 DEFINE_TEST(test_archive_read_add_passphrase_multiple)
  91 {
  92         struct archive* a = archive_read_new();
  93         struct archive_read *ar = (struct archive_read *)a;
  94
  95         assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass1"));
  96         assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass2"));
  97
  98         __archive_read_reset_passphrase(ar);
  99         /* Fist call, we should get "pass1" as a passphrase. */
 100         assertEqualString("pass1", __archive_read_next_passphrase(ar));
 101         /* Second call, we should get "pass2" as a passphrase. */
 102         assertEqualString("pass2", __archive_read_next_passphrase(ar));
 103         /* Third call, we should get NULL which means all the pssphrases
 104          * are passed already. */
 105         assertEqualString(NULL, __archive_read_next_passphrase(ar));
 106
 107         archive_read_free(a);
 108 }
 109
 110 static const char *
 111 callback1(struct archive *a, void *_client_data)
 112 {
 113         (void)a; /* UNUSED */
 114         (void)_client_data; /* UNUSED */
 115         return ("passCallBack");
 116 }
 117
 118 DEFINE_TEST(test_archive_read_add_passphrase_set_callback1)
 119 {
 120         struct archive* a = archive_read_new();
 121         struct archive_read *ar = (struct archive_read *)a;
 122
 123         assertEqualInt(ARCHIVE_OK,
 124             archive_read_set_passphrase_callback(a, NULL, callback1));
 125
 126         __archive_read_reset_passphrase(ar);
 127         /* Fist call, we should get "passCallBack" as a passphrase. */
 128         assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
 129         /* Second call, we still get "passCallBack" as a passphrase. */
 130         assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
 131
 132         archive_read_free(a);
 133
 134         /* Without __archive_read_reset_passphrase call, the callback
 135          * should work fine. */
 136         a = archive_read_new();
 137         ar = (struct archive_read *)a;
 138         assertEqualInt(ARCHIVE_OK,
 139             archive_read_set_passphrase_callback(a, NULL, callback1));
 140         /* Fist call, we should get "passCallBack" as a passphrase. */
 141         assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
 142         /* Second call, we still get "passCallBack" as a passphrase. */
 143         assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
 144
 145         archive_read_free(a);
 146 }
 147
 148 static const char *
 149 callback2(struct archive *a, void *_client_data)
 150 {
 151         int *cd = (int *)_client_data;
 152
 153         (void)a; /* UNUSED */
 154
 155         if (*cd == 0) {
 156                 *cd = 1;
 157                 return ("passCallBack");
 158         }
 159         return (NULL);
 160 }
 161
 162 DEFINE_TEST(test_archive_read_add_passphrase_set_callback2)
 163 {
 164         struct archive* a = archive_read_new();
 165         struct archive_read *ar = (struct archive_read *)a;
 166         int client_data = 0;
 167
 168         assertEqualInt(ARCHIVE_OK,
 169             archive_read_set_passphrase_callback(a, &client_data, callback2));
 170
 171         __archive_read_reset_passphrase(ar);
 172         /* Fist call, we should get "passCallBack" as a passphrase. */
 173         assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
 174         /* Second call, we should get NULL which means all the pssphrases
 175          * are passed already. */
 176         assertEqualString(NULL, __archive_read_next_passphrase(ar));
 177
 178         archive_read_free(a);
 179 }
 180
 181 DEFINE_TEST(test_archive_read_add_passphrase_set_callback3)
 182 {
 183         struct archive* a = archive_read_new();
 184         struct archive_read *ar = (struct archive_read *)a;
 185         int client_data = 0;
 186
 187         assertEqualInt(ARCHIVE_OK,
 188             archive_read_set_passphrase_callback(a, &client_data, callback2));
 189
 190         __archive_read_reset_passphrase(ar);
 191         /* Fist call, we should get "passCallBack" as a passphrase. */
 192         assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
 193         __archive_read_reset_passphrase(ar);
 194         /* After reset passphrase, we should get "passCallBack"passphrase. */
 195         assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
 196         /* Second call, we should get NULL which means all the pssphrases
 197          * are passed already. */
 198         assertEqualString(NULL, __archive_read_next_passphrase(ar));
 199
 200         archive_read_free(a);
 201 }
 202
 203 DEFINE_TEST(test_archive_read_add_passphrase_multiple_with_callback)
 204 {
 205         struct archive* a = archive_read_new();
 206         struct archive_read *ar = (struct archive_read *)a;
 207         int client_data = 0;
 208
 209         assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass1"));
 210         assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass2"));
 211         assertEqualInt(ARCHIVE_OK,
 212             archive_read_set_passphrase_callback(a, &client_data, callback2));
 213
 214         __archive_read_reset_passphrase(ar);
 215         /* Fist call, we should get "pass1" as a passphrase. */
 216         assertEqualString("pass1", __archive_read_next_passphrase(ar));
 217         /* Second call, we should get "pass2" as a passphrase. */
 218         assertEqualString("pass2", __archive_read_next_passphrase(ar));
 219         /* Third call, we should get "passCallBack" as a passphrase. */
 220         assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
 221         /* Fourth call, we should get NULL which means all the pssphrases
 222          * are passed already. */
 223         assertEqualString(NULL, __archive_read_next_passphrase(ar));
 224
 225         archive_read_free(a);
 226 }
 227
 228 DEFINE_TEST(test_archive_read_add_passphrase_multiple_with_callback2)
 229 {
 230         struct archive* a = archive_read_new();
 231         struct archive_read *ar = (struct archive_read *)a;
 232         int client_data = 0;
 233
 234         assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass1"));
 235         assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass2"));
 236         assertEqualInt(ARCHIVE_OK,
 237             archive_read_set_passphrase_callback(a, &client_data, callback2));
 238
 239         __archive_read_reset_passphrase(ar);
 240         /* Fist call, we should get "pass1" as a passphrase. */
 241         assertEqualString("pass1", __archive_read_next_passphrase(ar));
 242         /* Second call, we should get "pass2" as a passphrase. */
 243         assertEqualString("pass2", __archive_read_next_passphrase(ar));
 244         /* Third call, we should get "passCallBack" as a passphrase. */
 245         assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
 246
 247         __archive_read_reset_passphrase(ar);
 248         /* After reset passphrase, we should get "passCallBack" passphrase. */
 249         assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
 250         /* Second call, we should get "pass1" as a passphrase. */
 251         assertEqualString("pass1", __archive_read_next_passphrase(ar));
 252         /* Third call, we should get "passCallBack" as a passphrase. */
 253         assertEqualString("pass2", __archive_read_next_passphrase(ar));
 254         /* Fourth call, we should get NULL which means all the pssphrases
 255          * are passed already. */
 256         assertEqualString(NULL, __archive_read_next_passphrase(ar));
 257
 258         archive_read_free(a);
 259 }
 260