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
29 struct archive_read;
30 extern void __archive_read_reset_passphrase(struct archive_read *);
31 extern const char * __archive_read_next_passphrase(struct archive_read *);
32
33 static void
test(int pristine)34 test(int pristine)
35 {
36 struct archive* a = archive_read_new();
37
38 if (!pristine) {
39 archive_read_support_filter_all(a);
40 archive_read_support_format_all(a);
41 }
42
43 assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass1"));
44 /* An empty passphrase cannot be accepted. */
45 assertEqualInt(ARCHIVE_FAILED, archive_read_add_passphrase(a, ""));
46 /* NULL passphrases cannot be accepted. */
47 assertEqualInt(ARCHIVE_FAILED, archive_read_add_passphrase(a, NULL));
48
49 archive_read_free(a);
50 }
51
DEFINE_TEST(test_archive_read_add_passphrase)52 DEFINE_TEST(test_archive_read_add_passphrase)
53 {
54 test(1);
55 test(0);
56 }
57
DEFINE_TEST(test_archive_read_add_passphrase_incorrect_sequance)58 DEFINE_TEST(test_archive_read_add_passphrase_incorrect_sequance)
59 {
60 struct archive* a = archive_read_new();
61 struct archive_read *ar = (struct archive_read *)a;
62
63 assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass1"));
64
65 /* No call of __archive_read_reset_passphrase() leads to
66 * get NULL even if a user has passed a passphrases. */
67 assertEqualString(NULL, __archive_read_next_passphrase(ar));
68
69 archive_read_free(a);
70 }
71
DEFINE_TEST(test_archive_read_add_passphrase_single)72 DEFINE_TEST(test_archive_read_add_passphrase_single)
73 {
74 struct archive* a = archive_read_new();
75 struct archive_read *ar = (struct archive_read *)a;
76
77 assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass1"));
78
79 __archive_read_reset_passphrase(ar);
80 /* Fist call, we should get "pass1" as a passphrase. */
81 assertEqualString("pass1", __archive_read_next_passphrase(ar));
82 /* Second call, we should get NULL which means all the passphrases
83 * are passed already. */
84 assertEqualString(NULL, __archive_read_next_passphrase(ar));
85
86 archive_read_free(a);
87 }
88
DEFINE_TEST(test_archive_read_add_passphrase_multiple)89 DEFINE_TEST(test_archive_read_add_passphrase_multiple)
90 {
91 struct archive* a = archive_read_new();
92 struct archive_read *ar = (struct archive_read *)a;
93
94 assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass1"));
95 assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass2"));
96
97 __archive_read_reset_passphrase(ar);
98 /* Fist call, we should get "pass1" as a passphrase. */
99 assertEqualString("pass1", __archive_read_next_passphrase(ar));
100 /* Second call, we should get "pass2" as a passphrase. */
101 assertEqualString("pass2", __archive_read_next_passphrase(ar));
102 /* Third call, we should get NULL which means all the passphrases
103 * are passed already. */
104 assertEqualString(NULL, __archive_read_next_passphrase(ar));
105
106 archive_read_free(a);
107 }
108
109 static const char *
callback1(struct archive * a,void * _client_data)110 callback1(struct archive *a, void *_client_data)
111 {
112 (void)a; /* UNUSED */
113 (void)_client_data; /* UNUSED */
114 return ("passCallBack");
115 }
116
DEFINE_TEST(test_archive_read_add_passphrase_set_callback1)117 DEFINE_TEST(test_archive_read_add_passphrase_set_callback1)
118 {
119 struct archive* a = archive_read_new();
120 struct archive_read *ar = (struct archive_read *)a;
121
122 assertEqualInt(ARCHIVE_OK,
123 archive_read_set_passphrase_callback(a, NULL, callback1));
124
125 __archive_read_reset_passphrase(ar);
126 /* Fist call, we should get "passCallBack" as a passphrase. */
127 assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
128 /* Second call, we still get "passCallBack" as a passphrase. */
129 assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
130
131 archive_read_free(a);
132
133 /* Without __archive_read_reset_passphrase call, the callback
134 * should work fine. */
135 a = archive_read_new();
136 ar = (struct archive_read *)a;
137 assertEqualInt(ARCHIVE_OK,
138 archive_read_set_passphrase_callback(a, NULL, callback1));
139 /* Fist call, we should get "passCallBack" as a passphrase. */
140 assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
141 /* Second call, we still get "passCallBack" as a passphrase. */
142 assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
143
144 archive_read_free(a);
145 }
146
147 static const char *
callback2(struct archive * a,void * _client_data)148 callback2(struct archive *a, void *_client_data)
149 {
150 int *cd = (int *)_client_data;
151
152 (void)a; /* UNUSED */
153
154 if (*cd == 0) {
155 *cd = 1;
156 return ("passCallBack");
157 }
158 return (NULL);
159 }
160
DEFINE_TEST(test_archive_read_add_passphrase_set_callback2)161 DEFINE_TEST(test_archive_read_add_passphrase_set_callback2)
162 {
163 struct archive* a = archive_read_new();
164 struct archive_read *ar = (struct archive_read *)a;
165 int client_data = 0;
166
167 assertEqualInt(ARCHIVE_OK,
168 archive_read_set_passphrase_callback(a, &client_data, callback2));
169
170 __archive_read_reset_passphrase(ar);
171 /* Fist call, we should get "passCallBack" as a passphrase. */
172 assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
173 /* Second call, we should get NULL which means all the passphrases
174 * are passed already. */
175 assertEqualString(NULL, __archive_read_next_passphrase(ar));
176
177 archive_read_free(a);
178 }
179
DEFINE_TEST(test_archive_read_add_passphrase_set_callback3)180 DEFINE_TEST(test_archive_read_add_passphrase_set_callback3)
181 {
182 struct archive* a = archive_read_new();
183 struct archive_read *ar = (struct archive_read *)a;
184 int client_data = 0;
185
186 assertEqualInt(ARCHIVE_OK,
187 archive_read_set_passphrase_callback(a, &client_data, callback2));
188
189 __archive_read_reset_passphrase(ar);
190 /* Fist call, we should get "passCallBack" as a passphrase. */
191 assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
192 __archive_read_reset_passphrase(ar);
193 /* After reset passphrase, we should get "passCallBack" passphrase. */
194 assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
195 /* Second call, we should get NULL which means all the passphrases
196 * are passed already. */
197 assertEqualString(NULL, __archive_read_next_passphrase(ar));
198
199 archive_read_free(a);
200 }
201
DEFINE_TEST(test_archive_read_add_passphrase_multiple_with_callback)202 DEFINE_TEST(test_archive_read_add_passphrase_multiple_with_callback)
203 {
204 struct archive* a = archive_read_new();
205 struct archive_read *ar = (struct archive_read *)a;
206 int client_data = 0;
207
208 assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass1"));
209 assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass2"));
210 assertEqualInt(ARCHIVE_OK,
211 archive_read_set_passphrase_callback(a, &client_data, callback2));
212
213 __archive_read_reset_passphrase(ar);
214 /* Fist call, we should get "pass1" as a passphrase. */
215 assertEqualString("pass1", __archive_read_next_passphrase(ar));
216 /* Second call, we should get "pass2" as a passphrase. */
217 assertEqualString("pass2", __archive_read_next_passphrase(ar));
218 /* Third call, we should get "passCallBack" as a passphrase. */
219 assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
220 /* Fourth call, we should get NULL which means all the passphrases
221 * are passed already. */
222 assertEqualString(NULL, __archive_read_next_passphrase(ar));
223
224 archive_read_free(a);
225 }
226
DEFINE_TEST(test_archive_read_add_passphrase_multiple_with_callback2)227 DEFINE_TEST(test_archive_read_add_passphrase_multiple_with_callback2)
228 {
229 struct archive* a = archive_read_new();
230 struct archive_read *ar = (struct archive_read *)a;
231 int client_data = 0;
232
233 assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass1"));
234 assertEqualInt(ARCHIVE_OK, archive_read_add_passphrase(a, "pass2"));
235 assertEqualInt(ARCHIVE_OK,
236 archive_read_set_passphrase_callback(a, &client_data, callback2));
237
238 __archive_read_reset_passphrase(ar);
239 /* Fist call, we should get "pass1" as a passphrase. */
240 assertEqualString("pass1", __archive_read_next_passphrase(ar));
241 /* Second call, we should get "pass2" as a passphrase. */
242 assertEqualString("pass2", __archive_read_next_passphrase(ar));
243 /* Third call, we should get "passCallBack" as a passphrase. */
244 assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
245
246 __archive_read_reset_passphrase(ar);
247 /* After reset passphrase, we should get "passCallBack" passphrase. */
248 assertEqualString("passCallBack", __archive_read_next_passphrase(ar));
249 /* Second call, we should get "pass1" as a passphrase. */
250 assertEqualString("pass1", __archive_read_next_passphrase(ar));
251 /* Third call, we should get "passCallBack" as a passphrase. */
252 assertEqualString("pass2", __archive_read_next_passphrase(ar));
253 /* Fourth call, we should get NULL which means all the passphrases
254 * are passed already. */
255 assertEqualString(NULL, __archive_read_next_passphrase(ar));
256
257 archive_read_free(a);
258 }
259
260