1 /*
2 * Copyright 2017-2021 The OpenSSL Project Authors. All Rights Reserved.
3 * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
4 *
5 * Licensed under the Apache License 2.0 (the "License"). You may not use
6 * this file except in compliance with the License. You can obtain a copy
7 * in the file LICENSE in the source distribution or at
8 * https://www.openssl.org/source/license.html
9 */
10
11 #include <stdio.h>
12 #include <string.h>
13
14 #include <openssl/opensslconf.h>
15 #include <openssl/safestack.h>
16 #include <openssl/err.h>
17 #include <openssl/crypto.h>
18
19 #include "internal/nelem.h"
20 #include "testutil.h"
21
22 /* The macros below generate unused functions which error out one of the clang
23 * builds. We disable this check here.
24 */
25 #ifdef __clang__
26 #pragma clang diagnostic ignored "-Wunused-function"
27 #endif
28
29 typedef struct {
30 int n;
31 char c;
32 } SS;
33
34 typedef union {
35 int n;
36 char c;
37 } SU;
38
DEFINE_SPECIAL_STACK_OF(sint,int)39 DEFINE_SPECIAL_STACK_OF(sint, int)
40 DEFINE_SPECIAL_STACK_OF_CONST(uchar, unsigned char)
41 DEFINE_STACK_OF(SS)
42 DEFINE_STACK_OF_CONST(SU)
43
44 static int int_compare(const int *const *a, const int *const *b)
45 {
46 if (**a < **b)
47 return -1;
48 if (**a > **b)
49 return 1;
50 return 0;
51 }
52
test_int_stack(int reserve)53 static int test_int_stack(int reserve)
54 {
55 static int v[] = { 1, 2, -4, 16, 999, 1, -173, 1, 9 };
56 static int notpresent = -1;
57 const int n = OSSL_NELEM(v);
58 static struct {
59 int value;
60 int unsorted;
61 int sorted;
62 int ex;
63 } finds[] = {
64 { 2, 1, 5, 5 },
65 { 9, 7, 6, 6 },
66 { -173, 5, 0, 0 },
67 { 999, 3, 8, 8 },
68 { 0, -1, -1, 1 }
69 };
70 const int n_finds = OSSL_NELEM(finds);
71 static struct {
72 int value;
73 int ex;
74 } exfinds[] = {
75 { 3, 5 },
76 { 1000, 8 },
77 { 20, 8 },
78 { -999, 0 },
79 { -5, 0 },
80 { 8, 5 }
81 };
82 const int n_exfinds = OSSL_NELEM(exfinds);
83 STACK_OF(sint) *s = sk_sint_new_null();
84 int i;
85 int testresult = 0;
86
87 if (!TEST_ptr(s)
88 || (reserve > 0 && !TEST_true(sk_sint_reserve(s, 5 * reserve))))
89 goto end;
90
91 /* Check push and num */
92 for (i = 0; i < n; i++) {
93 if (!TEST_int_eq(sk_sint_num(s), i)) {
94 TEST_info("int stack size %d", i);
95 goto end;
96 }
97 sk_sint_push(s, v + i);
98 }
99 if (!TEST_int_eq(sk_sint_num(s), n))
100 goto end;
101
102 /* check the values */
103 for (i = 0; i < n; i++)
104 if (!TEST_ptr_eq(sk_sint_value(s, i), v + i)) {
105 TEST_info("int value %d", i);
106 goto end;
107 }
108
109 /* find unsorted -- the pointers are compared */
110 for (i = 0; i < n_finds; i++) {
111 int *val = (finds[i].unsorted == -1) ? ¬present
112 : v + finds[i].unsorted;
113
114 if (!TEST_int_eq(sk_sint_find(s, val), finds[i].unsorted)) {
115 TEST_info("int unsorted find %d", i);
116 goto end;
117 }
118 }
119
120 /* find_ex unsorted */
121 for (i = 0; i < n_finds; i++) {
122 int *val = (finds[i].unsorted == -1) ? ¬present
123 : v + finds[i].unsorted;
124
125 if (!TEST_int_eq(sk_sint_find_ex(s, val), finds[i].unsorted)) {
126 TEST_info("int unsorted find_ex %d", i);
127 goto end;
128 }
129 }
130
131 /* sorting */
132 if (!TEST_false(sk_sint_is_sorted(s)))
133 goto end;
134 (void)sk_sint_set_cmp_func(s, &int_compare);
135 sk_sint_sort(s);
136 if (!TEST_true(sk_sint_is_sorted(s)))
137 goto end;
138
139 /* find sorted -- the value is matched so we don't need to locate it */
140 for (i = 0; i < n_finds; i++)
141 if (!TEST_int_eq(sk_sint_find(s, &finds[i].value), finds[i].sorted)) {
142 TEST_info("int sorted find %d", i);
143 goto end;
144 }
145
146 /* find_ex sorted */
147 for (i = 0; i < n_finds; i++)
148 if (!TEST_int_eq(sk_sint_find_ex(s, &finds[i].value), finds[i].ex)) {
149 TEST_info("int sorted find_ex present %d", i);
150 goto end;
151 }
152 for (i = 0; i < n_exfinds; i++)
153 if (!TEST_int_eq(sk_sint_find_ex(s, &exfinds[i].value), exfinds[i].ex)) {
154 TEST_info("int sorted find_ex absent %d", i);
155 goto end;
156 }
157
158 /* shift */
159 if (!TEST_ptr_eq(sk_sint_shift(s), v + 6))
160 goto end;
161
162 testresult = 1;
163 end:
164 sk_sint_free(s);
165 return testresult;
166 }
167
uchar_compare(const unsigned char * const * a,const unsigned char * const * b)168 static int uchar_compare(const unsigned char *const *a,
169 const unsigned char *const *b)
170 {
171 return **a - (signed int)**b;
172 }
173
test_uchar_stack(int reserve)174 static int test_uchar_stack(int reserve)
175 {
176 static const unsigned char v[] = { 1, 3, 7, 5, 255, 0 };
177 const int n = OSSL_NELEM(v);
178 STACK_OF(uchar) *s = sk_uchar_new(&uchar_compare), *r = NULL;
179 int i;
180 int testresult = 0;
181
182 if (!TEST_ptr(s)
183 || (reserve > 0 && !TEST_true(sk_uchar_reserve(s, 5 * reserve))))
184 goto end;
185
186 /* unshift and num */
187 for (i = 0; i < n; i++) {
188 if (!TEST_int_eq(sk_uchar_num(s), i)) {
189 TEST_info("uchar stack size %d", i);
190 goto end;
191 }
192 sk_uchar_unshift(s, v + i);
193 }
194 if (!TEST_int_eq(sk_uchar_num(s), n))
195 goto end;
196
197 /* dup */
198 r = sk_uchar_dup(NULL);
199 if (sk_uchar_num(r) != 0)
200 goto end;
201 sk_uchar_free(r);
202 r = sk_uchar_dup(s);
203 if (!TEST_int_eq(sk_uchar_num(r), n))
204 goto end;
205 sk_uchar_sort(r);
206
207 /* pop */
208 for (i = 0; i < n; i++)
209 if (!TEST_ptr_eq(sk_uchar_pop(s), v + i)) {
210 TEST_info("uchar pop %d", i);
211 goto end;
212 }
213
214 /* free -- we rely on the debug malloc to detect leakage here */
215 sk_uchar_free(s);
216 s = NULL;
217
218 /* dup again */
219 if (!TEST_int_eq(sk_uchar_num(r), n))
220 goto end;
221
222 /* zero */
223 sk_uchar_zero(r);
224 if (!TEST_int_eq(sk_uchar_num(r), 0))
225 goto end;
226
227 /* insert */
228 sk_uchar_insert(r, v, 0);
229 sk_uchar_insert(r, v + 2, -1);
230 sk_uchar_insert(r, v + 1, 1);
231 for (i = 0; i < 3; i++)
232 if (!TEST_ptr_eq(sk_uchar_value(r, i), v + i)) {
233 TEST_info("uchar insert %d", i);
234 goto end;
235 }
236
237 /* delete */
238 if (!TEST_ptr_null(sk_uchar_delete(r, 12)))
239 goto end;
240 if (!TEST_ptr_eq(sk_uchar_delete(r, 1), v + 1))
241 goto end;
242
243 /* set */
244 (void)sk_uchar_set(r, 1, v + 1);
245 for (i = 0; i < 2; i++)
246 if (!TEST_ptr_eq(sk_uchar_value(r, i), v + i)) {
247 TEST_info("uchar set %d", i);
248 goto end;
249 }
250
251 testresult = 1;
252 end:
253 sk_uchar_free(r);
254 sk_uchar_free(s);
255 return testresult;
256 }
257
SS_copy(const SS * p)258 static SS *SS_copy(const SS *p)
259 {
260 SS *q = OPENSSL_malloc(sizeof(*q));
261
262 if (q != NULL)
263 memcpy(q, p, sizeof(*q));
264 return q;
265 }
266
SS_free(SS * p)267 static void SS_free(SS *p)
268 {
269 OPENSSL_free(p);
270 }
271
test_SS_stack(void)272 static int test_SS_stack(void)
273 {
274 STACK_OF(SS) *s = sk_SS_new_null();
275 STACK_OF(SS) *r = NULL;
276 SS *v[10], *p;
277 const int n = OSSL_NELEM(v);
278 int i;
279 int testresult = 0;
280
281 /* allocate and push */
282 for (i = 0; i < n; i++) {
283 v[i] = OPENSSL_malloc(sizeof(*v[i]));
284
285 if (!TEST_ptr(v[i]))
286 goto end;
287 v[i]->n = i;
288 v[i]->c = 'A' + i;
289 if (!TEST_int_eq(sk_SS_num(s), i)) {
290 TEST_info("SS stack size %d", i);
291 goto end;
292 }
293 sk_SS_push(s, v[i]);
294 }
295 if (!TEST_int_eq(sk_SS_num(s), n))
296 goto end;
297
298 /* deepcopy */
299 r = sk_SS_deep_copy(NULL, &SS_copy, &SS_free);
300 if (sk_SS_num(r) != 0)
301 goto end;
302 sk_SS_free(r);
303 r = sk_SS_deep_copy(s, &SS_copy, &SS_free);
304 if (!TEST_ptr(r))
305 goto end;
306 for (i = 0; i < n; i++) {
307 p = sk_SS_value(r, i);
308 if (!TEST_ptr_ne(p, v[i])) {
309 TEST_info("SS deepcopy non-copy %d", i);
310 goto end;
311 }
312 if (!TEST_int_eq(p->n, v[i]->n)) {
313 TEST_info("test SS deepcopy int %d", i);
314 goto end;
315 }
316 if (!TEST_char_eq(p->c, v[i]->c)) {
317 TEST_info("SS deepcopy char %d", i);
318 goto end;
319 }
320 }
321
322 /* pop_free - we rely on the malloc debug to catch the leak */
323 sk_SS_pop_free(r, &SS_free);
324 r = NULL;
325
326 /* delete_ptr */
327 p = sk_SS_delete_ptr(s, v[3]);
328 if (!TEST_ptr(p))
329 goto end;
330 SS_free(p);
331 if (!TEST_int_eq(sk_SS_num(s), n - 1))
332 goto end;
333 for (i = 0; i < n - 1; i++)
334 if (!TEST_ptr_eq(sk_SS_value(s, i), v[i < 3 ? i : 1 + i])) {
335 TEST_info("SS delete ptr item %d", i);
336 goto end;
337 }
338
339 testresult = 1;
340 end:
341 sk_SS_pop_free(r, &SS_free);
342 sk_SS_pop_free(s, &SS_free);
343 return testresult;
344 }
345
test_SU_stack(void)346 static int test_SU_stack(void)
347 {
348 STACK_OF(SU) *s = sk_SU_new_null();
349 SU v[10];
350 const int n = OSSL_NELEM(v);
351 int i;
352 int testresult = 0;
353
354 /* allocate and push */
355 for (i = 0; i < n; i++) {
356 if ((i & 1) == 0)
357 v[i].n = i;
358 else
359 v[i].c = 'A' + i;
360 if (!TEST_int_eq(sk_SU_num(s), i)) {
361 TEST_info("SU stack size %d", i);
362 goto end;
363 }
364 sk_SU_push(s, v + i);
365 }
366 if (!TEST_int_eq(sk_SU_num(s), n))
367 goto end;
368
369 /* check the pointers are correct */
370 for (i = 0; i < n; i++)
371 if (!TEST_ptr_eq(sk_SU_value(s, i), v + i)) {
372 TEST_info("SU pointer check %d", i);
373 goto end;
374 }
375
376 testresult = 1;
377 end:
378 sk_SU_free(s);
379 return testresult;
380 }
381
setup_tests(void)382 int setup_tests(void)
383 {
384 ADD_ALL_TESTS(test_int_stack, 4);
385 ADD_ALL_TESTS(test_uchar_stack, 4);
386 ADD_TEST(test_SS_stack);
387 ADD_TEST(test_SU_stack);
388 return 1;
389 }
390