1 /*
2 * Copyright (c) 2021-2025 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 "softbus_client_frame_manager.h"
17
18 #include <securec.h>
19 #include <string.h>
20
21 #include "client_bus_center_manager.h"
22 #include "client_trans_session_manager.h"
23 #include "client_trans_socket_manager.h"
24 #include "comm_log.h"
25 #include "general_connection_server_proxy.h"
26 #include "g_enhance_sdk_func.h"
27 #include "g_enhance_adapter_func.h"
28 #include "softbus_adapter_mem.h"
29 #include "softbus_adapter_thread.h"
30 #include "softbus_base_listener.h"
31 #include "softbus_client_event_manager.h"
32 #include "softbus_client_stub_interface.h"
33 #include "softbus_def.h"
34 #include "softbus_error_code.h"
35 #include "softbus_feature_config.h"
36 #include "softbus_socket.h"
37 #include "softbus_utils.h"
38 #include "softbus_client_init.h"
39 #include "softbus_init_common.h"
40
41 static bool g_isInited = false;
42 static SoftBusMutex g_isInitedLock;
43 typedef struct PkgNameInfo {
44 ListNode node;
45 char pkgName[PKG_NAME_SIZE_MAX];
46 } PkgNameInfo;
47
48 static SoftBusMutex g_pkgNameLock;
49 static LIST_HEAD(g_pkgNameList);
50
CheckPkgNameInfo(const char * pkgName)51 static bool CheckPkgNameInfo(const char *pkgName)
52 {
53 ListNode *item = NULL;
54 PkgNameInfo *info = NULL;
55 uint32_t totalNum = 0;
56 LIST_FOR_EACH(item, &g_pkgNameList) {
57 totalNum++;
58 info = LIST_ENTRY(item, PkgNameInfo, node);
59 if (strcmp(info->pkgName, pkgName) == 0) {
60 return false;
61 }
62 }
63 if (totalNum >= SOFTBUS_PKGNAME_MAX_NUM) {
64 COMM_LOGI(COMM_SDK, "number of pkgName exceeds maximum");
65 return false;
66 }
67 return true;
68 }
69
AddClientPkgName(const char * pkgName)70 static int32_t AddClientPkgName(const char *pkgName)
71 {
72 if (!CheckPkgNameInfo(pkgName)) {
73 COMM_LOGD(COMM_SDK, "check PkgNameInfo invalid.");
74 return SOFTBUS_INVALID_PKGNAME;
75 }
76 if (SoftBusMutexLock(&g_pkgNameLock) != SOFTBUS_OK) {
77 COMM_LOGE(COMM_SDK, "lock init failed");
78 return SOFTBUS_LOCK_ERR;
79 }
80 PkgNameInfo *info = (PkgNameInfo *)SoftBusCalloc(sizeof(PkgNameInfo));
81 if (info == NULL) {
82 COMM_LOGE(COMM_SDK, "Create PkgNameInfo malloc fail.");
83 SoftBusMutexUnlock(&g_pkgNameLock);
84 return SOFTBUS_MALLOC_ERR;
85 }
86 if (strcpy_s(info->pkgName, PKG_NAME_SIZE_MAX, pkgName) != EOK) {
87 COMM_LOGE(COMM_SDK, "strcpy_s pkgName failed.");
88 SoftBusFree(info);
89 SoftBusMutexUnlock(&g_pkgNameLock);
90 return SOFTBUS_STRCPY_ERR;
91 }
92 ListInit(&info->node);
93 ListAdd(&g_pkgNameList, &info->node);
94 SoftBusMutexUnlock(&g_pkgNameLock);
95 return SOFTBUS_OK;
96 }
97
DelClientPkgName(const char * pkgName)98 static void DelClientPkgName(const char *pkgName)
99 {
100 if (SoftBusMutexLock(&g_pkgNameLock) != SOFTBUS_OK) {
101 COMM_LOGE(COMM_SDK, "del lock init failed");
102 return;
103 }
104 ListNode *item = NULL;
105 ListNode *nextItem = NULL;
106 PkgNameInfo *info = NULL;
107 LIST_FOR_EACH_SAFE(item, nextItem, &g_pkgNameList) {
108 info = LIST_ENTRY(item, PkgNameInfo, node);
109 if (strcmp(pkgName, info->pkgName) == 0) {
110 ListDelete(&info->node);
111 SoftBusFree(info);
112 break;
113 }
114 }
115 SoftBusMutexUnlock(&g_pkgNameLock);
116 }
117
ClientRegisterPkgName(const char * pkgName)118 static int32_t ClientRegisterPkgName(const char *pkgName)
119 {
120 int32_t ret = AddClientPkgName(pkgName);
121 if (ret != SOFTBUS_OK) {
122 COMM_LOGD(COMM_SDK, "AddClientPkgName failed. ret=%{public}d", ret);
123 return ret;
124 }
125 ret = ClientRegisterService(pkgName);
126 if (ret != SOFTBUS_OK) {
127 COMM_LOGE(COMM_SDK, "ClientRegisterService failed. ret=%{public}d", ret);
128 DelClientPkgName(pkgName);
129 return ret;
130 }
131 COMM_LOGD(COMM_SDK, "ClientRegisterService success");
132 return SOFTBUS_OK;
133 }
134
FreeClientPkgName(void)135 static void FreeClientPkgName(void)
136 {
137 if (SoftBusMutexLock(&g_pkgNameLock) != SOFTBUS_OK) {
138 COMM_LOGE(COMM_SDK, "lock init failed");
139 return;
140 }
141 ListNode *item = NULL;
142 ListNode *nextItem = NULL;
143 PkgNameInfo *info = NULL;
144 LIST_FOR_EACH_SAFE(item, nextItem, &g_pkgNameList) {
145 info = LIST_ENTRY(item, PkgNameInfo, node);
146 ListDelete(&info->node);
147 SoftBusFree(info);
148 }
149 SoftBusMutexUnlock(&g_pkgNameLock);
150 }
151
ConnClientDeinit(void)152 static void ConnClientDeinit(void)
153 {
154 (void)DeinitBaseListener();
155 (void)ConnDeinitSockets();
156 (void)ConnectionServerProxyDeInit();
157 }
158
ClientModuleDeinit(void)159 static void ClientModuleDeinit(void)
160 {
161 EventClientDeinit();
162 BusCenterClientDeinit();
163 TransClientDeinit();
164 ConnClientDeinit();
165 }
166
ConnClientInit(void)167 static int32_t ConnClientInit(void)
168 {
169 int32_t ret = ConnInitSockets();
170 if (ret != SOFTBUS_OK) {
171 COMM_LOGE(COMM_EVENT, "ConnInitSockets failed! ret=%{public}d", ret);
172 return ret;
173 }
174
175 ret = InitBaseListener();
176 if (ret != SOFTBUS_OK) {
177 COMM_LOGE(COMM_EVENT, "InitBaseListener failed! ret=%{public}d", ret);
178 return ret;
179 }
180
181 ret = ConnectionServerProxyInit();
182 if (ret != SOFTBUS_OK) {
183 COMM_LOGE(COMM_EVENT, "ConnectionServerProxyInit failed! ret=%{public}d", ret);
184 return ret;
185 }
186
187 COMM_LOGD(COMM_EVENT, "init conn client success");
188 return ret;
189 }
190
ClientFuncInit(void)191 static void ClientFuncInit(void)
192 {
193 int ret = SOFTBUS_OK;
194 void *soHandle = NULL;
195 (void)SoftBusDlopen(SOFTBUS_HANDLE_CLIENT_PLUGIN, &soHandle);
196 if (soHandle == NULL) {
197 COMM_LOGE(COMM_SDK, "dlopen libdsoftbus_client_plugin.z.so failed.");
198 return;
199 }
200
201 ret = SoftBusClientOpenFuncInit(soHandle);
202 if (ret != SOFTBUS_OK) {
203 COMM_LOGE(COMM_SDK, "init softbus client Open func failed");
204 }
205
206 ret = ClientRegisterEnhanceFunc(soHandle);
207 if (ret != SOFTBUS_OK) {
208 COMM_LOGE(COMM_SDK, "init softbus client Enhance func failed");
209 }
210
211 return;
212 }
213
ClientModuleInit(void)214 static int32_t ClientModuleInit(void)
215 {
216 SoftbusConfigInit();
217 if (EventClientInit() != SOFTBUS_OK) {
218 COMM_LOGE(COMM_SDK, "init event manager failed");
219 goto ERR_EXIT;
220 }
221
222 if (BusCenterClientInit() != SOFTBUS_OK) {
223 COMM_LOGE(COMM_SDK, "init bus center failed");
224 goto ERR_EXIT;
225 }
226
227 if (ConnClientInit() != SOFTBUS_OK) {
228 COMM_LOGE(COMM_SDK, "init connect manager failed");
229 goto ERR_EXIT;
230 }
231
232 if (TransClientInit() != SOFTBUS_OK) {
233 COMM_LOGE(COMM_SDK, "init trans manager failed");
234 goto ERR_EXIT;
235 }
236
237 return SOFTBUS_OK;
238
239 ERR_EXIT:
240 COMM_LOGD(COMM_SDK, "softbus sdk frame init failed.");
241 ClientModuleDeinit();
242 return SOFTBUS_NO_INIT;
243 }
244
InitSoftBus(const char * pkgName)245 int32_t InitSoftBus(const char *pkgName)
246 {
247 ClientFuncInit();
248 COMM_CHECK_AND_RETURN_RET_LOGE(IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1),
249 SOFTBUS_INVALID_PKGNAME, COMM_SDK, "init softbus sdk fail.Package name is empty or length exceeds");
250
251 COMM_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexInit(
252 &g_pkgNameLock, NULL) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_SDK, "lock init pkgName failed");
253
254 COMM_CHECK_AND_RETURN_RET_LOGE((g_isInited || SoftBusMutexInit(
255 &g_isInitedLock, NULL) == SOFTBUS_OK), SOFTBUS_LOCK_ERR, COMM_SDK, "lock init failed");
256
257 COMM_CHECK_AND_RETURN_RET_LOGE(
258 SoftBusMutexLock(&g_isInitedLock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, COMM_SDK, "lock failed");
259
260 if (g_isInited) {
261 (void)ClientRegisterPkgName(pkgName);
262 SoftBusMutexUnlock(&g_isInitedLock);
263 return SOFTBUS_OK;
264 }
265 if (AddClientPkgName(pkgName) != SOFTBUS_OK) {
266 SoftBusMutexUnlock(&g_isInitedLock);
267 COMM_LOGE(COMM_SDK, "AddClientPkgName failed.");
268 return SOFTBUS_INVALID_PKGNAME;
269 }
270 if (SoftBusTimerInit() != SOFTBUS_OK) {
271 COMM_LOGE(COMM_SDK, "client timer init fail");
272 goto EXIT;
273 }
274 if (ClientModuleInit() != SOFTBUS_OK) {
275 COMM_LOGE(COMM_SDK, "ctx init fail");
276 goto EXIT;
277 }
278 if (ClientStubInit() != SOFTBUS_OK) {
279 COMM_LOGE(COMM_SDK, "service init fail");
280 goto EXIT;
281 }
282
283 if (ClientRegisterService(pkgName) != SOFTBUS_OK) {
284 COMM_LOGE(COMM_SDK, "ClientRegisterService fail");
285 goto EXIT;
286 }
287 g_isInited = true;
288 SoftBusMutexUnlock(&g_isInitedLock);
289 COMM_LOGD(COMM_SDK, "softbus sdk frame init success.");
290 return SOFTBUS_OK;
291 EXIT:
292 FreeClientPkgName();
293 SoftBusMutexUnlock(&g_isInitedLock);
294 return SOFTBUS_NO_INIT;
295 }
296
GetSoftBusClientNameList(char * pkgList[],uint32_t len)297 uint32_t GetSoftBusClientNameList(char *pkgList[], uint32_t len)
298 {
299 if (pkgList == NULL || len == 0) {
300 return 0;
301 }
302 if (SoftBusMutexLock(&g_pkgNameLock) != SOFTBUS_OK) {
303 COMM_LOGE(COMM_SDK, "lock init failed");
304 return 0;
305 }
306 ListNode *item = NULL;
307 uint32_t subscript = 0;
308 LIST_FOR_EACH(item, &g_pkgNameList) {
309 PkgNameInfo *info = LIST_ENTRY(item, PkgNameInfo, node);
310 char *pkgName = (char *)SoftBusCalloc(PKG_NAME_SIZE_MAX);
311 if (pkgName == NULL) {
312 COMM_LOGE(COMM_SDK, "get client name malloc fail");
313 goto EXIT;
314 }
315 if (strcpy_s(pkgName, PKG_NAME_SIZE_MAX, info->pkgName) != EOK) {
316 COMM_LOGE(COMM_SDK, "get client name strcpy_s failed");
317 SoftBusFree(pkgName);
318 goto EXIT;
319 }
320 pkgList[subscript] = pkgName;
321 subscript++;
322 if (subscript >= len) {
323 break;
324 }
325 }
326 SoftBusMutexUnlock(&g_pkgNameLock);
327 return subscript;
328
329 EXIT:
330 for (uint32_t i = 0; i < subscript; i++) {
331 SoftBusFree(pkgList[i]);
332 }
333 SoftBusMutexUnlock(&g_pkgNameLock);
334 return 0;
335 }
336
CheckPackageName(const char * pkgName)337 int32_t CheckPackageName(const char *pkgName)
338 {
339 (void)pkgName;
340 #ifdef __LITEOS_M__
341 return SOFTBUS_OK;
342 #else
343 if (SoftBusMutexLock(&g_pkgNameLock) != SOFTBUS_OK) {
344 COMM_LOGE(COMM_SDK, "lock init failed");
345 return SOFTBUS_LOCK_ERR;
346 }
347 ListNode *item = NULL;
348 PkgNameInfo *info = NULL;
349 LIST_FOR_EACH(item, &g_pkgNameList) {
350 info = LIST_ENTRY(item, PkgNameInfo, node);
351 if (strcmp(info->pkgName, pkgName) == 0) {
352 SoftBusMutexUnlock(&g_pkgNameLock);
353 return SOFTBUS_OK;
354 }
355 }
356 SoftBusMutexUnlock(&g_pkgNameLock);
357 return SOFTBUS_INVALID_PKGNAME;
358 #endif
359 }
360