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 pthread_mutex_t g_pkgNameLock = PTHREAD_MUTEX_INITIALIZER;
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 (pthread_mutex_lock(&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 (void)pthread_mutex_unlock(&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 pthread_mutex_unlock(&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 (void)pthread_mutex_unlock(&g_pkgNameLock);
85 return SOFTBUS_MEM_ERR;
86 }
87 ListInit(&info->node);
88 ListAdd(&g_pkgNameList, &info->node);
89 (void)pthread_mutex_unlock(&g_pkgNameLock);
90 return SOFTBUS_OK;
91 }
92
DelClientPkgName(const char * pkgName)93 static void DelClientPkgName(const char *pkgName)
94 {
95 if (pthread_mutex_lock(&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 (void)pthread_mutex_unlock(&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 (pthread_mutex_lock(&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 (void)pthread_mutex_unlock(&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
221 if ((g_isInited == false) && (SoftBusMutexInit(&g_isInitedLock, NULL) != SOFTBUS_OK)) {
222 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock init failed");
223 return SOFTBUS_LOCK_ERR;
224 }
225
226 if (SoftBusMutexLock(&g_isInitedLock) != SOFTBUS_OK) {
227 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock failed");
228 return SOFTBUS_LOCK_ERR;
229 }
230 if (g_isInited == true) {
231 (void)ClientRegisterPkgName(pkgName);
232 SoftBusMutexUnlock(&g_isInitedLock);
233 return SOFTBUS_OK;
234 }
235
236 if (AddClientPkgName(pkgName) != SOFTBUS_OK) {
237 SoftBusMutexUnlock(&g_isInitedLock);
238 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "AddClientPkgName failed.");
239 return SOFTBUS_MEM_ERR;
240 }
241 if (SoftBusTimerInit() != SOFTBUS_OK) {
242 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "client timer init fail");
243 goto EXIT;
244 }
245
246 if (ClientModuleInit() != SOFTBUS_OK) {
247 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "ctx init fail");
248 goto EXIT;
249 }
250
251 if (ClientStubInit() != SOFTBUS_OK) {
252 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "service init fail");
253 goto EXIT;
254 }
255 if (ClientRegisterService(pkgName) != SOFTBUS_OK) {
256 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "ClientRegisterService fail");
257 goto EXIT;
258 }
259 g_isInited = true;
260 SoftBusMutexUnlock(&g_isInitedLock);
261 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_INFO, "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 (pthread_mutex_lock(&g_pkgNameLock) != SOFTBUS_OK) {
275 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "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 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "get client name malloc fail");
285 goto EXIT;
286 }
287 if (strcpy_s(pkgName, PKG_NAME_SIZE_MAX, info->pkgName) != EOK) {
288 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "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 (void)pthread_mutex_unlock(&g_pkgNameLock);
299 return subscript;
300
301 EXIT:
302 for (uint32_t i = 0; i < subscript; i++) {
303 SoftBusFree(pkgList[i]);
304 }
305 (void)pthread_mutex_unlock(&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 (pthread_mutex_lock(&g_pkgNameLock) != SOFTBUS_OK) {
316 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "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 (void)pthread_mutex_unlock(&g_pkgNameLock);
325 return SOFTBUS_OK;
326 }
327 }
328 (void)pthread_mutex_unlock(&g_pkgNameLock);
329 return SOFTBUS_INVALID_PKGNAME;
330 #endif
331 }
332
333