xref: /openssl/test/bio_callback_test.c (revision 38fc02a7)
1 /*
2  * Copyright 2018-2021 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9 #define OPENSSL_SUPPRESS_DEPRECATED
10 #include <stdio.h>
11 #include <string.h>
12 #include <openssl/bio.h>
13 
14 #include "testutil.h"
15 
16 #define MAXCOUNT 5
17 static int         my_param_count;
18 static BIO        *my_param_b[MAXCOUNT];
19 static int         my_param_oper[MAXCOUNT];
20 static const char *my_param_argp[MAXCOUNT];
21 static int         my_param_argi[MAXCOUNT];
22 static long        my_param_argl[MAXCOUNT];
23 static long        my_param_ret[MAXCOUNT];
24 static size_t      my_param_len[MAXCOUNT];
25 static size_t      my_param_processed[MAXCOUNT];
26 
my_bio_cb_ex(BIO * b,int oper,const char * argp,size_t len,int argi,long argl,int ret,size_t * processed)27 static long my_bio_cb_ex(BIO *b, int oper, const char *argp, size_t len,
28                          int argi, long argl, int ret, size_t *processed)
29 {
30     if (my_param_count >= MAXCOUNT)
31         return -1;
32     my_param_b[my_param_count]    = b;
33     my_param_oper[my_param_count] = oper;
34     my_param_argp[my_param_count] = argp;
35     my_param_argi[my_param_count] = argi;
36     my_param_argl[my_param_count] = argl;
37     my_param_ret[my_param_count]  = ret;
38     my_param_len[my_param_count]  = len;
39     my_param_processed[my_param_count] = processed != NULL ? *processed : 0;
40 
41     my_param_count++;
42     return ret;
43 }
44 
test_bio_callback_ex(void)45 static int test_bio_callback_ex(void)
46 {
47     int ok = 0;
48     BIO *bio;
49     int i;
50     char test1[] = "test";
51     const size_t test1len = sizeof(test1) - 1;
52     char test2[] = "hello";
53     const size_t test2len = sizeof(test2) - 1;
54     char buf[16];
55 
56     my_param_count = 0;
57 
58     bio = BIO_new(BIO_s_mem());
59     if (bio == NULL)
60         goto err;
61 
62     BIO_set_callback_ex(bio, my_bio_cb_ex);
63     i = BIO_write(bio, test1, test1len);
64     if (!TEST_int_eq(i, test1len)
65             || !TEST_int_eq(my_param_count, 2)
66             || !TEST_ptr_eq(my_param_b[0], bio)
67             || !TEST_int_eq(my_param_oper[0], BIO_CB_WRITE)
68             || !TEST_ptr_eq(my_param_argp[0], test1)
69             || !TEST_size_t_eq(my_param_len[0], test1len)
70             || !TEST_long_eq(my_param_argl[0], 0L)
71             || !TEST_int_eq((int)my_param_ret[0], 1)
72             || !TEST_ptr_eq(my_param_b[1], bio)
73             || !TEST_int_eq(my_param_oper[1], BIO_CB_WRITE | BIO_CB_RETURN)
74             || !TEST_ptr_eq(my_param_argp[1], test1)
75             || !TEST_size_t_eq(my_param_len[1], test1len)
76             || !TEST_long_eq(my_param_argl[1], 0L)
77             || !TEST_size_t_eq(my_param_processed[1], test1len)
78             || !TEST_int_eq((int)my_param_ret[1], 1))
79         goto err;
80 
81     my_param_count = 0;
82     i = BIO_read(bio, buf, sizeof(buf));
83     if (!TEST_mem_eq(buf, i, test1, test1len)
84             || !TEST_int_eq(my_param_count, 2)
85             || !TEST_ptr_eq(my_param_b[0], bio)
86             || !TEST_int_eq(my_param_oper[0], BIO_CB_READ)
87             || !TEST_ptr_eq(my_param_argp[0], buf)
88             || !TEST_size_t_eq(my_param_len[0], sizeof(buf))
89             || !TEST_long_eq(my_param_argl[0], 0L)
90             || !TEST_int_eq((int)my_param_ret[0], 1)
91             || !TEST_ptr_eq(my_param_b[1], bio)
92             || !TEST_int_eq(my_param_oper[1], BIO_CB_READ | BIO_CB_RETURN)
93             || !TEST_ptr_eq(my_param_argp[1], buf)
94             || !TEST_size_t_eq(my_param_len[1], sizeof(buf))
95             || !TEST_long_eq(my_param_argl[1], 0L)
96             || !TEST_size_t_eq(my_param_processed[1], test1len)
97             || !TEST_int_eq((int)my_param_ret[1], 1))
98         goto err;
99 
100     /* By default a mem bio returns -1 if it has run out of data */
101     my_param_count = 0;
102     i = BIO_read(bio, buf, sizeof(buf));
103     if (!TEST_int_eq(i, -1)
104             || !TEST_int_eq(my_param_count, 2)
105             || !TEST_ptr_eq(my_param_b[0], bio)
106             || !TEST_int_eq(my_param_oper[0], BIO_CB_READ)
107             || !TEST_ptr_eq(my_param_argp[0], buf)
108             || !TEST_size_t_eq(my_param_len[0], sizeof(buf))
109             || !TEST_long_eq(my_param_argl[0], 0L)
110             || !TEST_int_eq((int)my_param_ret[0], 1)
111             || !TEST_ptr_eq(my_param_b[1], bio)
112             || !TEST_int_eq(my_param_oper[1], BIO_CB_READ | BIO_CB_RETURN)
113             || !TEST_ptr_eq(my_param_argp[1], buf)
114             || !TEST_size_t_eq(my_param_len[1], sizeof(buf))
115             || !TEST_long_eq(my_param_argl[1], 0L)
116             || !TEST_size_t_eq(my_param_processed[1], 0)
117             || !TEST_int_eq((int)my_param_ret[1], -1))
118         goto err;
119 
120     /* Force the mem bio to return 0 if it has run out of data */
121     my_param_count = 0;
122     i = BIO_set_mem_eof_return(bio, 0);
123     if (!TEST_int_eq(i, 1)
124             || !TEST_int_eq(my_param_count, 2)
125             || !TEST_ptr_eq(my_param_b[0], bio)
126             || !TEST_int_eq(my_param_oper[0], BIO_CB_CTRL)
127             || !TEST_ptr_eq(my_param_argp[0], NULL)
128             || !TEST_int_eq(my_param_argi[0], BIO_C_SET_BUF_MEM_EOF_RETURN)
129             || !TEST_long_eq(my_param_argl[0], 0L)
130             || !TEST_int_eq((int)my_param_ret[0], 1)
131             || !TEST_ptr_eq(my_param_b[1], bio)
132             || !TEST_int_eq(my_param_oper[1], BIO_CB_CTRL | BIO_CB_RETURN)
133             || !TEST_ptr_eq(my_param_argp[1], NULL)
134             || !TEST_int_eq(my_param_argi[1], BIO_C_SET_BUF_MEM_EOF_RETURN)
135             || !TEST_long_eq(my_param_argl[1], 0L)
136             || !TEST_int_eq((int)my_param_ret[1], 1))
137         goto err;
138     my_param_count = 0;
139     i = BIO_read(bio, buf, sizeof(buf));
140     if (!TEST_int_eq(i, 0)
141             || !TEST_int_eq(my_param_count, 2)
142             || !TEST_ptr_eq(my_param_b[0], bio)
143             || !TEST_int_eq(my_param_oper[0], BIO_CB_READ)
144             || !TEST_ptr_eq(my_param_argp[0], buf)
145             || !TEST_size_t_eq(my_param_len[0], sizeof(buf))
146             || !TEST_long_eq(my_param_argl[0], 0L)
147             || !TEST_int_eq((int)my_param_ret[0], 1)
148             || !TEST_ptr_eq(my_param_b[1], bio)
149             || !TEST_int_eq(my_param_oper[1], BIO_CB_READ | BIO_CB_RETURN)
150             || !TEST_ptr_eq(my_param_argp[1], buf)
151             || !TEST_size_t_eq(my_param_len[1], sizeof(buf))
152             || !TEST_long_eq(my_param_argl[1], 0L)
153             || !TEST_size_t_eq(my_param_processed[1], 0)
154             || !TEST_int_eq((int)my_param_ret[1], 0))
155         goto err;
156 
157     my_param_count = 0;
158     i = BIO_puts(bio, test2);
159     if (!TEST_int_eq(i, 5)
160             || !TEST_int_eq(my_param_count, 2)
161             || !TEST_ptr_eq(my_param_b[0], bio)
162             || !TEST_int_eq(my_param_oper[0], BIO_CB_PUTS)
163             || !TEST_ptr_eq(my_param_argp[0], test2)
164             || !TEST_int_eq(my_param_argi[0], 0)
165             || !TEST_long_eq(my_param_argl[0], 0L)
166             || !TEST_int_eq((int)my_param_ret[0], 1)
167             || !TEST_ptr_eq(my_param_b[1], bio)
168             || !TEST_int_eq(my_param_oper[1], BIO_CB_PUTS | BIO_CB_RETURN)
169             || !TEST_ptr_eq(my_param_argp[1], test2)
170             || !TEST_int_eq(my_param_argi[1], 0)
171             || !TEST_long_eq(my_param_argl[1], 0L)
172             || !TEST_size_t_eq(my_param_processed[1], test2len)
173             || !TEST_int_eq((int)my_param_ret[1], 1))
174         goto err;
175 
176     my_param_count = 0;
177     i = BIO_free(bio);
178     if (!TEST_int_eq(i, 1)
179             || !TEST_int_eq(my_param_count, 1)
180             || !TEST_ptr_eq(my_param_b[0], bio)
181             || !TEST_int_eq(my_param_oper[0], BIO_CB_FREE)
182             || !TEST_ptr_eq(my_param_argp[0], NULL)
183             || !TEST_int_eq(my_param_argi[0], 0)
184             || !TEST_long_eq(my_param_argl[0], 0L)
185             || !TEST_int_eq((int)my_param_ret[0], 1))
186         goto finish;
187 
188     ok = 1;
189     goto finish;
190 
191 err:
192     BIO_free(bio);
193 
194 finish:
195     /* This helps finding memory leaks with ASAN */
196     memset(my_param_b, 0, sizeof(my_param_b));
197     memset(my_param_argp, 0, sizeof(my_param_argp));
198     return ok;
199 }
200 
201 #ifndef OPENSSL_NO_DEPRECATED_3_0
my_bio_callback(BIO * b,int oper,const char * argp,int argi,long argl,long ret)202 static long my_bio_callback(BIO *b, int oper, const char *argp, int argi,
203                             long argl, long ret)
204 {
205     if (my_param_count >= MAXCOUNT)
206         return -1;
207     my_param_b[my_param_count]    = b;
208     my_param_oper[my_param_count] = oper;
209     my_param_argp[my_param_count] = argp;
210     my_param_argi[my_param_count] = argi;
211     my_param_argl[my_param_count] = argl;
212     my_param_ret[my_param_count]  = ret;
213     my_param_count++;
214     return ret;
215 }
216 
test_bio_callback(void)217 static int test_bio_callback(void)
218 {
219     int ok = 0;
220     BIO *bio;
221     int i;
222     char test1[] = "test";
223     const int test1len = sizeof(test1) - 1;
224     char test2[] = "hello";
225     const int test2len = sizeof(test2) - 1;
226     char buf[16];
227 
228     my_param_count = 0;
229 
230     bio = BIO_new(BIO_s_mem());
231     if (bio == NULL)
232         goto err;
233 
234     BIO_set_callback(bio, my_bio_callback);
235     i = BIO_write(bio, test1, test1len);
236     if (!TEST_int_eq(i, test1len)
237             || !TEST_int_eq(my_param_count, 2)
238             || !TEST_ptr_eq(my_param_b[0], bio)
239             || !TEST_int_eq(my_param_oper[0], BIO_CB_WRITE)
240             || !TEST_ptr_eq(my_param_argp[0], test1)
241             || !TEST_int_eq(my_param_argi[0], test1len)
242             || !TEST_long_eq(my_param_argl[0], 0L)
243             || !TEST_long_eq(my_param_ret[0], 1L)
244             || !TEST_ptr_eq(my_param_b[1], bio)
245             || !TEST_int_eq(my_param_oper[1], BIO_CB_WRITE | BIO_CB_RETURN)
246             || !TEST_ptr_eq(my_param_argp[1], test1)
247             || !TEST_int_eq(my_param_argi[1], test1len)
248             || !TEST_long_eq(my_param_argl[1], 0L)
249             || !TEST_long_eq(my_param_ret[1], (long)test1len))
250         goto err;
251 
252     my_param_count = 0;
253     i = BIO_read(bio, buf, sizeof(buf));
254     if (!TEST_mem_eq(buf, i, test1, test1len)
255             || !TEST_int_eq(my_param_count, 2)
256             || !TEST_ptr_eq(my_param_b[0], bio)
257             || !TEST_int_eq(my_param_oper[0], BIO_CB_READ)
258             || !TEST_ptr_eq(my_param_argp[0], buf)
259             || !TEST_int_eq(my_param_argi[0], sizeof(buf))
260             || !TEST_long_eq(my_param_argl[0], 0L)
261             || !TEST_long_eq(my_param_ret[0], 1L)
262             || !TEST_ptr_eq(my_param_b[1], bio)
263             || !TEST_int_eq(my_param_oper[1], BIO_CB_READ | BIO_CB_RETURN)
264             || !TEST_ptr_eq(my_param_argp[1], buf)
265             || !TEST_int_eq(my_param_argi[1], sizeof(buf))
266             || !TEST_long_eq(my_param_argl[1], 0L)
267             || !TEST_long_eq(my_param_ret[1], (long)test1len))
268         goto err;
269 
270     /* By default a mem bio returns -1 if it has run out of data */
271     my_param_count = 0;
272     i = BIO_read(bio, buf, sizeof(buf));
273     if (!TEST_int_eq(i, -1)
274             || !TEST_int_eq(my_param_count, 2)
275             || !TEST_ptr_eq(my_param_b[0], bio)
276             || !TEST_int_eq(my_param_oper[0], BIO_CB_READ)
277             || !TEST_ptr_eq(my_param_argp[0], buf)
278             || !TEST_int_eq(my_param_argi[0], sizeof(buf))
279             || !TEST_long_eq(my_param_argl[0], 0L)
280             || !TEST_long_eq(my_param_ret[0], 1L)
281             || !TEST_ptr_eq(my_param_b[1], bio)
282             || !TEST_int_eq(my_param_oper[1], BIO_CB_READ | BIO_CB_RETURN)
283             || !TEST_ptr_eq(my_param_argp[1], buf)
284             || !TEST_int_eq(my_param_argi[1], sizeof(buf))
285             || !TEST_long_eq(my_param_argl[1], 0L)
286             || !TEST_long_eq(my_param_ret[1], -1L))
287         goto err;
288 
289     /* Force the mem bio to return 0 if it has run out of data */
290     BIO_set_mem_eof_return(bio, 0);
291     my_param_count = 0;
292     i = BIO_read(bio, buf, sizeof(buf));
293     if (!TEST_int_eq(i, 0)
294             || !TEST_int_eq(my_param_count, 2)
295             || !TEST_ptr_eq(my_param_b[0], bio)
296             || !TEST_int_eq(my_param_oper[0], BIO_CB_READ)
297             || !TEST_ptr_eq(my_param_argp[0], buf)
298             || !TEST_int_eq(my_param_argi[0], sizeof(buf))
299             || !TEST_long_eq(my_param_argl[0], 0L)
300             || !TEST_long_eq(my_param_ret[0], 1L)
301             || !TEST_ptr_eq(my_param_b[1], bio)
302             || !TEST_int_eq(my_param_oper[1], BIO_CB_READ | BIO_CB_RETURN)
303             || !TEST_ptr_eq(my_param_argp[1], buf)
304             || !TEST_int_eq(my_param_argi[1], sizeof(buf))
305             || !TEST_long_eq(my_param_argl[1], 0L)
306             || !TEST_long_eq(my_param_ret[1], 0L))
307         goto err;
308 
309     my_param_count = 0;
310     i = BIO_puts(bio, test2);
311     if (!TEST_int_eq(i, 5)
312             || !TEST_int_eq(my_param_count, 2)
313             || !TEST_ptr_eq(my_param_b[0], bio)
314             || !TEST_int_eq(my_param_oper[0], BIO_CB_PUTS)
315             || !TEST_ptr_eq(my_param_argp[0], test2)
316             || !TEST_int_eq(my_param_argi[0], 0)
317             || !TEST_long_eq(my_param_argl[0], 0L)
318             || !TEST_long_eq(my_param_ret[0], 1L)
319             || !TEST_ptr_eq(my_param_b[1], bio)
320             || !TEST_int_eq(my_param_oper[1], BIO_CB_PUTS | BIO_CB_RETURN)
321             || !TEST_ptr_eq(my_param_argp[1], test2)
322             || !TEST_int_eq(my_param_argi[1], 0)
323             || !TEST_long_eq(my_param_argl[1], 0L)
324             || !TEST_long_eq(my_param_ret[1], (long)test2len))
325         goto err;
326 
327     my_param_count = 0;
328     i = BIO_free(bio);
329     if (!TEST_int_eq(i, 1)
330             || !TEST_int_eq(my_param_count, 1)
331             || !TEST_ptr_eq(my_param_b[0], bio)
332             || !TEST_int_eq(my_param_oper[0], BIO_CB_FREE)
333             || !TEST_ptr_eq(my_param_argp[0], NULL)
334             || !TEST_int_eq(my_param_argi[0], 0)
335             || !TEST_long_eq(my_param_argl[0], 0L)
336             || !TEST_long_eq(my_param_ret[0], 1L))
337         goto finish;
338 
339     ok = 1;
340     goto finish;
341 
342 err:
343     BIO_free(bio);
344 
345 finish:
346     /* This helps finding memory leaks with ASAN */
347     memset(my_param_b, 0, sizeof(my_param_b));
348     memset(my_param_argp, 0, sizeof(my_param_argp));
349     return ok;
350 }
351 #endif
352 
setup_tests(void)353 int setup_tests(void)
354 {
355     ADD_TEST(test_bio_callback_ex);
356 #ifndef OPENSSL_NO_DEPRECATED_3_0
357     ADD_TEST(test_bio_callback);
358 #endif
359     return 1;
360 }
361