test_archive_read_add_passphrase.c revision 313570 
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: stable/11/contrib/libarchive/libarchive/test/test_archive_read_add_passphrase.c 313570 2017-02-11 00:54:16Z mm $");
29
30struct archive_read;
31extern void __archive_read_reset_passphrase(struct archive_read *);
32extern const char * __archive_read_next_passphrase(struct archive_read *);
33
34static void
35test(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
53DEFINE_TEST(test_archive_read_add_passphrase)
54{
55	test(1);
56	test(0);
57}
58
59DEFINE_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
73DEFINE_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 passphrases
84	 * are passed already. */
85	assertEqualString(NULL, __archive_read_next_passphrase(ar));
86
87	archive_read_free(a);
88}
89
90DEFINE_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 passphrases
104	 * are passed already. */
105	assertEqualString(NULL, __archive_read_next_passphrase(ar));
106
107	archive_read_free(a);
108}
109
110static const char *
111callback1(struct archive *a, void *_client_data)
112{
113	(void)a; /* UNUSED */
114	(void)_client_data; /* UNUSED */
115	return ("passCallBack");
116}
117
118DEFINE_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
148static const char *
149callback2(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
162DEFINE_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 passphrases
175	 * are passed already. */
176	assertEqualString(NULL, __archive_read_next_passphrase(ar));
177
178	archive_read_free(a);
179}
180
181DEFINE_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 passphrases
197	 * are passed already. */
198	assertEqualString(NULL, __archive_read_next_passphrase(ar));
199
200	archive_read_free(a);
201}
202
203DEFINE_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 passphrases
222	 * are passed already. */
223	assertEqualString(NULL, __archive_read_next_passphrase(ar));
224
225	archive_read_free(a);
226}
227
228DEFINE_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 passphrases
255	 * are passed already. */
256	assertEqualString(NULL, __archive_read_next_passphrase(ar));
257
258	archive_read_free(a);
259}
260
261