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