1 /*
2 * Copyright (c) 2021 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 "softbus_adapter_mem.h"
25 #include "softbus_adapter_thread.h"
26 #include "softbus_base_listener.h"
27 #include "softbus_client_event_manager.h"
28 #include "softbus_client_stub_interface.h"
29 #include "softbus_def.h"
30 #include "softbus_errcode.h"
31 #include "softbus_feature_config.h"
32 #include "softbus_log.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 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_INFO, "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 (SoftBusMutexLock(&g_pkgNameLock) != SOFTBUS_OK) {
68 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock init failed");
69 return SOFTBUS_LOCK_ERR;
70 }
71 if (CheckPkgNameInfo(pkgName) == false) {
72 SoftBusMutexUnlock(&g_pkgNameLock);
73 return SOFTBUS_INVALID_PARAM;
74 }
75 PkgNameInfo *info = (PkgNameInfo *)SoftBusCalloc(sizeof(PkgNameInfo));
76 if (info == NULL) {
77 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "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 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "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 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "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 if (AddClientPkgName(pkgName) != SOFTBUS_OK) {
116 return SOFTBUS_MEM_ERR;
117 }
118 int32_t ret = ClientRegisterService(pkgName);
119 if (ret != SOFTBUS_OK) {
120 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "ClientRegisterService failed. ret = %d", ret);
121 DelClientPkgName(pkgName);
122 return ret;
123 }
124 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_INFO, "ClientRegisterService success");
125 return SOFTBUS_OK;
126 }
127
FreeClientPkgName(void)128 static void FreeClientPkgName(void)
129 {
130 if (SoftBusMutexLock(&g_pkgNameLock) != SOFTBUS_OK) {
131 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock init failed");
132 return;
133 }
134 ListNode *item = NULL;
135 ListNode *nextItem = NULL;
136 PkgNameInfo *info = NULL;
137 LIST_FOR_EACH_SAFE(item, nextItem, &g_pkgNameList) {
138 info = LIST_ENTRY(item, PkgNameInfo, node);
139 ListDelete(&info->node);
140 SoftBusFree(info);
141 }
142 SoftBusMutexUnlock(&g_pkgNameLock);
143 }
144
ConnClientDeinit(void)145 static void ConnClientDeinit(void)
146 {
147 (void)DeinitBaseListener();
148 (void)ConnDeinitSockets();
149 }
150
ClientModuleDeinit(void)151 static void ClientModuleDeinit(void)
152 {
153 EventClientDeinit();
154 BusCenterClientDeinit();
155 TransClientDeinit();
156 ConnClientDeinit();
157 DiscClientDeinit();
158 }
159
ConnClientInit(void)160 static int32_t ConnClientInit(void)
161 {
162 int32_t ret = ConnInitSockets();
163 if (ret != SOFTBUS_OK) {
164 SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "ConnInitSockets failed!ret=%" PRId32 " \r\n", ret);
165 return ret;
166 }
167
168 ret = InitBaseListener();
169 if (ret != SOFTBUS_OK) {
170 SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "InitBaseListener failed!ret=%" PRId32 " \r\n", ret);
171 return ret;
172 }
173 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "init conn client success");
174 return ret;
175 }
176
ClientModuleInit(void)177 static int32_t ClientModuleInit(void)
178 {
179 SoftbusConfigInit();
180 if (EventClientInit() == SOFTBUS_ERR) {
181 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "init event manager failed");
182 goto ERR_EXIT;
183 }
184
185 if (BusCenterClientInit() == SOFTBUS_ERR) {
186 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "init bus center failed");
187 goto ERR_EXIT;
188 }
189
190 if (DiscClientInit() == SOFTBUS_ERR) {
191 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "init service manager failed");
192 goto ERR_EXIT;
193 }
194
195 if (ConnClientInit() != SOFTBUS_OK) {
196 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "init connect manager failed");
197 goto ERR_EXIT;
198 }
199
200 if (TransClientInit() == SOFTBUS_ERR) {
201 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "init trans manager failed");
202 goto ERR_EXIT;
203 }
204
205 return SOFTBUS_OK;
206
207 ERR_EXIT:
208 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "softbus sdk frame init failed.");
209 ClientModuleDeinit();
210 return SOFTBUS_ERR;
211 }
212
InitSoftBus(const char * pkgName)213 int32_t InitSoftBus(const char *pkgName)
214 {
215 if (!IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1)) {
216 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR,
217 "init softbus sdk fail. Package name is empty or length exceeds");
218 return SOFTBUS_INVALID_PARAM;
219 }
220 if (SoftBusMutexInit(&g_pkgNameLock, NULL) != SOFTBUS_OK) {
221 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock init pkgName failed");
222 return SOFTBUS_LOCK_ERR;
223 }
224 if ((g_isInited == false) && (SoftBusMutexInit(&g_isInitedLock, NULL) != SOFTBUS_OK)) {
225 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock init failed");
226 return SOFTBUS_LOCK_ERR;
227 }
228 if (SoftBusMutexLock(&g_isInitedLock) != SOFTBUS_OK) {
229 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock failed");
230 return SOFTBUS_LOCK_ERR;
231 }
232 if (g_isInited == true) {
233 (void)ClientRegisterPkgName(pkgName);
234 SoftBusMutexUnlock(&g_isInitedLock);
235 return SOFTBUS_OK;
236 }
237 if (AddClientPkgName(pkgName) != SOFTBUS_OK) {
238 SoftBusMutexUnlock(&g_isInitedLock);
239 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "AddClientPkgName failed.");
240 return SOFTBUS_MEM_ERR;
241 }
242 if (SoftBusTimerInit() != SOFTBUS_OK) {
243 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "client timer init fail");
244 goto EXIT;
245 }
246 if (ClientModuleInit() != SOFTBUS_OK) {
247 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "ctx init fail");
248 goto EXIT;
249 }
250 if (ClientStubInit() != SOFTBUS_OK) {
251 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "service init fail");
252 goto EXIT;
253 }
254 if (ClientRegisterService(pkgName) != SOFTBUS_OK) {
255 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "ClientRegisterService fail");
256 goto EXIT;
257 }
258 g_isInited = true;
259 SoftBusMutexUnlock(&g_isInitedLock);
260 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_INFO, "softbus sdk frame init success.");
261 return SOFTBUS_OK;
262 EXIT:
263 FreeClientPkgName();
264 SoftBusMutexUnlock(&g_isInitedLock);
265 return SOFTBUS_ERR;
266 }
267
GetSoftBusClientNameList(char * pkgList[],uint32_t len)268 uint32_t GetSoftBusClientNameList(char *pkgList[], uint32_t len)
269 {
270 if (pkgList == NULL || len == 0) {
271 return 0;
272 }
273 if (SoftBusMutexLock(&g_pkgNameLock) != SOFTBUS_OK) {
274 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock init failed");
275 return 0;
276 }
277 ListNode *item = NULL;
278 uint32_t subscript = 0;
279 LIST_FOR_EACH(item, &g_pkgNameList) {
280 PkgNameInfo *info = LIST_ENTRY(item, PkgNameInfo, node);
281 char *pkgName = (char *)SoftBusCalloc(PKG_NAME_SIZE_MAX);
282 if (pkgName == NULL) {
283 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "get client name malloc fail");
284 goto EXIT;
285 }
286 if (strcpy_s(pkgName, PKG_NAME_SIZE_MAX, info->pkgName) != EOK) {
287 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "get client name strcpy_s failed");
288 SoftBusFree(pkgName);
289 goto EXIT;
290 }
291 pkgList[subscript] = pkgName;
292 subscript++;
293 if (subscript >= len) {
294 break;
295 }
296 }
297 SoftBusMutexUnlock(&g_pkgNameLock);
298 return subscript;
299
300 EXIT:
301 for (uint32_t i = 0; i < subscript; i++) {
302 SoftBusFree(pkgList[i]);
303 }
304 SoftBusMutexUnlock(&g_pkgNameLock);
305 return 0;
306 }
307
CheckPackageName(const char * pkgName)308 int32_t CheckPackageName(const char *pkgName)
309 {
310 (void)pkgName;
311 #ifdef __LITEOS_M__
312 return SOFTBUS_OK;
313 #else
314 if (SoftBusMutexLock(&g_pkgNameLock) != SOFTBUS_OK) {
315 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock init failed");
316 return SOFTBUS_LOCK_ERR;
317 }
318 ListNode *item = NULL;
319 PkgNameInfo *info = NULL;
320 LIST_FOR_EACH(item, &g_pkgNameList) {
321 info = LIST_ENTRY(item, PkgNameInfo, node);
322 if (strcmp(info->pkgName, pkgName) == 0) {
323 SoftBusMutexUnlock(&g_pkgNameLock);
324 return SOFTBUS_OK;
325 }
326 }
327 SoftBusMutexUnlock(&g_pkgNameLock);
328 return SOFTBUS_INVALID_PKGNAME;
329 #endif
330 }
331