1 /*
2 * SPDX-License-Identifier: BSD-2-Clause
3 * Copyright 2019, Intel Corporation
4 */
5
6 #ifdef HAVE_CONFIG_H
7 #include <config.h>
8 #endif
9
10 #include <limits.h>
11 #include <stdio.h>
12 #include <stddef.h>
13 #include <stdlib.h>
14 #include <string.h>
15
16 #include <setjmp.h>
17 #include <cmocka.h>
18
19 #include "tss2_tctildr.h"
20 #include "tss2_tcti.h"
21 #include "tss2-tcti/tctildr.h"
22
23 static TSS2_TCTI_CONTEXT_COMMON_V2 tcti_ctx = { 0, };
24 static TSS2_TCTILDR_CONTEXT tctildr_ctx = { 0, };
25
26 TSS2_RC
local_init(TSS2_TCTI_CONTEXT * tctiContext,size_t * size,const char * config)27 local_init (
28 TSS2_TCTI_CONTEXT *tctiContext,
29 size_t *size,
30 const char *config)
31 {
32 *size = mock_type (size_t);
33 return mock_type (TSS2_RC);
34 }
35
36 void
tcti_from_init_null_init(void ** state)37 tcti_from_init_null_init (void **state)
38 {
39 TSS2_RC rc = tcti_from_init (NULL, NULL, NULL);
40 assert_int_equal (rc, TSS2_TCTI_RC_BAD_REFERENCE);
41 }
42
43 #define TEST_MAGIC_SIZE (size_t)5513444
44 #define TEST_INIT_RC_FAIL (TSS2_RC)0x6134
45 void
tcti_from_init_init_fail(void ** state)46 tcti_from_init_init_fail (void **state)
47 {
48 will_return(local_init, TEST_MAGIC_SIZE);
49 will_return(local_init, TEST_INIT_RC_FAIL);
50 TSS2_TCTI_CONTEXT *tcti_ctx = NULL;
51 TSS2_RC rc = tcti_from_init (local_init, NULL, &tcti_ctx);
52 assert_int_equal (rc, TEST_INIT_RC_FAIL);
53 }
54
55 void* __real_calloc (size_t nmemb, size_t size);
56 void*
__wrap_calloc(size_t nmemb,size_t size)57 __wrap_calloc (size_t nmemb, size_t size)
58 {
59 if (size == TEST_MAGIC_SIZE || size == sizeof (TSS2_TCTILDR_CONTEXT))
60 return mock_type (void*);
61 else
62 return __real_calloc (nmemb, size);
63 }
64 void __real_free (void *ptr);
65 void
__wrap_free(void * ptr)66 __wrap_free (void *ptr)
67 {
68 if (ptr != &tcti_ctx && ptr != &tctildr_ctx)
69 __real_free (ptr);
70 return;
71 }
72 TSS2_RC
__wrap_tctildr_get_info(const char * name,const TSS2_TCTI_INFO ** info,void ** data)73 __wrap_tctildr_get_info (const char *name,
74 const TSS2_TCTI_INFO **info,
75 void **data)
76 {
77 return TSS2_RC_SUCCESS;
78 }
79 TSS2_RC
__wrap_tctildr_get_tcti(const char * name,const char * conf,TSS2_TCTI_CONTEXT ** tcti,void ** data)80 __wrap_tctildr_get_tcti (const char *name,
81 const char* conf,
82 TSS2_TCTI_CONTEXT **tcti,
83 void **data)
84 {
85 TSS2_RC rc = mock_type (TSS2_RC);
86 if (rc == TSS2_RC_SUCCESS) {
87 *tcti= mock_type (TSS2_TCTI_CONTEXT*);
88 *data = mock_type (void*);
89 }
90 return rc;
91 }
__wrap_tctildr_finalize_data(void ** data)92 void __wrap_tctildr_finalize_data (void **data){}
93
94 void
tcti_from_init_calloc_fail(void ** state)95 tcti_from_init_calloc_fail (void **state)
96 {
97 will_return(local_init, TEST_MAGIC_SIZE);
98 will_return(local_init, TSS2_RC_SUCCESS);
99 TSS2_TCTI_CONTEXT *tcti_ctx = NULL;
100 will_return(__wrap_calloc, NULL);
101 TSS2_RC rc = tcti_from_init (local_init, NULL, &tcti_ctx);
102 assert_int_equal (rc, TSS2_ESYS_RC_MEMORY);
103 }
104 void
tcti_from_init_second_init_fail(void ** state)105 tcti_from_init_second_init_fail (void **state)
106 {
107 will_return(local_init, TEST_MAGIC_SIZE);
108 will_return(local_init, TSS2_RC_SUCCESS);
109 TSS2_TCTI_CONTEXT *tcti_ctx_ptr = NULL;
110 will_return(__wrap_calloc, &tcti_ctx);
111 will_return(local_init, TEST_MAGIC_SIZE);
112 will_return(local_init, TEST_INIT_RC_FAIL);
113 TSS2_RC rc = tcti_from_init (local_init, NULL, &tcti_ctx_ptr);
114 assert_int_equal (rc, TEST_INIT_RC_FAIL);
115 }
116
117 void
tcti_from_init_success(void ** state)118 tcti_from_init_success (void **state)
119 {
120 will_return(local_init, TEST_MAGIC_SIZE);
121 will_return(local_init, TSS2_RC_SUCCESS);
122 TSS2_TCTI_CONTEXT *tcti_ctx_ptr = NULL;
123 will_return(__wrap_calloc, &tcti_ctx);
124 will_return(local_init, TEST_MAGIC_SIZE);
125 will_return(local_init, TSS2_RC_SUCCESS);
126 TSS2_RC rc = tcti_from_init (local_init, NULL, &tcti_ctx_ptr);
127 assert_int_equal (rc, TSS2_RC_SUCCESS);
128 }
129 TSS2_TCTI_INFO info = { .init = local_init, };
130 const TSS2_TCTI_INFO*
local_info(void)131 local_info (void)
132 {
133 return mock_type (const TSS2_TCTI_INFO*);
134 }
135 void
tcti_from_info_info_null(void ** state)136 tcti_from_info_info_null (void **state)
137 {
138 TSS2_TCTI_CONTEXT *tcti_ctx_ptr = NULL;
139
140 will_return (local_info, NULL);
141 TSS2_RC rc = tcti_from_info (local_info, NULL, &tcti_ctx_ptr);
142 assert_int_equal (rc, TSS2_ESYS_RC_GENERAL_FAILURE);
143 }
144 void
tcti_from_info_info_fail(void ** state)145 tcti_from_info_info_fail (void **state)
146 {
147 TSS2_TCTI_CONTEXT *tcti_ctx_ptr = NULL;
148
149 will_return (local_info, &info);
150 will_return(local_init, TEST_MAGIC_SIZE);
151 will_return(local_init, TEST_INIT_RC_FAIL);
152 TSS2_RC rc = tcti_from_info (local_info, NULL, &tcti_ctx_ptr);
153 assert_int_equal (rc, TEST_INIT_RC_FAIL);
154 }
155 void
tcti_from_info_success(void ** state)156 tcti_from_info_success (void **state)
157 {
158 TSS2_TCTI_CONTEXT *tcti_ctx_ptr = NULL;
159
160 will_return (local_info, &info);
161 will_return(local_init, TEST_MAGIC_SIZE);
162 will_return(local_init, TSS2_RC_SUCCESS);
163 will_return(__wrap_calloc, &tcti_ctx);
164 will_return(local_init, TEST_MAGIC_SIZE);
165 will_return(local_init, TSS2_RC_SUCCESS);
166 TSS2_RC rc = tcti_from_info (local_info, NULL, &tcti_ctx_ptr);
167 assert_int_equal (rc, TSS2_RC_SUCCESS);
168 }
169 void
test_conf_parse_null(void ** state)170 test_conf_parse_null (void **state)
171 {
172 TSS2_RC rc = tctildr_conf_parse (NULL, NULL, NULL);
173 assert_int_equal (rc, TSS2_TCTI_RC_BAD_REFERENCE);
174 }
175
176 void
test_conf_parse_bad_length(void ** state)177 test_conf_parse_bad_length (void **state)
178 {
179 char name_buf[0], conf_buf[0];
180 char name[PATH_MAX+1];
181 memset(&name[0], 'a', sizeof(name));
182 name[PATH_MAX] = '\0';
183 TSS2_RC rc = tctildr_conf_parse (name, name_buf, conf_buf);
184 assert_int_equal (rc, TSS2_TCTI_RC_BAD_VALUE);
185 }
186 void
test_conf_parse_empty_str(void ** state)187 test_conf_parse_empty_str (void **state)
188 {
189 char name_buf[0], conf_buf[0];
190 TSS2_RC rc = tctildr_conf_parse ("", name_buf, conf_buf);
191 assert_int_equal (rc, TSS2_RC_SUCCESS);
192 }
193 void
test_conf_parse_no_colon(void ** state)194 test_conf_parse_no_colon (void **state)
195 {
196 char name_buf[50] = { 0, }, conf_buf[50] = { 0, };
197 TSS2_RC rc = tctildr_conf_parse ("foo", name_buf, conf_buf);
198 assert_int_equal (rc, TSS2_RC_SUCCESS);
199 }
200 void
test_conf_parse_name_colon(void ** state)201 test_conf_parse_name_colon (void **state)
202 {
203 char name_buf[50] = { 0, }, conf_buf[50] = { 0, };
204 TSS2_RC rc = tctildr_conf_parse ("foo:", name_buf, conf_buf);
205 assert_string_equal (name_buf, "foo");
206 assert_int_equal (rc, TSS2_RC_SUCCESS);
207 }
208 void
test_conf_parse_name_colon_conf(void ** state)209 test_conf_parse_name_colon_conf (void **state)
210 {
211 char name_buf[50] = { 0, }, conf_buf[50] = { 0, };
212 TSS2_RC rc = tctildr_conf_parse ("foo:bar", name_buf, conf_buf);
213 assert_string_equal (name_buf, "foo");
214 assert_string_equal (conf_buf, "bar");
215 assert_int_equal (rc, TSS2_RC_SUCCESS);
216 }
217 /* tctildr init begin */
218 static void
tctildr_init_ex_null_test(void ** state)219 tctildr_init_ex_null_test (void **state)
220 {
221 TSS2_RC rc;
222
223 rc = Tss2_TctiLdr_Initialize_Ex (NULL, NULL, NULL);
224 assert_int_equal (rc, TSS2_TCTI_RC_BAD_VALUE);
225 }
226 static void
tctildr_init_null_test(void ** state)227 tctildr_init_null_test (void **state)
228 {
229 TSS2_RC rc;
230
231 rc = Tss2_TctiLdr_Initialize (NULL, NULL);
232 assert_int_equal (rc, TSS2_TCTI_RC_BAD_VALUE);
233 }
234 static void
tctildr_init_conf_fail_test(void ** state)235 tctildr_init_conf_fail_test (void **state)
236 {
237 TSS2_RC rc;
238 char name[PATH_MAX+1];
239 memset(&name[0], 'a', sizeof(name));
240 name[PATH_MAX] = '\0';
241 rc = Tss2_TctiLdr_Initialize (name, NULL);
242 assert_int_equal (rc, TSS2_TCTI_RC_BAD_VALUE);
243 }
244 static void
tctildr_init_ex_default_fail(void ** state)245 tctildr_init_ex_default_fail (void **state)
246 {
247 TSS2_RC rc;
248 TSS2_TCTI_CONTEXT *context;
249
250 will_return (__wrap_tctildr_get_tcti, TSS2_TCTI_RC_BAD_REFERENCE);
251 rc = Tss2_TctiLdr_Initialize_Ex (NULL, NULL, &context);
252 assert_int_equal (rc, TSS2_TCTI_RC_BAD_REFERENCE);
253 }
254 static void
tctildr_init_ex_from_file_fail(void ** state)255 tctildr_init_ex_from_file_fail (void **state)
256 {
257 TSS2_RC rc;
258 TSS2_TCTI_CONTEXT *context;
259
260 will_return (__wrap_tctildr_get_tcti, TSS2_TCTI_RC_BAD_REFERENCE);
261 rc = Tss2_TctiLdr_Initialize_Ex ("foo", NULL, &context);
262 assert_int_equal (rc, TSS2_TCTI_RC_BAD_REFERENCE);
263 }
264 #define TEST_TCTI_HANDLE (TSS2_TCTI_LIBRARY_HANDLE)0x9827635
265 static void
tctildr_init_ex_calloc_fail_test(void ** state)266 tctildr_init_ex_calloc_fail_test (void **state)
267 {
268 TSS2_RC rc;
269 TSS2_TCTI_CONTEXT *ctx;
270
271 will_return (__wrap_tctildr_get_tcti, TSS2_RC_SUCCESS);
272 will_return (__wrap_tctildr_get_tcti, &tcti_ctx);
273 will_return (__wrap_tctildr_get_tcti, TEST_TCTI_HANDLE);
274 will_return (__wrap_calloc, NULL);
275
276 rc = Tss2_TctiLdr_Initialize_Ex (NULL, NULL, &ctx);
277 assert_int_equal (rc, TSS2_TCTI_RC_MEMORY);
278 }
279 static void
tctildr_init_ex_success_test(void ** state)280 tctildr_init_ex_success_test (void **state)
281 {
282 TSS2_RC rc;
283 TSS2_TCTI_CONTEXT *ctx;
284
285 will_return (__wrap_tctildr_get_tcti, TSS2_RC_SUCCESS);
286 will_return (__wrap_tctildr_get_tcti, &tcti_ctx);
287 will_return (__wrap_tctildr_get_tcti, TEST_TCTI_HANDLE);
288 will_return (__wrap_calloc, &tctildr_ctx);
289
290 rc = Tss2_TctiLdr_Initialize_Ex (NULL, NULL, &ctx);
291 assert_int_equal (rc, TSS2_RC_SUCCESS);
292 }
293 static void
tctildr_finalize_null_ref_test(void ** state)294 tctildr_finalize_null_ref_test (void **state)
295 {
296 Tss2_TctiLdr_Finalize (NULL);
297 assert_int_equal (1, 1);
298 }
299 static void
tctildr_finalize_null_ctx_test(void ** state)300 tctildr_finalize_null_ctx_test (void **state)
301 {
302 TSS2_TCTI_CONTEXT *ctx = NULL;
303 Tss2_TctiLdr_Finalize (&ctx);
304 assert_int_equal (1, 1);
305 }
306 static void
tctildr_finalize_test(void ** state)307 tctildr_finalize_test (void **state)
308 {
309 TSS2_TCTI_CONTEXT *ctx = (TSS2_TCTI_CONTEXT*)&tctildr_ctx;
310
311 TSS2_TCTI_VERSION(&tctildr_ctx) = 3;
312 tctildr_ctx.library_handle = TEST_TCTI_HANDLE;
313 TSS2_TCTI_MAGIC(&tctildr_ctx) = TCTILDR_MAGIC;
314 tctildr_ctx.tcti = (TSS2_TCTI_CONTEXT*)&tcti_ctx;
315 Tss2_TctiLdr_Finalize (&ctx);
316 assert_null (ctx);
317 }
318 /* tctildr init end */
319 int
main(void)320 main(void)
321 {
322 const struct CMUnitTest tests[] = {
323 cmocka_unit_test(tcti_from_init_null_init),
324 cmocka_unit_test(tcti_from_init_init_fail),
325 cmocka_unit_test(tcti_from_init_calloc_fail),
326 cmocka_unit_test(tcti_from_init_second_init_fail),
327 cmocka_unit_test(tcti_from_init_success),
328 cmocka_unit_test(tcti_from_info_info_null),
329 cmocka_unit_test(tcti_from_info_info_fail),
330 cmocka_unit_test(tcti_from_info_success),
331 cmocka_unit_test(test_conf_parse_null),
332 cmocka_unit_test(test_conf_parse_bad_length),
333 cmocka_unit_test(test_conf_parse_empty_str),
334 cmocka_unit_test(test_conf_parse_no_colon),
335 cmocka_unit_test(test_conf_parse_name_colon),
336 cmocka_unit_test(test_conf_parse_name_colon_conf),
337 cmocka_unit_test (tctildr_init_ex_null_test),
338 cmocka_unit_test (tctildr_init_null_test),
339 cmocka_unit_test (tctildr_init_conf_fail_test),
340 cmocka_unit_test (tctildr_init_ex_default_fail),
341 cmocka_unit_test (tctildr_init_ex_from_file_fail),
342 cmocka_unit_test (tctildr_init_ex_calloc_fail_test),
343 cmocka_unit_test (tctildr_init_ex_success_test),
344 cmocka_unit_test (tctildr_finalize_null_ref_test),
345 cmocka_unit_test (tctildr_finalize_null_ctx_test),
346 cmocka_unit_test (tctildr_finalize_test),
347 };
348 return cmocka_run_group_tests (tests, NULL, NULL);
349 }
350