1 /*
2 * Copyright (c) 2021-2023 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_disc_manager.h"
23 #include "client_trans_session_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_LOGE(COMM_SDK, "check PkgNameInfo invalid.");
69 return SOFTBUS_INVALID_PARAM;
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, "Add strcpy_s failed.");
83 SoftBusFree(info);
84 SoftBusMutexUnlock(&g_pkgNameLock);
85 return SOFTBUS_MEM_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_LOGE(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_LOGI(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 DiscClientDeinit();
160 }
161
ConnClientInit(void)162 static int32_t ConnClientInit(void)
163 {
164 int32_t ret = ConnInitSockets();
165 if (ret != SOFTBUS_OK) {
166 COMM_LOGE(COMM_EVENT, "ConnInitSockets failed! ret=%{public}d", ret);
167 return ret;
168 }
169
170 ret = InitBaseListener();
171 if (ret != SOFTBUS_OK) {
172 COMM_LOGE(COMM_EVENT, "InitBaseListener failed! ret=%{public}d", ret);
173 return ret;
174 }
175 COMM_LOGD(COMM_EVENT, "init conn client success");
176 return ret;
177 }
178
ClientModuleInit(void)179 static int32_t ClientModuleInit(void)
180 {
181 SoftbusConfigInit();
182 if (EventClientInit() != SOFTBUS_OK) {
183 COMM_LOGE(COMM_SDK, "init event manager failed");
184 goto ERR_EXIT;
185 }
186
187 if (BusCenterClientInit() != SOFTBUS_OK) {
188 COMM_LOGE(COMM_SDK, "init bus center failed");
189 goto ERR_EXIT;
190 }
191
192 if (DiscClientInit() != SOFTBUS_OK) {
193 COMM_LOGE(COMM_SDK, "init service manager failed");
194 goto ERR_EXIT;
195 }
196
197 if (ConnClientInit() != SOFTBUS_OK) {
198 COMM_LOGE(COMM_SDK, "init connect manager failed");
199 goto ERR_EXIT;
200 }
201
202 if (TransClientInit() != SOFTBUS_OK) {
203 COMM_LOGE(COMM_SDK, "init trans manager failed");
204 goto ERR_EXIT;
205 }
206
207 return SOFTBUS_OK;
208
209 ERR_EXIT:
210 COMM_LOGE(COMM_SDK, "softbus sdk frame init failed.");
211 ClientModuleDeinit();
212 return SOFTBUS_ERR;
213 }
214
InitSoftBus(const char * pkgName)215 int32_t InitSoftBus(const char *pkgName)
216 {
217 if (!IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1)) {
218 COMM_LOGE(COMM_SDK, "init softbus sdk fail. Package name is empty or length exceeds");
219 return SOFTBUS_INVALID_PARAM;
220 }
221 if (SoftBusMutexInit(&g_pkgNameLock, NULL) != SOFTBUS_OK) {
222 COMM_LOGE(COMM_SDK, "lock init pkgName failed");
223 return SOFTBUS_LOCK_ERR;
224 }
225 if ((!g_isInited) && (SoftBusMutexInit(&g_isInitedLock, NULL) != SOFTBUS_OK)) {
226 COMM_LOGE(COMM_SDK, "lock init failed");
227 return SOFTBUS_LOCK_ERR;
228 }
229 if (SoftBusMutexLock(&g_isInitedLock) != SOFTBUS_OK) {
230 COMM_LOGE(COMM_SDK, "lock failed");
231 return SOFTBUS_LOCK_ERR;
232 }
233 if (g_isInited) {
234 (void)ClientRegisterPkgName(pkgName);
235 SoftBusMutexUnlock(&g_isInitedLock);
236 return SOFTBUS_OK;
237 }
238 if (AddClientPkgName(pkgName) != SOFTBUS_OK) {
239 SoftBusMutexUnlock(&g_isInitedLock);
240 COMM_LOGE(COMM_SDK, "AddClientPkgName failed.");
241 return SOFTBUS_MEM_ERR;
242 }
243 if (SoftBusTimerInit() != SOFTBUS_OK) {
244 COMM_LOGE(COMM_SDK, "client timer init fail");
245 goto EXIT;
246 }
247 if (ClientModuleInit() != SOFTBUS_OK) {
248 COMM_LOGE(COMM_SDK, "ctx init fail");
249 goto EXIT;
250 }
251 if (ClientStubInit() != SOFTBUS_OK) {
252 COMM_LOGE(COMM_SDK, "service init fail");
253 goto EXIT;
254 }
255 if (ClientRegisterService(pkgName) != SOFTBUS_OK) {
256 COMM_LOGE(COMM_SDK, "ClientRegisterService fail");
257 goto EXIT;
258 }
259 g_isInited = true;
260 SoftBusMutexUnlock(&g_isInitedLock);
261 COMM_LOGI(COMM_SDK, "softbus sdk frame init success.");
262 return SOFTBUS_OK;
263 EXIT:
264 FreeClientPkgName();
265 SoftBusMutexUnlock(&g_isInitedLock);
266 return SOFTBUS_ERR;
267 }
268
GetSoftBusClientNameList(char * pkgList[],uint32_t len)269 uint32_t GetSoftBusClientNameList(char *pkgList[], uint32_t len)
270 {
271 if (pkgList == NULL || len == 0) {
272 return 0;
273 }
274 if (SoftBusMutexLock(&g_pkgNameLock) != SOFTBUS_OK) {
275 COMM_LOGE(COMM_SDK, "lock init failed");
276 return 0;
277 }
278 ListNode *item = NULL;
279 uint32_t subscript = 0;
280 LIST_FOR_EACH(item, &g_pkgNameList) {
281 PkgNameInfo *info = LIST_ENTRY(item, PkgNameInfo, node);
282 char *pkgName = (char *)SoftBusCalloc(PKG_NAME_SIZE_MAX);
283 if (pkgName == NULL) {
284 COMM_LOGE(COMM_SDK, "get client name malloc fail");
285 goto EXIT;
286 }
287 if (strcpy_s(pkgName, PKG_NAME_SIZE_MAX, info->pkgName) != EOK) {
288 COMM_LOGE(COMM_SDK, "get client name strcpy_s failed");
289 SoftBusFree(pkgName);
290 goto EXIT;
291 }
292 pkgList[subscript] = pkgName;
293 subscript++;
294 if (subscript >= len) {
295 break;
296 }
297 }
298 SoftBusMutexUnlock(&g_pkgNameLock);
299 return subscript;
300
301 EXIT:
302 for (uint32_t i = 0; i < subscript; i++) {
303 SoftBusFree(pkgList[i]);
304 }
305 SoftBusMutexUnlock(&g_pkgNameLock);
306 return 0;
307 }
308
CheckPackageName(const char * pkgName)309 int32_t CheckPackageName(const char *pkgName)
310 {
311 (void)pkgName;
312 #ifdef __LITEOS_M__
313 return SOFTBUS_OK;
314 #else
315 if (SoftBusMutexLock(&g_pkgNameLock) != SOFTBUS_OK) {
316 COMM_LOGE(COMM_SDK, "lock init failed");
317 return SOFTBUS_LOCK_ERR;
318 }
319 ListNode *item = NULL;
320 PkgNameInfo *info = NULL;
321 LIST_FOR_EACH(item, &g_pkgNameList) {
322 info = LIST_ENTRY(item, PkgNameInfo, node);
323 if (strcmp(info->pkgName, pkgName) == 0) {
324 SoftBusMutexUnlock(&g_pkgNameLock);
325 return SOFTBUS_OK;
326 }
327 }
328 SoftBusMutexUnlock(&g_pkgNameLock);
329 return SOFTBUS_INVALID_PKGNAME;
330 #endif
331 }
332