1 /**
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <dlfcn.h>
17 #include <errno.h>
18 #include <stdio.h>
19 #include <string.h>
20
21 #include "dlns_test.h"
22 #include "functionalext.h"
23
24
25 /**
26 * @tc.name : dlopen_0100
27 * @tc.desc : Enter a valid path, dlopen compatibility test
28 * @tc.level : Level 0
29 */
dlopen_0100(void)30 void dlopen_0100(void)
31 {
32 void* handle = dlopen(dllNamePath, RTLD_LAZY);
33 EXPECT_TRUE("dlopen_0100", handle);
34 dlclose(handle);
35 }
36
37
38 /**
39 * @tc.name : dlopen_0200
40 * @tc.desc : Enter invalid path, dlopen compatibility test
41 * @tc.level : Level 2
42 */
dlopen_0200(void)43 void dlopen_0200(void)
44 {
45 void* handle = dlopen(errPath_ns, RTLD_LAZY);
46 EXPECT_FALSE("dlopen_0200", handle);
47 }
48
49 /**
50 * @tc.name : dlns_init_0100
51 * @tc.desc : Use a string less than 255 bytes as the dlns_init parameter
52 * @tc.level : Level 1
53 */
dlns_init_0100(void)54 void dlns_init_0100(void)
55 {
56 Dl_namespace dlns;
57 char n[] = "dlns_init_0100";
58 dlns_init(&dlns, n);
59 EXPECT_EQ("dlns_init_0100", strcmp(dlns.name, n), 0);
60 }
61
62 /**
63 * @tc.name : dlns_init_0200
64 * @tc.desc : Use very long strings as dlns_init parameters
65 * @tc.level : Level 2
66 */
dlns_init_0200(void)67 void dlns_init_0200(void)
68 {
69 Dl_namespace dlns;
70 int size = 256;
71 char n[] = "012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 \
72 012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 \
73 012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 \
74 012345678901234567890123456789";
75 int len = strlen(n);
76 dlns_init(&dlns, n);
77 EXPECT_TRUE("dlns_init_0200", size < len);
78
79 int dlnslen = strlen(dlns.name);
80 EXPECT_TRUE("dlns_init_0200", size > dlnslen);
81 }
82
83 /**
84 * @tc.name : dlns_create_0100
85 * @tc.desc : Using dlns_create, create a new namespace
86 * @tc.level : Level 1
87 */
dlns_create_0100(void)88 void dlns_create_0100(void)
89 {
90 Dl_namespace dlns;
91 dlns_init(&dlns, "dlns_create_0100");
92
93 EXPECT_EQ("dlns_create_0100", dlns_create(&dlns, path), EOK);
94 }
95
96 /**
97 * @tc.name : dlns_create_0200
98 * @tc.desc : Using dlns_create, create a new namespace
99 * @tc.level : Level 2
100 */
dlns_create_0200(void)101 void dlns_create_0200(void)
102 {
103 // ns_no_allowed_libs already exists
104 Dl_namespace dlns;
105 dlns_init(&dlns, "ns_no_allowed_libs");
106
107 dlns_create(&dlns, NULL);
108 EXPECT_EQ("dlns_create_0200", dlns_create(&dlns, NULL), EEXIST);
109 }
110
111 /**
112 * @tc.name : dlns_create_0300
113 * @tc.desc : After creating a new namespace, check lib_path validity
114 * @tc.level : Level 1
115 */
dlns_create_0300(void)116 void dlns_create_0300(void)
117 {
118 // ns_no_allowed_libs already exists
119 Dl_namespace dlns;
120 dlns_init(&dlns, "dlns_create_0300");
121
122 EXPECT_EQ("dlns_create_0300", dlns_create(&dlns, path), EOK);
123
124 void* handle = dlopen_ns(&dlns, dllName, RTLD_LAZY);
125 EXPECT_TRUE("dlns_create_0300", handle);
126 dlclose(handle);
127 }
128
129 /**
130 * @tc.name : dlns_create_0400
131 * @tc.desc : Namespace creation when dlns=NULL
132 * @tc.level : Level 2
133 */
dlns_create_0400(void)134 void dlns_create_0400(void)
135 {
136 EXPECT_EQ("dlns_create_0400", dlns_create(NULL, path), EINVAL);
137 }
138
139 /**
140 * @tc.name : dlns_create_0500
141 * @tc.desc : Namespace creation when lib_path=NULL
142 * @tc.level : Level 2
143 */
dlns_create_0500(void)144 void dlns_create_0500(void)
145 {
146 Dl_namespace dlns;
147 dlns_init(&dlns, "dlns_create_0500");
148
149 EXPECT_EQ("dlns_create_0500", dlns_create(&dlns, NULL), EOK);
150 }
151
152
153 /**
154 * @tc.name : dlopen_ns_0100
155 * @tc.desc : dlopen_ns valid full path test
156 * @tc.level : Level 1
157 */
dlopen_ns_0100(void)158 void dlopen_ns_0100(void)
159 {
160 Dl_namespace dlns_default;
161 dlns_get(NULL, &dlns_default);
162 Dl_namespace dlns;
163 dlns_init(&dlns, "ns_no_allowed_libs");
164 dlns_inherit(&dlns, &dlns_default, "libc++.so");
165
166 void* handle = dlopen_ns(&dlns, dllNamePath, RTLD_LAZY);
167 EXPECT_TRUE("dlopen_ns_0100", handle);
168 dlclose(handle);
169 }
170
171 /**
172 * @tc.name : dlopen_ns_0200
173 * @tc.desc : dlopen_ns invalid full path test
174 * @tc.level : Level 2
175 */
dlopen_ns_0200(void)176 void dlopen_ns_0200(void)
177 {
178 Dl_namespace dlns_default;
179 dlns_get(NULL, &dlns_default);
180 Dl_namespace dlns;
181 dlns_init(&dlns, "ns_no_allowed_libs");
182 dlns_inherit(&dlns, &dlns_default, "libc++.so");
183
184 void* handle = dlopen_ns(&dlns, errdllNamePath, RTLD_LAZY);
185 EXPECT_FALSE("dlopen_ns_0200", handle);
186 }
187
188 /**
189 * @tc.name : dlopen_ns_0300
190 * @tc.desc : dlopen_ns valid short name test
191 * @tc.level : Level 1
192 */
dlopen_ns_0300(void)193 void dlopen_ns_0300(void)
194 {
195 Dl_namespace dlns_default;
196 dlns_get(NULL, &dlns_default);
197 Dl_namespace dlns;
198 dlns_init(&dlns, "ns_no_allowed_libs");
199 dlns_inherit(&dlns, &dlns_default, "libc++.so");
200
201 void* handle = dlopen_ns(&dlns, dllName, RTLD_LAZY);
202 EXPECT_TRUE("dlopen_ns_0300", handle);
203 dlclose(handle);
204 }
205
206 /**
207 * @tc.name : dlopen_ns_0400
208 * @tc.desc : When dlns=NULL, call dlopen_ns to load the library
209 * @tc.level : Level 1
210 */
dlopen_ns_0400(void)211 void dlopen_ns_0400(void)
212 {
213 void* handle = dlopen_ns(NULL, dllNamePath, RTLD_LAZY);
214 EXPECT_TRUE("dlopen_ns_0400", handle);
215 dlclose(handle);
216 }
217
218 /**
219 * @tc.name : dlopen_ns_0500
220 * @tc.desc : When file=NULL, call dlopen_ns to load the library
221 * @tc.level : Level 2
222 */
dlopen_ns_0500(void)223 void dlopen_ns_0500(void)
224 {
225 Dl_namespace dlns;
226 dlns_init(&dlns, "ns_no_allowed_libs");
227
228 void *handle = dlopen_ns(&dlns, NULL, RTLD_LAZY);
229 EXPECT_TRUE("dlopen_ns_0500", handle);
230 dlclose(handle);
231 }
232
233 /**
234 * @tc.name : dlns_get_0100
235 * @tc.desc : Gets an existing namespace handle.
236 * @tc.level : Level 1
237 */
dlns_get_0100(void)238 void dlns_get_0100(void)
239 {
240 Dl_namespace dlns;
241 dlns_init(&dlns, "dlns_get_0100");
242 dlns_create(&dlns, NULL);
243 dlns_get("dlns_get_0100", &dlns);
244 EXPECT_EQ("dlns_get_0100", strcmp(dlns.name, "dlns_get_0100"), 0);
245 }
246
247 /**
248 * @tc.name : dlns_get_0200
249 * @tc.desc : Gets the current namespace handle when name=NULL.
250 * @tc.level : Level 1
251 */
dlns_get_0200(void)252 void dlns_get_0200(void)
253 {
254 Dl_namespace dlns;
255 dlns_get(NULL, &dlns);
256 EXPECT_EQ("dlns_get_0200", strcmp(dlns.name, "default"), 0);
257 }
258
259 /**
260 * @tc.name : dlns_get_0300
261 * @tc.desc : Call dlns_get when dlns=NULL.
262 * @tc.level : Level 2
263 */
dlns_get_0300(void)264 void dlns_get_0300(void)
265 {
266 dlns_get(NULL, NULL);
267 EXPECT_EQ("dlns_get_0300", dlns_get(NULL, NULL), EINVAL);
268 }
269
270 /**
271 * @tc.name : dlns_get_0400
272 * @tc.desc : Gets a namespace handle that does not exist.
273 * @tc.level : Level 2
274 */
dlns_get_0400(void)275 void dlns_get_0400(void)
276 {
277 Dl_namespace dlns;
278 dlns_init(&dlns, "dlns_get_0400");
279 EXPECT_EQ("dlns_get_0400", dlns_get("dlns_get_0400", &dlns), ENOKEY);
280 }
281
282 /**
283 * @tc.name : dlopen_add_reloc
284 * @tc.desc : Test add_reloc_can_search_dso: not enough memory.
285 * Dlopen lib whth more than 32 dependent libs.(libace.z.so)
286 * @tc.level : Level 1
287 */
dlopen_add_reloc(void)288 void dlopen_add_reloc(void)
289 {
290 void* handle = dlopen(dllAcePath, RTLD_LAZY);
291 EXPECT_TRUE("dlopen_add_reloc", handle);
292 }
293
294 /**
295 * @tc.name : dlopen_relocation
296 * @tc.desc : Test dlopen lib relocation type is REL_DTPMOD/REL_DTPOFF.(libstd.dylib.so)
297 * @tc.level : Level 1
298 */
dlopen_relocation(void)299 void dlopen_relocation(void)
300 {
301 void* handle = dlopen(dllDylibPath, RTLD_LAZY);
302 EXPECT_TRUE("dlopen_relocation", handle);
303 if(handle){
304 dlclose(handle);
305 }
306 }
307
308 /**
309 * @tc.name : dlopen_hash_type
310 * @tc.desc : Test dlopen lib hash type is sysv.(libdlopen_hash_sysv.so)
311 * @tc.level : Level 1
312 */
dlopen_hash_type(void)313 void dlopen_hash_type(void)
314 {
315 void* handle = dlopen(dllHashsysvPath, RTLD_LAZY);
316 EXPECT_TRUE("dlopen_hash_type", handle);
317 if(handle){
318 dlclose(handle);
319 }
320 }
321
322 /**
323 * @tc.name : dlopen_set_rpath
324 * @tc.desc : Test dlopen lib by set rpath.(libdlopen_hash_sysv.so)
325 * @tc.level : Level 1
326 */
dlopen_set_rpath(void)327 void dlopen_set_rpath(void)
328 {
329 void* handle = dlopen(dllHashsysv, RTLD_LAZY);
330 EXPECT_TRUE("dlopen_set_rpath", handle);
331 if(handle){
332 dlclose(handle);
333 }
334 }
335
336 /**
337 * @tc.name : dlopen_fill_random
338 * @tc.desc : Test dlopen lib libdlopen_fill_random.so to coverage fill_random_data.
339 * @tc.level : Level 1
340 */
dlopen_fill_random(void)341 void dlopen_fill_random(void)
342 {
343 void* handle = dlopen(dllFillRandom, RTLD_LAZY);
344 EXPECT_TRUE("dlopen_fill_random", handle);
345 if(handle){
346 dlclose(handle);
347 }
348 }
349
350 TEST_FUN G_Fun_Array[] = {
351 dlopen_0100,
352 dlopen_0200,
353 dlns_init_0100,
354 dlns_init_0200,
355 dlns_create_0100,
356 dlns_create_0200,
357 dlns_create_0300,
358 dlns_create_0400,
359 dlns_create_0500,
360 dlopen_ns_0100,
361 dlopen_ns_0200,
362 dlopen_ns_0300,
363 dlopen_ns_0400,
364 dlopen_ns_0500,
365 dlns_get_0100,
366 dlns_get_0200,
367 dlns_get_0300,
368 dlns_get_0400,
369 dlopen_relocation,
370 dlopen_hash_type,
371 dlopen_set_rpath,
372 dlopen_fill_random,
373 dlopen_add_reloc,
374 };
375
main(void)376 int main(void)
377 {
378 int num = sizeof(G_Fun_Array)/sizeof(TEST_FUN);
379 for (int pos = 0; pos < num; ++pos) {
380 G_Fun_Array[pos]();
381 }
382
383 return t_status;
384 }