1 /*
2 * Copyright (c) 2022-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 "trans_lane_pending_ctl.h"
17
18 #include <securec.h>
19
20 #include "access_control.h"
21 #include "auth_interface.h"
22 #include "bus_center_manager.h"
23 #include "common_list.h"
24 #include "lnn_distributed_net_ledger.h"
25 #include "permission_entry.h"
26 #include "softbus_adapter_mem.h"
27 #include "softbus_adapter_thread.h"
28 #include "softbus_def.h"
29 #include "softbus_errcode.h"
30 #include "softbus_hisysevt_transreporter.h"
31 #include "softbus_utils.h"
32 #include "trans_channel_common.h"
33 #include "trans_client_proxy.h"
34 #include "trans_event.h"
35 #include "trans_lane_manager.h"
36 #include "trans_log.h"
37 #include "trans_network_statistics.h"
38 #include "trans_qos_info.h"
39 #include "trans_session_manager.h"
40
41 #define MIN(a, b) ((a) < (b) ? (a) : (b))
42
43 #define TRANS_REQUEST_PENDING_TIMEOUT (5000)
44 #define TRANS_FREE_LANE_TIMEOUT (2000)
45 #define SESSION_NAME_PHONEPAD "com.huawei.pcassistant.phonepad-connect-channel"
46 #define SESSION_NAME_CASTPLUS "CastPlusSessionName"
47 #define SESSION_NAME_DISTRIBUTE_COMMUNICATION "com.huawei.boosterd.user"
48 #define SESSION_NAME_ISHARE "IShare"
49 #define ISHARE_MIN_NAME_LEN 6
50 #define SESSION_NAME_DBD "distributeddata-default"
51 #define SESSION_NAME_DSL "device.security.level"
52 #define SESSION_NAME_DSL2_RE "com.*security.devicesec"
53 #define DB_MAGIC_BW 0x5A5A5A5A // p2preuse, wifi and br link
54 #define MESH_MAGIC_BW 0xA5A5A5A5 // wifi and br link
55
56 typedef struct {
57 ListNode node;
58 uint32_t laneHandle;
59 int32_t errCode;
60 SoftBusCond cond;
61 bool bSucc;
62 bool isFinished;
63 LaneConnInfo connInfo;
64 SessionParam param;
65 uint32_t callingTokenId; // used for transmission access control
66 uint32_t firstTokenId; // used for dfx connection success rate
67 int64_t timeStart;
68 } TransReqLaneItem;
69
70 typedef struct {
71 ListNode node;
72 uint32_t laneHandle;
73 int32_t errCode;
74 SoftBusCond condVar;
75 bool isSucc;
76 bool isFinished;
77 } TransFreeLaneItem;
78
79 static SoftBusList *g_reqLanePendingList = NULL;
80 static SoftBusList *g_freeLanePendingList = NULL;
81
82 static SoftBusList *g_asyncReqLanePendingList = NULL;
83 static SoftBusList *g_authWithParaAsyncReqLaneList = NULL;
84
TransReqLanePendingInit(void)85 int32_t TransReqLanePendingInit(void)
86 {
87 g_reqLanePendingList = CreateSoftBusList();
88 if (g_reqLanePendingList == NULL) {
89 TRANS_LOGE(TRANS_INIT, "g_reqLanePendingList is null.");
90 return SOFTBUS_MALLOC_ERR;
91 }
92 return SOFTBUS_OK;
93 }
94
TransAsyncReqLanePendingInit(void)95 int32_t TransAsyncReqLanePendingInit(void)
96 {
97 g_asyncReqLanePendingList = CreateSoftBusList();
98 if (g_asyncReqLanePendingList == NULL) {
99 TRANS_LOGE(TRANS_INIT, "g_asyncReqLanePendingList is null.");
100 return SOFTBUS_MALLOC_ERR;
101 }
102 return SOFTBUS_OK;
103 }
104
TransFreeLanePendingInit(void)105 int32_t TransFreeLanePendingInit(void)
106 {
107 if (g_freeLanePendingList != NULL) {
108 TRANS_LOGI(TRANS_INIT, "g_freeLanePendingList is initialized.");
109 return SOFTBUS_OK;
110 }
111 g_freeLanePendingList = CreateSoftBusList();
112 TRANS_CHECK_AND_RETURN_RET_LOGE(g_freeLanePendingList != NULL,
113 SOFTBUS_MALLOC_ERR, TRANS_INIT, "g_freeLanePendingList is null.");
114 return SOFTBUS_OK;
115 }
116
DestroyAsyncReqItemParam(SessionParam * param)117 static void DestroyAsyncReqItemParam(SessionParam *param)
118 {
119 if (param->sessionName != NULL) {
120 SoftBusFree((void *)(param->sessionName));
121 param->sessionName = NULL;
122 }
123 if (param->peerSessionName != NULL) {
124 SoftBusFree((void *)(param->peerSessionName));
125 param->peerSessionName = NULL;
126 }
127 if (param->peerDeviceId != NULL) {
128 SoftBusFree((void *)(param->peerDeviceId));
129 param->peerDeviceId = NULL;
130 }
131 if (param->groupId != NULL) {
132 SoftBusFree((void *)(param->groupId));
133 param->groupId = NULL;
134 }
135 if (param->attr != NULL) {
136 SoftBusFree((void *)(param->attr));
137 param->attr = NULL;
138 }
139 }
140
TransReqLanePendingDeinit(void)141 void TransReqLanePendingDeinit(void)
142 {
143 TRANS_LOGI(TRANS_SVC, "enter.");
144 if (g_reqLanePendingList == NULL) {
145 TRANS_LOGE(TRANS_INIT, "g_reqLanePendingList is null.");
146 return;
147 }
148
149 if (SoftBusMutexLock(&g_reqLanePendingList->lock) != SOFTBUS_OK) {
150 TRANS_LOGE(TRANS_INIT, "lock failed.");
151 return;
152 }
153
154 TransReqLaneItem *item = NULL;
155 TransReqLaneItem *next = NULL;
156 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_reqLanePendingList->list, TransReqLaneItem, node) {
157 (void)SoftBusCondDestroy(&item->cond);
158 ListDelete(&item->node);
159 SoftBusFree(item);
160 }
161 (void)SoftBusMutexUnlock(&g_reqLanePendingList->lock);
162 DestroySoftBusList(g_reqLanePendingList);
163 g_reqLanePendingList = NULL;
164 }
165
TransAsyncReqLanePendingDeinit(void)166 void TransAsyncReqLanePendingDeinit(void)
167 {
168 TRANS_LOGI(TRANS_SVC, "enter.");
169 if (g_asyncReqLanePendingList == NULL) {
170 TRANS_LOGE(TRANS_INIT, "g_asyncReqLanePendingList is null.");
171 return;
172 }
173
174 if (SoftBusMutexLock(&g_asyncReqLanePendingList->lock) != SOFTBUS_OK) {
175 TRANS_LOGE(TRANS_INIT, "lock failed.");
176 return;
177 }
178
179 TransReqLaneItem *item = NULL;
180 TransReqLaneItem *next = NULL;
181 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_asyncReqLanePendingList->list, TransReqLaneItem, node) {
182 ListDelete(&item->node);
183 DestroyAsyncReqItemParam(&(item->param));
184 SoftBusFree(item);
185 }
186 (void)SoftBusMutexUnlock(&g_asyncReqLanePendingList->lock);
187 DestroySoftBusList(g_asyncReqLanePendingList);
188 g_asyncReqLanePendingList = NULL;
189 }
190
TransFreeLanePendingDeinit(void)191 void TransFreeLanePendingDeinit(void)
192 {
193 TRANS_CHECK_AND_RETURN_LOGE(g_freeLanePendingList != NULL, TRANS_INIT, "g_freeLanePendingList is null.");
194 TRANS_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_freeLanePendingList->lock) == SOFTBUS_OK,
195 TRANS_INIT, "lock failed.");
196
197 TransFreeLaneItem *item = NULL;
198 TransFreeLaneItem *next = NULL;
199 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_freeLanePendingList->list, TransFreeLaneItem, node) {
200 (void)SoftBusCondDestroy(&item->condVar);
201 ListDelete(&item->node);
202 SoftBusFree(item);
203 }
204 (void)SoftBusMutexUnlock(&g_freeLanePendingList->lock);
205 DestroySoftBusList(g_freeLanePendingList);
206 g_freeLanePendingList = NULL;
207 }
208
TransDelLaneReqFromPendingList(uint32_t laneHandle,bool isAsync)209 static int32_t TransDelLaneReqFromPendingList(uint32_t laneHandle, bool isAsync)
210 {
211 TRANS_LOGD(TRANS_SVC, "del tran request from pending laneHandle=%{public}u, isAsync=%{public}d",
212 laneHandle, isAsync);
213 SoftBusList *pendingList = isAsync ? g_asyncReqLanePendingList : g_reqLanePendingList;
214 if (pendingList == NULL) {
215 TRANS_LOGE(TRANS_SVC, "lane pending list no init.");
216 return SOFTBUS_MALLOC_ERR;
217 }
218 if (SoftBusMutexLock(&(pendingList->lock)) != SOFTBUS_OK) {
219 TRANS_LOGE(TRANS_SVC, "lock failed");
220 return SOFTBUS_LOCK_ERR;
221 }
222
223 TransReqLaneItem *laneItem = NULL;
224 TransReqLaneItem *next = NULL;
225 LIST_FOR_EACH_ENTRY_SAFE(laneItem, next, &(pendingList->list), TransReqLaneItem, node) {
226 if (laneItem->laneHandle == laneHandle) {
227 if (!isAsync) {
228 (void)SoftBusCondDestroy(&laneItem->cond);
229 }
230 ListDelete(&(laneItem->node));
231 TRANS_LOGI(TRANS_SVC, "delete laneHandle = %{public}u", laneItem->laneHandle);
232 pendingList->cnt--;
233 if (isAsync) {
234 DestroyAsyncReqItemParam(&(laneItem->param));
235 }
236 SoftBusFree(laneItem);
237 (void)SoftBusMutexUnlock(&(pendingList->lock));
238 return SOFTBUS_OK;
239 }
240 }
241 (void)SoftBusMutexUnlock(&(pendingList->lock));
242 TRANS_LOGE(TRANS_SVC, "trans lane request not found, laneHandle=%{public}u", laneHandle);
243 return SOFTBUS_TRANS_NODE_NOT_FOUND;
244 }
245
TransAddLaneReqFromPendingList(uint32_t laneHandle)246 static int32_t TransAddLaneReqFromPendingList(uint32_t laneHandle)
247 {
248 if (g_reqLanePendingList == NULL) {
249 TRANS_LOGE(TRANS_SVC, "lane pending list no init.");
250 return SOFTBUS_INVALID_PARAM;
251 }
252
253 TransReqLaneItem *item = (TransReqLaneItem *)SoftBusCalloc(sizeof(TransReqLaneItem));
254 if (item == NULL) {
255 TRANS_LOGE(TRANS_SVC, "malloc lane request item err.");
256 return SOFTBUS_MALLOC_ERR;
257 }
258 item->errCode = SOFTBUS_MALLOC_ERR;
259 item->laneHandle = laneHandle;
260 item->bSucc = false;
261 item->isFinished = false;
262
263 if (SoftBusMutexLock(&g_reqLanePendingList->lock) != SOFTBUS_OK) {
264 SoftBusFree(item);
265 TRANS_LOGE(TRANS_SVC, "lock failed.");
266 return SOFTBUS_LOCK_ERR;
267 }
268 if (SoftBusCondInit(&item->cond) != SOFTBUS_OK) {
269 SoftBusFree(item);
270 (void)SoftBusMutexUnlock(&g_reqLanePendingList->lock);
271 TRANS_LOGE(TRANS_SVC, "cond init failed.");
272 return SOFTBUS_TRANS_INIT_FAILED;
273 }
274 ListInit(&(item->node));
275 ListAdd(&(g_reqLanePendingList->list), &(item->node));
276 g_reqLanePendingList->cnt++;
277 (void)SoftBusMutexUnlock(&g_reqLanePendingList->lock);
278
279 TRANS_LOGI(TRANS_SVC, "add tran request to pending laneHandle=%{public}u", laneHandle);
280 return SOFTBUS_OK;
281 }
282
BuildTransEventExtra(TransEventExtra * extra,const SessionParam * param,uint32_t laneHandle,LaneTransType transType,int32_t ret)283 static void BuildTransEventExtra(
284 TransEventExtra *extra, const SessionParam *param, uint32_t laneHandle, LaneTransType transType, int32_t ret)
285 {
286 extra->calleePkg = NULL;
287 extra->callerPkg = NULL;
288 extra->socketName = param->sessionName;
289 extra->laneId = (int32_t)laneHandle;
290 extra->peerNetworkId = param->peerDeviceId;
291 extra->laneTransType = transType;
292 extra->deviceState = TransGetDeviceState(param->peerDeviceId);
293 extra->errcode = ret;
294 extra->result = (ret == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED;
295 extra->result = (ret == SOFTBUS_TRANS_STOP_BIND_BY_CANCEL) ? EVENT_STAGE_RESULT_CANCELED : extra->result;
296 }
297
CallbackOpenChannelFailed(const SessionParam * param,const AppInfo * appInfo,int32_t errCode)298 static void CallbackOpenChannelFailed(const SessionParam *param, const AppInfo *appInfo, int32_t errCode)
299 {
300 ChannelMsg data = {
301 .msgChannelId = param->sessionId,
302 .msgChannelType = CHANNEL_TYPE_UNDEFINED,
303 .msgPkgName = appInfo->myData.pkgName,
304 .msgPid = appInfo->myData.pid,
305 };
306 (void)ClientIpcOnChannelOpenFailed(&data, errCode);
307 }
308
CopyAsyncReqItemSessionParamIds(const SessionParam * source,SessionParam * target)309 static int32_t CopyAsyncReqItemSessionParamIds(const SessionParam *source, SessionParam *target)
310 {
311 char *groupId = (char *)SoftBusCalloc(sizeof(char) * GROUP_ID_SIZE_MAX);
312 TRANS_CHECK_AND_RETURN_RET_LOGE(groupId != NULL, SOFTBUS_MALLOC_ERR, TRANS_SVC, "SoftBusCalloc groupId failed");
313 if (source->groupId != NULL && strcpy_s(groupId, GROUP_ID_SIZE_MAX, source->groupId) != EOK) {
314 TRANS_LOGE(TRANS_SVC, "strcopy groupId failed");
315 SoftBusFree(groupId);
316 return SOFTBUS_MEM_ERR;
317 }
318 target->groupId = groupId;
319
320 SessionAttribute *tmpAttr = (SessionAttribute *)SoftBusCalloc(sizeof(SessionAttribute));
321 TRANS_CHECK_AND_RETURN_RET_LOGE(
322 tmpAttr != NULL, SOFTBUS_MALLOC_ERR, TRANS_SVC, "SoftBusCalloc SessionAttribute failed");
323 if (memcpy_s(tmpAttr, sizeof(SessionAttribute), source->attr, sizeof(SessionAttribute)) != EOK) {
324 TRANS_LOGE(TRANS_SVC, "memcpy_s SessionAttribute failed");
325 SoftBusFree(tmpAttr);
326 return SOFTBUS_MEM_ERR;
327 }
328 target->attr = tmpAttr;
329 target->qosCount = source->qosCount;
330 if ((source->qosCount > 0) &&
331 (memcpy_s(target->qos, sizeof(target->qos), source->qos, sizeof(QosTV) * (source->qosCount)) != EOK)) {
332 return SOFTBUS_MEM_ERR;
333 }
334 return SOFTBUS_OK;
335 }
336
CopyAsyncReqItemSessionParam(const SessionParam * source,SessionParam * target)337 static int32_t CopyAsyncReqItemSessionParam(const SessionParam *source, SessionParam *target)
338 {
339 char *sessionName = (char *)SoftBusCalloc(sizeof(char) * SESSION_NAME_SIZE_MAX);
340 TRANS_CHECK_AND_RETURN_RET_LOGE(
341 sessionName != NULL, SOFTBUS_MALLOC_ERR, TRANS_SVC, "SoftBusCalloc sessionName failed");
342 if (source->sessionName != NULL && strcpy_s(sessionName, SESSION_NAME_SIZE_MAX, source->sessionName) != EOK) {
343 TRANS_LOGE(TRANS_SVC, "strcopy sessionName failed");
344 SoftBusFree(sessionName);
345 return SOFTBUS_MEM_ERR;
346 }
347 target->sessionName = sessionName;
348
349 char *peerSessionName = (char *)SoftBusCalloc(sizeof(char) * SESSION_NAME_SIZE_MAX);
350 TRANS_CHECK_AND_RETURN_RET_LOGE(
351 peerSessionName != NULL, SOFTBUS_MALLOC_ERR, TRANS_SVC, "SoftBusCalloc peerSessionName failed");
352 if (source->peerSessionName != NULL &&
353 strcpy_s(peerSessionName, SESSION_NAME_SIZE_MAX, source->peerSessionName) != EOK) {
354 TRANS_LOGE(TRANS_SVC, "strcopy peerSessionName failed");
355 SoftBusFree(peerSessionName);
356 return SOFTBUS_MEM_ERR;
357 }
358 target->peerSessionName = peerSessionName;
359
360 char *peerDeviceId = (char *)SoftBusCalloc(sizeof(char) * DEVICE_ID_SIZE_MAX);
361 TRANS_CHECK_AND_RETURN_RET_LOGE(
362 peerDeviceId != NULL, SOFTBUS_MALLOC_ERR, TRANS_SVC, "SoftBusCalloc peerDeviceId failed");
363 if (source->peerDeviceId != NULL && strcpy_s(peerDeviceId, DEVICE_ID_SIZE_MAX, source->peerDeviceId) != EOK) {
364 TRANS_LOGE(TRANS_SVC, "strcopy peerDeviceId failed");
365 SoftBusFree(peerDeviceId);
366 return SOFTBUS_MEM_ERR;
367 }
368 target->peerDeviceId = peerDeviceId;
369 target->actionId = source->actionId;
370 return CopyAsyncReqItemSessionParamIds(source, target);
371 }
372
TransAddAsyncLaneReqFromPendingList(uint32_t laneHandle,const SessionParam * param,uint32_t callingTokenId,int64_t timeStart)373 static int32_t TransAddAsyncLaneReqFromPendingList(uint32_t laneHandle, const SessionParam *param,
374 uint32_t callingTokenId, int64_t timeStart)
375 {
376 if (g_asyncReqLanePendingList == NULL) {
377 TRANS_LOGE(TRANS_SVC, "lane pending list no init.");
378 return SOFTBUS_INVALID_PARAM;
379 }
380
381 TransReqLaneItem *item = (TransReqLaneItem *)SoftBusCalloc(sizeof(TransReqLaneItem));
382 if (item == NULL) {
383 TRANS_LOGE(TRANS_SVC, "malloc lane request item err.");
384 return SOFTBUS_MALLOC_ERR;
385 }
386 item->errCode = SOFTBUS_MALLOC_ERR;
387 item->laneHandle = laneHandle;
388 item->bSucc = false;
389 item->isFinished = false;
390 item->callingTokenId = callingTokenId;
391 item->firstTokenId = TransACLGetFirstTokenID();
392 item->timeStart = timeStart;
393 if (CopyAsyncReqItemSessionParam(param, &(item->param)) != SOFTBUS_OK) {
394 DestroyAsyncReqItemParam(&(item->param));
395 SoftBusFree(item);
396 TRANS_LOGE(TRANS_SVC, "copy async lane req attach param failed.");
397 return SOFTBUS_MEM_ERR;
398 }
399 item->param.isQosLane = param->isQosLane;
400 item->param.isAsync = param->isAsync;
401 item->param.sessionId = param->sessionId;
402 item->param.actionId = param->actionId;
403 if (SoftBusMutexLock(&g_asyncReqLanePendingList->lock) != SOFTBUS_OK) {
404 DestroyAsyncReqItemParam(&(item->param));
405 SoftBusFree(item);
406 TRANS_LOGE(TRANS_SVC, "lock failed.");
407 return SOFTBUS_LOCK_ERR;
408 }
409 ListInit(&(item->node));
410 ListAdd(&(g_asyncReqLanePendingList->list), &(item->node));
411 g_asyncReqLanePendingList->cnt++;
412 (void)SoftBusMutexUnlock(&g_asyncReqLanePendingList->lock);
413 TRANS_LOGI(TRANS_SVC, "add async request to pending list laneHandle=%{public}u, socket=%{public}d",
414 laneHandle, param->sessionId);
415 return SOFTBUS_OK;
416 }
417
TransGetLaneReqItemByLaneHandle(uint32_t laneHandle,bool * bSucc,LaneConnInfo * connInfo,int32_t * errCode)418 static int32_t TransGetLaneReqItemByLaneHandle(uint32_t laneHandle, bool *bSucc, LaneConnInfo *connInfo,
419 int32_t *errCode)
420 {
421 if (g_reqLanePendingList == NULL) {
422 TRANS_LOGE(TRANS_SVC, "lane request list hasn't init.");
423 return SOFTBUS_INVALID_PARAM;
424 }
425 if (SoftBusMutexLock(&(g_reqLanePendingList->lock)) != SOFTBUS_OK) {
426 TRANS_LOGE(TRANS_SVC, "lock failed.");
427 return SOFTBUS_LOCK_ERR;
428 }
429 TransReqLaneItem *item = NULL;
430 LIST_FOR_EACH_ENTRY(item, &(g_reqLanePendingList->list), TransReqLaneItem, node) {
431 if (item->laneHandle == laneHandle) {
432 *bSucc = item->bSucc;
433 *errCode = item->errCode;
434 if (memcpy_s(connInfo, sizeof(LaneConnInfo), &(item->connInfo), sizeof(LaneConnInfo)) != EOK) {
435 (void)SoftBusMutexUnlock(&(g_reqLanePendingList->lock));
436 TRANS_LOGE(TRANS_SVC, "memcpy_s connInfo failed");
437 return SOFTBUS_MEM_ERR;
438 }
439 (void)SoftBusMutexUnlock(&(g_reqLanePendingList->lock));
440 return SOFTBUS_OK;
441 }
442 }
443 (void)SoftBusMutexUnlock(&(g_reqLanePendingList->lock));
444 TRANS_LOGE(TRANS_SVC, "trans lane request not found. laneHandle=%{public}u", laneHandle);
445 return SOFTBUS_TRANS_NODE_NOT_FOUND;
446 }
447
TransGetLaneReqItemParamByLaneHandle(uint32_t laneHandle,SessionParam * param,uint32_t * callingTokenId,uint32_t * firstTokenId,int64_t * timeStart)448 static int32_t TransGetLaneReqItemParamByLaneHandle(
449 uint32_t laneHandle, SessionParam *param, uint32_t *callingTokenId, uint32_t *firstTokenId, int64_t *timeStart)
450 {
451 if (param == NULL) {
452 TRANS_LOGE(TRANS_SVC, "param err.");
453 return SOFTBUS_INVALID_PARAM;
454 }
455 if (g_asyncReqLanePendingList == NULL) {
456 TRANS_LOGE(TRANS_SVC, "lane request list hasn't init.");
457 return SOFTBUS_NO_INIT;
458 }
459 if (SoftBusMutexLock(&(g_asyncReqLanePendingList->lock)) != SOFTBUS_OK) {
460 TRANS_LOGE(TRANS_SVC, "lock failed.");
461 return SOFTBUS_LOCK_ERR;
462 }
463
464 TransReqLaneItem *item = NULL;
465 LIST_FOR_EACH_ENTRY(item, &(g_asyncReqLanePendingList->list), TransReqLaneItem, node) {
466 if (item->laneHandle == laneHandle) {
467 *callingTokenId = item->callingTokenId;
468 if (firstTokenId != NULL) {
469 *firstTokenId = item->firstTokenId;
470 }
471 *timeStart = item->timeStart;
472 if (memcpy_s(param, sizeof(SessionParam), &(item->param), sizeof(SessionParam)) != EOK) {
473 (void)SoftBusMutexUnlock(&(g_asyncReqLanePendingList->lock));
474 TRANS_LOGE(TRANS_SVC, "copy session param failed.");
475 return SOFTBUS_MEM_ERR;
476 }
477 (void)SoftBusMutexUnlock(&(g_asyncReqLanePendingList->lock));
478 return SOFTBUS_OK;
479 }
480 }
481 (void)SoftBusMutexUnlock(&(g_asyncReqLanePendingList->lock));
482 TRANS_LOGE(TRANS_SVC, "trans lane request not found. laneHandle=%{public}u", laneHandle);
483 return SOFTBUS_TRANS_NODE_NOT_FOUND;
484 }
485
TransUpdateLaneConnInfoByLaneHandle(uint32_t laneHandle,bool bSucc,const LaneConnInfo * connInfo,bool isAsync,int32_t errCode)486 static int32_t TransUpdateLaneConnInfoByLaneHandle(uint32_t laneHandle, bool bSucc, const LaneConnInfo *connInfo,
487 bool isAsync, int32_t errCode)
488 {
489 SoftBusList *pendingList = isAsync ? g_asyncReqLanePendingList : g_reqLanePendingList;
490 if (pendingList == NULL) {
491 TRANS_LOGE(TRANS_SVC, "lane pending list no init.");
492 return SOFTBUS_INVALID_PARAM;
493 }
494 if (SoftBusMutexLock(&(pendingList->lock)) != SOFTBUS_OK) {
495 TRANS_LOGE(TRANS_SVC, "lock failed.");
496 return SOFTBUS_LOCK_ERR;
497 }
498
499 TransReqLaneItem *item = NULL;
500 LIST_FOR_EACH_ENTRY(item, &(pendingList->list), TransReqLaneItem, node) {
501 if (item->laneHandle == laneHandle) {
502 item->bSucc = bSucc;
503 item->errCode = errCode;
504 if ((connInfo != NULL) &&
505 (memcpy_s(&(item->connInfo), sizeof(LaneConnInfo), connInfo, sizeof(LaneConnInfo)) != EOK)) {
506 (void)SoftBusMutexUnlock(&(pendingList->lock));
507 return SOFTBUS_MEM_ERR;
508 }
509 item->isFinished = true;
510 if (!isAsync) {
511 (void)SoftBusCondSignal(&item->cond);
512 }
513 (void)SoftBusMutexUnlock(&(pendingList->lock));
514 return SOFTBUS_OK;
515 }
516 }
517 (void)SoftBusMutexUnlock(&(pendingList->lock));
518 TRANS_LOGE(TRANS_SVC, "trans lane request not found. laneHandle=%{public}u", laneHandle);
519 return SOFTBUS_TRANS_NODE_NOT_FOUND;
520 }
521
TransOnLaneRequestSuccess(uint32_t laneHandle,const LaneConnInfo * connInfo)522 static void TransOnLaneRequestSuccess(uint32_t laneHandle, const LaneConnInfo *connInfo)
523 {
524 TRANS_LOGI(TRANS_SVC, "request success. laneHandle=%{public}u, laneId=%{public}" PRIu64,
525 laneHandle, connInfo->laneId);
526 int32_t ret = TransUpdateLaneConnInfoByLaneHandle(laneHandle, true, connInfo, false, SOFTBUS_OK);
527 if (ret != SOFTBUS_OK) {
528 TRANS_LOGE(TRANS_SVC, "update lane connInfo failed, laneHandle=%{public}u, ret=%{public}d", laneHandle, ret);
529 }
530 }
531
RecordFailOpenSessionKpi(AppInfo * appInfo,const LaneConnInfo * connInfo,int64_t timeStart)532 static void RecordFailOpenSessionKpi(AppInfo *appInfo, const LaneConnInfo *connInfo, int64_t timeStart)
533 {
534 SoftbusRecordOpenSessionKpi(appInfo->myData.pkgName, connInfo->type, SOFTBUS_EVT_OPEN_SESSION_FAIL,
535 GetSoftbusRecordTimeMillis() - timeStart);
536 }
537
TransAsyncOpenChannelProc(uint32_t laneHandle,SessionParam * param,AppInfo * appInfo,TransEventExtra * extra,const LaneConnInfo * connInnerInfo)538 static void TransAsyncOpenChannelProc(uint32_t laneHandle, SessionParam *param, AppInfo *appInfo,
539 TransEventExtra *extra, const LaneConnInfo *connInnerInfo)
540 {
541 TransInfo transInfo = { .channelId = INVALID_CHANNEL_ID, .channelType = CHANNEL_TYPE_BUTT};
542 ConnectOption connOpt;
543 (void)memset_s(&connOpt, sizeof(ConnectOption), 0, sizeof(ConnectOption));
544 int32_t ret = TransGetConnectOptByConnInfo(connInnerInfo, &connOpt);
545 if (ret != SOFTBUS_OK) {
546 RecordFailOpenSessionKpi(appInfo, connInnerInfo, appInfo->timeStart);
547 goto EXIT_ERR;
548 }
549 extra->peerUdid = appInfo->peerUdid;
550 extra->osType = (appInfo->osType < 0) ? UNKNOW_OS_TYPE : appInfo->osType;
551 appInfo->connectType = connOpt.type;
552 extra->linkType = connOpt.type;
553 extra->deviceState = TransGetDeviceState(param->peerDeviceId);
554 FillAppInfo(appInfo, param, &transInfo, connInnerInfo);
555 TransOpenChannelSetModule(transInfo.channelType, &connOpt);
556 TRANS_LOGI(TRANS_SVC, "laneHandle=%{public}u, channelType=%{public}u", laneHandle, transInfo.channelType);
557 ret = TransOpenChannelProc((ChannelType)transInfo.channelType, appInfo, &connOpt, &(transInfo.channelId));
558 (void)memset_s(appInfo->sessionKey, sizeof(appInfo->sessionKey), 0, sizeof(appInfo->sessionKey));
559 if (ret != SOFTBUS_OK) {
560 SoftbusReportTransErrorEvt(SOFTBUS_TRANS_CREATE_CHANNEL_ERR);
561 RecordFailOpenSessionKpi(appInfo, connInnerInfo, appInfo->timeStart);
562 goto EXIT_ERR;
563 }
564 TransUpdateSocketChannelInfoBySession(
565 param->sessionName, param->sessionId, transInfo.channelId, transInfo.channelType);
566 ret = ClientIpcSetChannelInfo(
567 appInfo->myData.pkgName, param->sessionName, param->sessionId, &transInfo, appInfo->myData.pid);
568 if (ret != SOFTBUS_OK) {
569 RecordFailOpenSessionKpi(appInfo, connInnerInfo, appInfo->timeStart);
570 TransCommonCloseChannel(NULL, transInfo.channelId, transInfo.channelType);
571 goto EXIT_ERR;
572 }
573 TransSetSocketChannelStateByChannel(transInfo.channelId, transInfo.channelType, CORE_SESSION_STATE_CHANNEL_OPENED);
574 if (TransLaneMgrAddLane(&transInfo, connInnerInfo, laneHandle, param->isQosLane, &(appInfo->myData)) !=
575 SOFTBUS_OK) {
576 RecordFailOpenSessionKpi(appInfo, connInnerInfo, appInfo->timeStart);
577 TransCommonCloseChannel(NULL, transInfo.channelId, transInfo.channelType);
578 goto EXIT_ERR;
579 }
580 AddChannelStatisticsInfo(transInfo.channelId, transInfo.channelType);
581 return;
582 EXIT_ERR:
583 TransBuildTransOpenChannelEndEvent(extra, &transInfo, appInfo->timeStart, ret);
584 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_END, *extra);
585 TransAlarmExtra extraAlarm;
586 TransBuildTransAlarmEvent(&extraAlarm, appInfo, ret);
587 TRANS_ALARM(OPEN_SESSION_FAIL_ALARM, CONTROL_ALARM_TYPE, extraAlarm);
588 if (ret != SOFTBUS_TRANS_STOP_BIND_BY_CANCEL && ret != SOFTBUS_TRANS_STOP_BIND_BY_TIMEOUT) {
589 CallbackOpenChannelFailed(param, appInfo, ret);
590 }
591 TransFreeLane(laneHandle, param->isQosLane, true);
592 (void)TransDeleteSocketChannelInfoBySession(param->sessionName, param->sessionId);
593 TRANS_LOGE(TRANS_SVC, "server TransOpenChannel err, ret=%{public}d", ret);
594 return;
595 }
596
TransAsyncSetFirstTokenInfo(uint32_t firstTokenId,AppInfo * appInfo,TransEventExtra * event)597 static void TransAsyncSetFirstTokenInfo(uint32_t firstTokenId, AppInfo *appInfo, TransEventExtra *event)
598 {
599 event->firstTokenId = firstTokenId;
600 if (event->firstTokenId == TOKENID_NOT_SET) {
601 event->firstTokenId = appInfo->callingTokenId;
602 }
603 TransGetTokenInfo(event->firstTokenId, appInfo->tokenName, sizeof(appInfo->tokenName), &event->firstTokenType);
604 event->firstTokenName = appInfo->tokenName;
605 }
606
CreateAppInfoByParam(uint32_t laneHandle,const SessionParam * param,AppInfo * appInfo)607 static int32_t CreateAppInfoByParam(uint32_t laneHandle, const SessionParam *param, AppInfo *appInfo)
608 {
609 int32_t ret = TransCommonGetAppInfo(param, appInfo);
610 if (ret != SOFTBUS_OK) {
611 TRANS_LOGE(TRANS_SVC, "GetAppInfo is null. ret=%{public}d", ret);
612 (void)TransDeleteSocketChannelInfoBySession(param->sessionName, param->sessionId);
613 (void)TransDelLaneReqFromPendingList(laneHandle, true);
614 return ret;
615 }
616 return SOFTBUS_OK;
617 }
618
CheckSocketChannelState(uint32_t laneHandle,const SessionParam * param,TransEventExtra * extra,LaneTransType transType)619 static int32_t CheckSocketChannelState(uint32_t laneHandle, const SessionParam *param, TransEventExtra *extra,
620 LaneTransType transType)
621 {
622 CoreSessionState state = CORE_SESSION_STATE_INIT;
623 TransGetSocketChannelStateBySession(param->sessionName, param->sessionId, &state);
624 if (state == CORE_SESSION_STATE_CANCELLING) {
625 TRANS_LOGI(TRANS_SVC, "cancel state laneHandle=%{public}u", laneHandle);
626 TransFreeLane(laneHandle, param->isQosLane, false);
627 BuildTransEventExtra(extra, param, laneHandle, transType, SOFTBUS_TRANS_STOP_BIND_BY_CANCEL);
628 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_SELECT_LANE, *extra);
629 (void)TransDeleteSocketChannelInfoBySession(param->sessionName, param->sessionId);
630 (void)TransDelLaneReqFromPendingList(laneHandle, true);
631 return SOFTBUS_TRANS_STOP_BIND_BY_CANCEL;
632 }
633 return SOFTBUS_OK;
634 }
635
TransOnAsyncLaneSuccess(uint32_t laneHandle,const LaneConnInfo * connInfo)636 static void TransOnAsyncLaneSuccess(uint32_t laneHandle, const LaneConnInfo *connInfo)
637 {
638 TRANS_LOGI(TRANS_SVC, "request success. laneHandle=%{public}u", laneHandle);
639 SessionParam param;
640 (void)memset_s(¶m, sizeof(SessionParam), 0, sizeof(SessionParam));
641 param.isQosLane = true;
642 uint32_t callingTokenId = TOKENID_NOT_SET;
643 uint32_t firstTokenId = TOKENID_NOT_SET;
644 int64_t timeStart = 0;
645 int32_t ret = TransGetLaneReqItemParamByLaneHandle(laneHandle, ¶m, &callingTokenId, &firstTokenId, &timeStart);
646 if (ret != SOFTBUS_OK) {
647 TRANS_LOGE(TRANS_SVC, "get lane req item failed. laneHandle=%{public}u, ret=%{public}d", laneHandle, ret);
648 (void)TransDeleteSocketChannelInfoBySession(param.sessionName, param.sessionId);
649 (void)TransDelLaneReqFromPendingList(laneHandle, true);
650 TransFreeLane(laneHandle, param.isQosLane, true);
651 return;
652 }
653 LaneTransType transType = (LaneTransType)TransGetLaneTransTypeBySession(¶m);
654 TransEventExtra extra;
655 extra.linkType = connInfo->type;
656 BuildTransEventExtra(&extra, ¶m, laneHandle, transType, SOFTBUS_OK);
657 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_SELECT_LANE, extra);
658 ret = CheckSocketChannelState(laneHandle, ¶m, &extra, transType);
659 TRANS_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, TRANS_SVC, "check socketChannel state failed.");
660 TransSetSocketChannelStateBySession(param.sessionName, param.sessionId, CORE_SESSION_STATE_LAN_COMPLETE);
661 AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
662 if (appInfo == NULL) {
663 TRANS_LOGE(TRANS_SVC, "malloc appInfo failed");
664 (void)TransDeleteSocketChannelInfoBySession(param.sessionName, param.sessionId);
665 (void)TransDelLaneReqFromPendingList(laneHandle, true);
666 TransFreeLane(laneHandle, param.isQosLane, true);
667 return;
668 }
669 ret = CreateAppInfoByParam(laneHandle, ¶m, appInfo);
670 if (ret != SOFTBUS_OK) {
671 TRANS_LOGE(TRANS_SVC, "CreateAppInfoByParam failed");
672 TransFreeAppInfo(appInfo);
673 TransFreeLane(laneHandle, param.isQosLane, true);
674 return;
675 }
676 appInfo->callingTokenId = callingTokenId;
677 appInfo->timeStart = timeStart;
678 NodeInfo nodeInfo;
679 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
680 int32_t peerRet = LnnGetRemoteNodeInfoById(appInfo->peerNetWorkId, CATEGORY_NETWORK_ID, &nodeInfo);
681 TransBuildTransOpenChannelStartEvent(&extra, appInfo, &nodeInfo, peerRet);
682 TransAsyncSetFirstTokenInfo(firstTokenId, appInfo, &extra);
683 TransAsyncOpenChannelProc(laneHandle, ¶m, appInfo, &extra, connInfo);
684 TransFreeAppInfo(appInfo);
685 (void)TransDelLaneReqFromPendingList(laneHandle, true);
686 }
687
TransBuildLaneAllocFailEvent(TransEventExtra * extra,TransInfo * transInfo,AppInfo * appInfo,SessionParam * param,int32_t reason)688 static void TransBuildLaneAllocFailEvent(
689 TransEventExtra *extra, TransInfo *transInfo, AppInfo *appInfo, SessionParam *param, int32_t reason)
690 {
691 extra->peerUdid = appInfo->peerUdid;
692 extra->peerDevVer = appInfo->peerVersion;
693 extra->deviceState = TransGetDeviceState(param->peerDeviceId);
694 extra->osType = appInfo->osType;
695 TransBuildTransOpenChannelEndEvent(extra, transInfo, appInfo->timeStart, reason);
696 }
697
TransOnAsyncLaneFail(uint32_t laneHandle,int32_t reason)698 static void TransOnAsyncLaneFail(uint32_t laneHandle, int32_t reason)
699 {
700 TRANS_LOGI(TRANS_SVC, "request failed, laneHandle=%{public}u, reason=%{public}d", laneHandle, reason);
701 SessionParam param;
702 (void)memset_s(¶m, sizeof(SessionParam), 0, sizeof(SessionParam));
703 param.isQosLane = true;
704 uint32_t callingTokenId = TOKENID_NOT_SET;
705 TransInfo transInfo = { .channelId = INVALID_CHANNEL_ID, .channelType = CHANNEL_TYPE_BUTT};
706 int64_t timeStart = 0;
707 int32_t ret = TransGetLaneReqItemParamByLaneHandle(laneHandle, ¶m, &callingTokenId, NULL, &timeStart);
708 if (ret != SOFTBUS_OK) {
709 TRANS_LOGE(TRANS_SVC, "get lane req item failed. laneHandle=%{public}u, ret=%{public}d", laneHandle, ret);
710 (void)TransDeleteSocketChannelInfoBySession(param.sessionName, param.sessionId);
711 (void)TransDelLaneReqFromPendingList(laneHandle, true);
712 return;
713 }
714 LaneTransType transType = (LaneTransType)TransGetLaneTransTypeBySession(¶m);
715 TransEventExtra extra;
716 extra.linkType = LANE_LINK_TYPE_BUTT;
717 BuildTransEventExtra(&extra, ¶m, laneHandle, transType, reason);
718 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_SELECT_LANE, extra);
719 if (reason == SOFTBUS_CONN_HV2_BLE_TRIGGER_TIMEOUT) {
720 SoftbusReportTransErrorEvt(SOFTBUS_CONN_HV2_BLE_TRIGGER_TIMEOUT);
721 }
722 AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
723 if (appInfo == NULL) {
724 TRANS_LOGE(TRANS_SVC, "malloc appInfo failed");
725 (void)TransDeleteSocketChannelInfoBySession(param.sessionName, param.sessionId);
726 (void)TransDelLaneReqFromPendingList(laneHandle, true);
727 return;
728 }
729 ret = CreateAppInfoByParam(laneHandle, ¶m, appInfo);
730 if (ret != SOFTBUS_OK) {
731 TRANS_LOGE(TRANS_SVC, "CreateAppInfoByParam failed");
732 TransFreeAppInfo(appInfo);
733 return;
734 }
735 appInfo->callingTokenId = callingTokenId;
736 appInfo->timeStart = timeStart;
737 CallbackOpenChannelFailed(¶m, appInfo, reason);
738 char localUdid[UDID_BUF_LEN] = { 0 };
739 (void)LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, localUdid, sizeof(localUdid));
740 extra.localUdid = localUdid;
741 TransBuildLaneAllocFailEvent(&extra, &transInfo, appInfo, ¶m, reason);
742 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_END, extra);
743 TransFreeAppInfo(appInfo);
744 (void)TransDeleteSocketChannelInfoBySession(param.sessionName, param.sessionId);
745 (void)TransDelLaneReqFromPendingList(laneHandle, true);
746 }
747
TransOnLaneRequestFail(uint32_t laneHandle,int32_t reason)748 static void TransOnLaneRequestFail(uint32_t laneHandle, int32_t reason)
749 {
750 TRANS_LOGI(TRANS_SVC, "request failed, laneHandle=%{public}u, reason=%{public}d", laneHandle, reason);
751 int32_t ret = TransUpdateLaneConnInfoByLaneHandle(laneHandle, false, NULL, false, reason);
752 if (ret != SOFTBUS_OK) {
753 TRANS_LOGE(TRANS_SVC, "update lane connInfo failed, laneHandle=%{public}u, ret=%{public}d", laneHandle, ret);
754 }
755 }
756
TransUpdateFreeLaneStatus(uint32_t laneHandle,bool isSucc,bool isAsync,int32_t errCode)757 static int32_t TransUpdateFreeLaneStatus(uint32_t laneHandle, bool isSucc, bool isAsync, int32_t errCode)
758 {
759 SoftBusList *freePendingList = g_freeLanePendingList;
760 TRANS_CHECK_AND_RETURN_RET_LOGE(freePendingList != NULL,
761 SOFTBUS_NO_INIT, TRANS_INIT, "free lane pending list no init.");
762 TRANS_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&freePendingList->lock) == SOFTBUS_OK,
763 SOFTBUS_LOCK_ERR, TRANS_SVC, "lock failed.");
764
765 TransFreeLaneItem *freeItem = NULL;
766 LIST_FOR_EACH_ENTRY(freeItem, &(freePendingList->list), TransFreeLaneItem, node) {
767 if (freeItem->laneHandle == laneHandle) {
768 freeItem->isSucc = isSucc;
769 freeItem->errCode = errCode;
770 freeItem->isFinished = true;
771 if (!isAsync) {
772 (void)SoftBusCondSignal(&freeItem->condVar);
773 }
774 (void)SoftBusMutexUnlock(&(freePendingList->lock));
775 return SOFTBUS_OK;
776 }
777 }
778 (void)SoftBusMutexUnlock(&(freePendingList->lock));
779 TRANS_LOGE(TRANS_SVC, "trans free lane not found. laneHandle=%{public}u", laneHandle);
780 return SOFTBUS_TRANS_NODE_NOT_FOUND;
781 }
782
TransOnLaneFreeSuccess(uint32_t laneHandle)783 static void TransOnLaneFreeSuccess(uint32_t laneHandle)
784 {
785 TRANS_LOGI(TRANS_SVC, "free lane success. laneHandle=%{public}u", laneHandle);
786 int32_t ret = TransUpdateFreeLaneStatus(laneHandle, true, false, SOFTBUS_OK);
787 if (ret != SOFTBUS_OK) {
788 TRANS_LOGE(TRANS_SVC, "update status failed, laneHandle=%{public}u, ret=%{public}d", laneHandle, ret);
789 }
790 }
791
TransOnLaneFreeFail(uint32_t laneHandle,int32_t reason)792 static void TransOnLaneFreeFail(uint32_t laneHandle, int32_t reason)
793 {
794 TRANS_LOGI(TRANS_SVC, "free lane failed, laneHandle=%{public}u, reason=%{public}d", laneHandle, reason);
795 int32_t ret = TransUpdateFreeLaneStatus(laneHandle, false, false, reason);
796 if (ret != SOFTBUS_OK) {
797 TRANS_LOGE(TRANS_SVC, "update status failed, laneHandle=%{public}u, ret=%{public}d", laneHandle, ret);
798 }
799 }
800
TransNotifyLaneQosEvent(uint32_t laneHandle,LaneOwner laneOwner,LaneQosEvent qosEvent)801 static int32_t TransNotifyLaneQosEvent(uint32_t laneHandle, LaneOwner laneOwner, LaneQosEvent qosEvent)
802 {
803 if (laneOwner > LANE_OWNER_BUTT || laneOwner < LANE_OWNER_SELF || qosEvent > LANE_QOS_BW_BUTT ||
804 qosEvent < LANE_QOS_BW_HIGH) {
805 TRANS_LOGE(
806 TRANS_SVC, "invalid lane owner or qos event, owner=%{public}d, qosEvent=%{public}d", laneOwner, qosEvent);
807 return SOFTBUS_INVALID_PARAM;
808 }
809 if (laneOwner != LANE_OWNER_OTHER || qosEvent != LANE_QOS_BW_HIGH) {
810 TRANS_LOGI(TRANS_SVC, "ignore lane qos event, owner=%{public}d, qosEvent=%{public}d", laneOwner, qosEvent);
811 return SOFTBUS_OK;
812 }
813 TransLaneInfo laneInfo;
814 (void)memset_s(&laneInfo, sizeof(TransLaneInfo), 0, sizeof(TransLaneInfo));
815 int32_t ret = TransGetTransLaneInfoByLaneHandle(laneHandle, &laneInfo);
816 if (ret != SOFTBUS_OK) {
817 TRANS_LOGE(TRANS_SVC, "get trans lane info failed, laneHandle=%{public}u, ret=%{public}d", laneHandle, ret);
818 return ret;
819 }
820 ChannelMsg data = {
821 .msgChannelId = laneInfo.channelId,
822 .msgChannelType = laneInfo.channelType,
823 .msgPid = laneInfo.pid,
824 .msgPkgName = laneInfo.pkgName,
825 .msgUuid = NULL,
826 .msgUdid = NULL
827 };
828 switch (qosEvent) {
829 case LANE_QOS_BW_HIGH: {
830 uint32_t count = 1;
831 QosTV qos[] = {
832 {QOS_TYPE_MIN_BW, 0},
833 };
834 QoSEvent event = QOS_SATISFIED;
835 ret = ClientIpcChannelOnQos(&data, event, (const QosTV *)qos, count);
836 if (ret != SOFTBUS_OK) {
837 TRANS_LOGE(
838 TRANS_SVC, "qos event failed, channelId=%{public}d, ret=%{public}d", laneInfo.channelId, ret);
839 }
840 break;
841 }
842 default:
843 ret = SOFTBUS_NOT_IMPLEMENT;
844 TRANS_LOGE(TRANS_SVC, "invalid lane qos event type, type=%{public}d", qosEvent);
845 break;
846 }
847 return ret;
848 }
849
TransOnLaneQosEvent(uint32_t laneHandle,LaneOwner laneOwner,LaneQosEvent qosEvent)850 static void TransOnLaneQosEvent(uint32_t laneHandle, LaneOwner laneOwner, LaneQosEvent qosEvent)
851 {
852 TRANS_LOGI(TRANS_SVC, "lane qos event, laneHandle=%{public}u, owner=%{public}d, qosEvent=%{public}d", laneHandle,
853 laneOwner, qosEvent);
854 int32_t ret = TransNotifyLaneQosEvent(laneHandle, laneOwner, qosEvent);
855 if (ret != SOFTBUS_OK) {
856 TRANS_LOGE(TRANS_SVC, "notify qos event failed, laneHandle=%{public}u, ret=%{public}d", laneHandle, ret);
857 }
858 }
859
860 static const LaneLinkType g_laneMap[LINK_TYPE_MAX + 1] = {
861 LANE_LINK_TYPE_BUTT,
862 LANE_WLAN_5G,
863 LANE_WLAN_2P4G,
864 LANE_P2P,
865 LANE_BR,
866 LANE_BLE,
867 LANE_P2P_REUSE,
868 LANE_BLE_DIRECT,
869 LANE_COC,
870 LANE_COC_DIRECT,
871 };
TransGetLaneLinkTypeBySessionLinkType(LinkType type)872 static LaneLinkType TransGetLaneLinkTypeBySessionLinkType(LinkType type)
873 {
874 return g_laneMap[type];
875 }
876
TransformSessionPreferredToLanePreferred(const SessionParam * param,LanePreferredLinkList * preferred,TransOption * transOption)877 static void TransformSessionPreferredToLanePreferred(const SessionParam *param,
878 LanePreferredLinkList *preferred, TransOption *transOption)
879 {
880 (void)transOption;
881 if (param->attr->linkTypeNum <= 0 || param->attr->linkTypeNum > LINK_TYPE_MAX) {
882 preferred->linkTypeNum = 0;
883 return;
884 }
885 preferred->linkTypeNum = 0;
886 for (int32_t i = 0; i < param->attr->linkTypeNum; ++i) {
887 LaneLinkType linkType = TransGetLaneLinkTypeBySessionLinkType(param->attr->linkType[i]);
888 if (linkType == LANE_LINK_TYPE_BUTT) {
889 continue;
890 }
891 if (preferred->linkTypeNum >= LINK_TYPE_MAX) {
892 TRANS_LOGE(TRANS_SVC,
893 "session preferred linknum override lane maxcnt=%{public}d.", LANE_LINK_TYPE_BUTT);
894 break;
895 }
896 preferred->linkType[preferred->linkTypeNum] = linkType;
897 preferred->linkTypeNum += 1;
898 }
899 return;
900 }
901
IsShareSession(const char * sessionName)902 static bool IsShareSession(const char *sessionName)
903 {
904 if (strlen(sessionName) < ISHARE_MIN_NAME_LEN ||
905 strncmp(sessionName, SESSION_NAME_ISHARE, ISHARE_MIN_NAME_LEN) != 0) {
906 return false;
907 }
908 return true;
909 }
910
IsDbdSession(const char * sessionName)911 static bool IsDbdSession(const char *sessionName)
912 {
913 if (sessionName == NULL) {
914 return false;
915 }
916
917 if (strncmp(sessionName, SESSION_NAME_DBD, strlen(SESSION_NAME_DBD)) == 0) {
918 return true;
919 }
920
921 return false;
922 }
923
IsDslSession(const char * sessionName)924 static bool IsDslSession(const char *sessionName)
925 {
926 if (sessionName == NULL) {
927 return false;
928 }
929
930 if (strncmp(sessionName, SESSION_NAME_DSL, strlen(SESSION_NAME_DSL)) == 0) {
931 return true;
932 }
933
934 if (CompareString(SESSION_NAME_DSL2_RE, sessionName, true) == SOFTBUS_OK) {
935 return true;
936 }
937
938 return false;
939 }
940
PeerDeviceIsLegacyOs(const char * peerNetworkId,const char * sessionName)941 static bool PeerDeviceIsLegacyOs(const char *peerNetworkId, const char *sessionName)
942 {
943 uint32_t authCapacity;
944 if (LnnGetDLAuthCapacity(peerNetworkId, &authCapacity) != SOFTBUS_OK) {
945 TRANS_LOGE(TRANS_SVC, "failed to get auth capacity");
946 return false;
947 }
948 if (authCapacity == 0 && IsDbdSession(sessionName)) {
949 return true;
950 }
951 return false;
952 }
953
ModuleLaneAdapter(LanePreferredLinkList * preferred)954 static void ModuleLaneAdapter(LanePreferredLinkList *preferred)
955 {
956 static LaneLinkType link[] = {
957 LANE_WLAN_5G,
958 LANE_WLAN_2P4G,
959 LANE_BR,
960 };
961 (void)memset_s(preferred->linkType, sizeof(preferred->linkType), 0, sizeof(preferred->linkType));
962 preferred->linkTypeNum = MIN(sizeof(link) / sizeof(link[0]), LANE_LINK_TYPE_BUTT);
963 for (uint32_t i = 0; i < preferred->linkTypeNum; i++) {
964 preferred->linkType[i] = link[i];
965 TRANS_LOGD(TRANS_SVC, "link=%{public}d", preferred->linkType[i]);
966 }
967 }
968
TransGetQosInfo(const SessionParam * param,QosInfo * qosInfo,AllocExtendInfo * extendInfo)969 static void TransGetQosInfo(const SessionParam *param, QosInfo *qosInfo, AllocExtendInfo *extendInfo)
970 {
971 if (!(param->isQosLane)) {
972 TRANS_LOGD(TRANS_SVC, "not support qos lane");
973 return;
974 }
975
976 for (uint32_t i = 0; i < param->qosCount; i++) {
977 switch (param->qos[i].qos) {
978 case QOS_TYPE_MIN_BW:
979 qosInfo->minBW = (param->qos[i].value > 0) ? param->qos[i].value : 0;
980 break;
981 case QOS_TYPE_MAX_LATENCY:
982 qosInfo->maxLaneLatency = (param->qos[i].value > 0) ? param->qos[i].value : 0;
983 break;
984 case QOS_TYPE_MIN_LATENCY:
985 qosInfo->minLaneLatency = (param->qos[i].value > 0) ? param->qos[i].value : 0;
986 break;
987 case QOS_TYPE_RTT_LEVEL:
988 qosInfo->rttLevel = (LaneRttLevel)((param->qos[i].value > 0) ? param->qos[i].value : 0);
989 break;
990 default:
991 GetExtQosInfo(param, qosInfo, i, extendInfo);
992 break;
993 }
994 }
995 }
996
997 #ifdef SOFTBUS_MINI_SYSTEM
TransGetBleMac(const SessionParam * param,LaneRequestOption * requestOption)998 static void TransGetBleMac(const SessionParam *param, LaneRequestOption *requestOption)
999 {
1000 if (LnnGetRemoteStrInfo(requestOption->requestInfo.trans.networkId, STRING_KEY_BLE_MAC,
1001 requestOption->requestInfo.trans.peerBleMac, BT_MAC_LEN) != SOFTBUS_OK) {
1002 if (strcpy_s(requestOption->requestInfo.trans.peerBleMac, BT_MAC_LEN, "") != EOK) {
1003 TRANS_LOGE(TRANS_SVC, "strcpy fail");
1004 }
1005 TRANS_LOGW(TRANS_SVC, "requestOption get ble mac fail.");
1006 }
1007 }
1008 #endif
1009
1010 #ifdef SOFTBUS_MINI_SYSTEM
TransGetBleMacForAllocLane(const SessionParam * param,LaneAllocInfo * allocInfo)1011 static void TransGetBleMacForAllocLane(const SessionParam *param, LaneAllocInfo *allocInfo)
1012 {
1013 if (LnnGetRemoteStrInfo(allocInfo->networkId, STRING_KEY_BLE_MAC,
1014 allocInfo->extendInfo.peerBleMac, BT_MAC_LEN) != SOFTBUS_OK) {
1015 if (strcpy_s(allocInfo->extendInfo.peerBleMac, BT_MAC_LEN, "") != EOK) {
1016 TRANS_LOGE(TRANS_SVC, "strcpy fail");
1017 }
1018 TRANS_LOGW(TRANS_SVC, "allocInfo get ble mac fail.");
1019 }
1020 }
1021 #endif
1022
GetAllocInfoBySessionParam(const SessionParam * param,LaneAllocInfo * allocInfo)1023 static int32_t GetAllocInfoBySessionParam(const SessionParam *param, LaneAllocInfo *allocInfo)
1024 {
1025 allocInfo->type = LANE_TYPE_TRANS;
1026 if (memcpy_s(allocInfo->networkId, NETWORK_ID_BUF_LEN, param->peerDeviceId, NETWORK_ID_BUF_LEN) != EOK) {
1027 TRANS_LOGE(TRANS_SVC, "memcpy networkId failed.");
1028 return SOFTBUS_MEM_ERR;
1029 }
1030 LaneTransType transType = (LaneTransType)TransGetLaneTransTypeBySession(param);
1031 if (transType == LANE_T_BUTT) {
1032 return SOFTBUS_TRANS_INVALID_SESSION_TYPE;
1033 }
1034 allocInfo->extendInfo.actionAddr = param->actionId;
1035 allocInfo->extendInfo.isSupportIpv6 = (param->attr->dataType != TYPE_STREAM && param->actionId > 0);
1036 allocInfo->extendInfo.networkDelegate = false;
1037 if (strcmp(param->sessionName, SESSION_NAME_PHONEPAD) == 0 ||
1038 strcmp(param->sessionName, SESSION_NAME_CASTPLUS) == 0) {
1039 allocInfo->extendInfo.networkDelegate = true;
1040 }
1041 allocInfo->transType = transType;
1042 allocInfo->acceptableProtocols = LNN_PROTOCOL_ALL ^ LNN_PROTOCOL_NIP;
1043 TransGetQosInfo(param, &allocInfo->qosRequire, &(allocInfo->extendInfo));
1044 if (IsDslSession(param->sessionName)) {
1045 // support wifi and br link
1046 allocInfo->qosRequire.minBW = MESH_MAGIC_BW;
1047 TRANS_LOGI(TRANS_SVC, "adapt mesh, minBw=%{public}u", allocInfo->qosRequire.minBW);
1048 } else if (PeerDeviceIsLegacyOs(param->peerDeviceId, param->sessionName)) {
1049 // support p2preuse, wifi and br link
1050 allocInfo->qosRequire.minBW = DB_MAGIC_BW;
1051 TRANS_LOGI(TRANS_SVC, "adapt legacy os device and dbd session, minBw=%{public}u", allocInfo->qosRequire.minBW);
1052 }
1053
1054 NodeInfo info;
1055 int32_t ret = LnnGetRemoteNodeInfoById(allocInfo->networkId, CATEGORY_NETWORK_ID, &info);
1056 if ((ret == SOFTBUS_OK) && LnnHasDiscoveryType(&info, DISCOVERY_TYPE_LSA)) {
1057 allocInfo->acceptableProtocols |= LNN_PROTOCOL_NIP;
1058 }
1059 #ifdef SOFTBUS_MINI_SYSTEM
1060 // get ble mac only on mini system
1061 TransGetBleMacForAllocLane(param, allocInfo);
1062 #endif
1063 int32_t uid;
1064 ret = TransGetUidAndPid(param->sessionName, &uid, &(allocInfo->pid));
1065 if (ret != SOFTBUS_OK) {
1066 TRANS_LOGE(TRANS_SVC, "transGetUidAndPid failed");
1067 return ret;
1068 }
1069 return SOFTBUS_OK;
1070 }
1071
GetRequestOptionBySessionParam(const SessionParam * param,LaneRequestOption * requestOption)1072 static int32_t GetRequestOptionBySessionParam(const SessionParam *param, LaneRequestOption *requestOption)
1073 {
1074 requestOption->type = LANE_TYPE_TRANS;
1075 if (memcpy_s(requestOption->requestInfo.trans.networkId, NETWORK_ID_BUF_LEN,
1076 param->peerDeviceId, NETWORK_ID_BUF_LEN) != EOK) {
1077 TRANS_LOGE(TRANS_SVC, "memcpy networkId failed.");
1078 return SOFTBUS_MEM_ERR;
1079 }
1080
1081 LaneTransType transType = (LaneTransType)TransGetLaneTransTypeBySession(param);
1082 if (transType == LANE_T_BUTT) {
1083 return SOFTBUS_TRANS_INVALID_SESSION_TYPE;
1084 }
1085 requestOption->requestInfo.trans.networkDelegate = false;
1086 if (strcmp(param->sessionName, SESSION_NAME_PHONEPAD) == 0 ||
1087 strcmp(param->sessionName, SESSION_NAME_CASTPLUS) == 0) {
1088 requestOption->requestInfo.trans.networkDelegate = true;
1089 }
1090 requestOption->requestInfo.trans.p2pOnly = false;
1091 if (strcmp(param->sessionName, SESSION_NAME_DISTRIBUTE_COMMUNICATION) == 0 || IsShareSession(param->sessionName)) {
1092 requestOption->requestInfo.trans.p2pOnly = true;
1093 }
1094 requestOption->requestInfo.trans.transType = transType;
1095 requestOption->requestInfo.trans.expectedBw = 0; /* init expectBW */
1096 requestOption->requestInfo.trans.acceptableProtocols = LNN_PROTOCOL_ALL ^ LNN_PROTOCOL_NIP;
1097
1098 NodeInfo info;
1099 int32_t ret = LnnGetRemoteNodeInfoById(requestOption->requestInfo.trans.networkId, CATEGORY_NETWORK_ID, &info);
1100 if ((ret == SOFTBUS_OK) && LnnHasDiscoveryType(&info, DISCOVERY_TYPE_LSA)) {
1101 requestOption->requestInfo.trans.acceptableProtocols |= LNN_PROTOCOL_NIP;
1102 }
1103 #ifdef SOFTBUS_MINI_SYSTEM
1104 // get ble mac only on mini system
1105 TransGetBleMac(param, requestOption);
1106 #endif
1107 int32_t uid;
1108 ret = TransGetUidAndPid(param->sessionName, &uid, &(requestOption->requestInfo.trans.pid));
1109 if (ret != SOFTBUS_OK) {
1110 TRANS_LOGE(TRANS_SVC, "transGetUidAndPid failed.");
1111 return ret;
1112 }
1113
1114 TransformSessionPreferredToLanePreferred(param, &(requestOption->requestInfo.trans.expectedLink),
1115 &requestOption->requestInfo.trans);
1116 if (!(param->isQosLane) &&
1117 (PeerDeviceIsLegacyOs(param->peerDeviceId, param->sessionName) || IsDslSession(param->sessionName))) {
1118 ModuleLaneAdapter(&(requestOption->requestInfo.trans.expectedLink));
1119 TRANS_LOGI(TRANS_SVC, "adapt expected link, wifi or br");
1120 }
1121 requestOption->requestInfo.trans.actionAddr = param->actionId;
1122 requestOption->requestInfo.trans.isSupportIpv6 = param->attr->dataType != TYPE_STREAM && param->actionId > 0;
1123 return SOFTBUS_OK;
1124 }
1125
TransSoftBusCondWait(SoftBusCond * cond,SoftBusMutex * mutex,uint32_t timeMillis)1126 static int32_t TransSoftBusCondWait(SoftBusCond *cond, SoftBusMutex *mutex, uint32_t timeMillis)
1127 {
1128 #define CONVERSION_BASE 1000LL
1129 if (timeMillis == 0) {
1130 return SoftBusCondWait(cond, mutex, NULL);
1131 }
1132
1133 SoftBusSysTime now;
1134 int32_t ret = SoftBusGetTime(&now);
1135 if (ret != SOFTBUS_OK) {
1136 TRANS_LOGE(TRANS_SVC, "trans softbus get time failed.");
1137 return ret;
1138 }
1139 int64_t usTime = now.sec * CONVERSION_BASE * CONVERSION_BASE + now.usec + (int32_t)timeMillis * CONVERSION_BASE;
1140 SoftBusSysTime tv;
1141 tv.sec = usTime / CONVERSION_BASE / CONVERSION_BASE;
1142 tv.usec = usTime % (CONVERSION_BASE * CONVERSION_BASE);
1143 TRANS_LOGI(TRANS_SVC, "start wait cond endSecond=%{public}" PRId64, tv.sec);
1144 return SoftBusCondWait(cond, mutex, &tv);
1145 }
1146
TransWaitingRequestCallback(uint32_t laneHandle)1147 static int32_t TransWaitingRequestCallback(uint32_t laneHandle)
1148 {
1149 if (g_reqLanePendingList == NULL) {
1150 TRANS_LOGE(TRANS_SVC, "lane request list hasn't init.");
1151 return SOFTBUS_NO_INIT;
1152 }
1153 if (SoftBusMutexLock(&(g_reqLanePendingList->lock)) != SOFTBUS_OK) {
1154 TRANS_LOGE(TRANS_SVC, "lock failed.");
1155 return SOFTBUS_LOCK_ERR;
1156 }
1157 bool isFound = false;
1158 TransReqLaneItem *item = NULL;
1159 LIST_FOR_EACH_ENTRY(item, &(g_reqLanePendingList->list), TransReqLaneItem, node) {
1160 if (item->laneHandle == laneHandle) {
1161 isFound = true;
1162 break;
1163 }
1164 }
1165 if (!isFound) {
1166 (void)SoftBusMutexUnlock(&(g_reqLanePendingList->lock));
1167 TRANS_LOGI(TRANS_SVC, "not found laneHandle in pending. laneHandle=%{public}u", laneHandle);
1168 return SOFTBUS_NOT_FIND;
1169 }
1170 if (item->isFinished == false) {
1171 int32_t rc = TransSoftBusCondWait(&item->cond, &g_reqLanePendingList->lock, 0);
1172 if (rc != SOFTBUS_OK) {
1173 (void)SoftBusMutexUnlock(&(g_reqLanePendingList->lock));
1174 TRANS_LOGI(TRANS_SVC, "wait cond failed laneHandle=%{public}u", laneHandle);
1175 return rc;
1176 }
1177 }
1178 (void)SoftBusMutexUnlock(&(g_reqLanePendingList->lock));
1179 TRANS_LOGI(TRANS_SVC, "receive lane cond laneHandle=%{public}u", laneHandle);
1180 return SOFTBUS_OK;
1181 }
1182
TransAddLaneReqToPendingAndWaiting(uint32_t laneHandle,const LaneRequestOption * requestOption)1183 static int32_t TransAddLaneReqToPendingAndWaiting(uint32_t laneHandle, const LaneRequestOption *requestOption)
1184 {
1185 int32_t ret = TransAddLaneReqFromPendingList(laneHandle);
1186 if (ret != SOFTBUS_OK) {
1187 TRANS_LOGE(TRANS_SVC, "add laneHandle to pending failed. laneHandle=%{public}u, ret=%{public}d",
1188 laneHandle, ret);
1189 return ret;
1190 }
1191 ILaneListener listener;
1192 listener.onLaneRequestSuccess = TransOnLaneRequestSuccess;
1193 listener.onLaneRequestFail = TransOnLaneRequestFail;
1194 ret = LnnRequestLane(laneHandle, requestOption, &listener);
1195 if (ret != SOFTBUS_OK) {
1196 TRANS_LOGE(TRANS_SVC, "trans request lane failed. ret=%{public}d", ret);
1197 (void)TransDelLaneReqFromPendingList(laneHandle, false);
1198 return ret;
1199 }
1200 TRANS_LOGI(TRANS_SVC, "add laneHandle to pending and start waiting. laneHandle=%{public}u", laneHandle);
1201 ret = TransWaitingRequestCallback(laneHandle);
1202 if (ret != SOFTBUS_OK) {
1203 (void)TransDelLaneReqFromPendingList(laneHandle, false);
1204 return ret;
1205 }
1206 return SOFTBUS_OK;
1207 }
1208
TransAddLaneAllocToPendingAndWaiting(uint32_t laneHandle,const LaneAllocInfo * allocInfo)1209 static int32_t TransAddLaneAllocToPendingAndWaiting(uint32_t laneHandle, const LaneAllocInfo *allocInfo)
1210 {
1211 int32_t ret = TransAddLaneReqFromPendingList(laneHandle);
1212 if (ret != SOFTBUS_OK) {
1213 TransFreeLane(laneHandle, true, true);
1214 TRANS_LOGE(TRANS_SVC, "add laneHandle to pending failed. laneHandle=%{public}u, ret=%{public}d",
1215 laneHandle, ret);
1216 return ret;
1217 }
1218 LaneAllocListener allocListener;
1219 allocListener.onLaneAllocSuccess = TransOnLaneRequestSuccess;
1220 allocListener.onLaneAllocFail = TransOnLaneRequestFail;
1221 allocListener.onLaneFreeSuccess = TransOnLaneFreeSuccess;
1222 allocListener.onLaneFreeFail = TransOnLaneFreeFail;
1223 allocListener.onLaneQosEvent = TransOnLaneQosEvent;
1224 TRANS_CHECK_AND_RETURN_RET_LOGE(
1225 GetLaneManager() != NULL, SOFTBUS_TRANS_GET_LANE_INFO_ERR, TRANS_SVC, "GetLaneManager is null");
1226 TRANS_CHECK_AND_RETURN_RET_LOGE(GetLaneManager()->lnnAllocLane != NULL, SOFTBUS_TRANS_GET_LANE_INFO_ERR,
1227 TRANS_SVC, "lnnAllocLane is null");
1228 ret = GetLaneManager()->lnnAllocLane(laneHandle, allocInfo, &allocListener);
1229 if (ret != SOFTBUS_OK) {
1230 TRANS_LOGE(TRANS_SVC, "trans request lane failed, ret=%{public}d", ret);
1231 (void)TransDelLaneReqFromPendingList(laneHandle, false);
1232 return ret;
1233 }
1234 TRANS_LOGI(TRANS_SVC, "add laneHandle to pending and start waiting. laneHandle=%{public}u", laneHandle);
1235 ret = TransWaitingRequestCallback(laneHandle);
1236 if (ret != SOFTBUS_OK) {
1237 (void)TransDelLaneReqFromPendingList(laneHandle, false);
1238 return ret;
1239 }
1240 return SOFTBUS_OK;
1241 }
1242
CancelLaneOnWaitLaneState(uint32_t laneHandle,bool isQosLane)1243 static void CancelLaneOnWaitLaneState(uint32_t laneHandle, bool isQosLane)
1244 {
1245 TRANS_LOGI(TRANS_SVC, "Cancel lane, laneHandle=%{public}u, isQosLane=%{public}d", laneHandle, isQosLane);
1246 if (isQosLane && laneHandle != 0) {
1247 TRANS_CHECK_AND_RETURN_LOGE(GetLaneManager() != NULL, TRANS_SVC, "GetLaneManager is null");
1248 TRANS_CHECK_AND_RETURN_LOGE(GetLaneManager()->lnnCancelLane != NULL, TRANS_SVC, "lnnCancelLane is null");
1249 int32_t ret = GetLaneManager()->lnnCancelLane(laneHandle);
1250 if (ret != SOFTBUS_OK) {
1251 TRANS_LOGE(
1252 TRANS_SVC, "Cancel lane failed, free lane. laneHandle=%{public}u, ret=%{public}d", laneHandle, ret);
1253 TransFreeLane(laneHandle, isQosLane, false);
1254 }
1255 }
1256 }
1257
TransGetLaneInfoByOption(const LaneRequestOption * requestOption,LaneConnInfo * connInfo,uint32_t * laneHandle)1258 int32_t TransGetLaneInfoByOption(const LaneRequestOption *requestOption, LaneConnInfo *connInfo, uint32_t *laneHandle)
1259 {
1260 if ((requestOption == NULL) || (connInfo == NULL) || (laneHandle == NULL)) {
1261 TRANS_LOGE(TRANS_SVC, "get lane info by option param error.");
1262 return SOFTBUS_INVALID_PARAM;
1263 }
1264 TRANS_CHECK_AND_RETURN_RET_LOGE(
1265 GetLaneManager() != NULL, SOFTBUS_TRANS_GET_LANE_INFO_ERR, TRANS_SVC, "GetLaneManager is null");
1266 TRANS_CHECK_AND_RETURN_RET_LOGE(GetLaneManager()->lnnGetLaneHandle != NULL, SOFTBUS_TRANS_GET_LANE_INFO_ERR,
1267 TRANS_SVC, "lnnGetLaneHandle is null");
1268 *laneHandle = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_TRANS);
1269 int32_t ret = TransAddLaneReqToPendingAndWaiting(*laneHandle, requestOption);
1270 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SVC, "trans add lane to pending list failed.");
1271
1272 bool bSuccess = false;
1273 int32_t errCode = SOFTBUS_NOT_FIND;
1274 if (TransGetLaneReqItemByLaneHandle(*laneHandle, &bSuccess, connInfo, &errCode) != SOFTBUS_OK) {
1275 TRANS_LOGE(TRANS_SVC, "get lane req item failed. laneHandle=%{public}u, errCode=%{public}d",
1276 *laneHandle, errCode);
1277 (void)TransDelLaneReqFromPendingList(*laneHandle, false);
1278 return errCode;
1279 }
1280 TRANS_LOGI(TRANS_SVC, "request lane conninfo end. laneHandle=%{public}u. errCode=%{public}d",
1281 *laneHandle, errCode);
1282 (void)TransDelLaneReqFromPendingList(*laneHandle, false);
1283 return errCode;
1284 }
1285
TransGetLaneInfoByQos(const LaneAllocInfo * allocInfo,LaneConnInfo * connInfo,uint32_t * laneHandle)1286 int32_t TransGetLaneInfoByQos(const LaneAllocInfo *allocInfo, LaneConnInfo *connInfo, uint32_t *laneHandle)
1287 {
1288 if ((allocInfo == NULL) || (connInfo == NULL) || (laneHandle == NULL)) {
1289 TRANS_LOGE(TRANS_SVC, "get lane info param error.");
1290 return SOFTBUS_INVALID_PARAM;
1291 }
1292 int32_t ret = TransAddLaneAllocToPendingAndWaiting(*laneHandle, allocInfo);
1293 if (ret != SOFTBUS_OK) {
1294 TRANS_LOGE(TRANS_SVC, "trans add lane to pending list failed. ret=%{public}d", ret);
1295 return ret;
1296 }
1297 bool bSuccess = false;
1298 int32_t errCode = SOFTBUS_NOT_FIND;
1299 if (TransGetLaneReqItemByLaneHandle(*laneHandle, &bSuccess, connInfo, &errCode) != SOFTBUS_OK) {
1300 TRANS_LOGE(TRANS_SVC, "get lane req item failed. laneHandle=%{public}u, errCode=%{public}d",
1301 *laneHandle, errCode);
1302 (void)TransDelLaneReqFromPendingList(*laneHandle, false);
1303 return errCode;
1304 }
1305 TRANS_LOGI(TRANS_SVC, "request lane conninfo end. laneHandle=%{public}u. errCode=%{public}d",
1306 *laneHandle, errCode);
1307 (void)TransDelLaneReqFromPendingList(*laneHandle, false);
1308 return errCode;
1309 }
1310
TransGetLaneInfo(const SessionParam * param,LaneConnInfo * connInfo,uint32_t * laneHandle)1311 int32_t TransGetLaneInfo(const SessionParam *param, LaneConnInfo *connInfo, uint32_t *laneHandle)
1312 {
1313 if (param == NULL || connInfo == NULL || laneHandle == NULL) {
1314 TRANS_LOGE(TRANS_SVC, "get lane info param error.");
1315 return SOFTBUS_INVALID_PARAM;
1316 }
1317 CoreSessionState state = CORE_SESSION_STATE_INIT;
1318 TransGetSocketChannelStateBySession(param->sessionName, param->sessionId, &state);
1319 TRANS_CHECK_AND_RETURN_RET_LOGW(state != CORE_SESSION_STATE_CANCELLING, SOFTBUS_TRANS_STOP_BIND_BY_CANCEL,
1320 TRANS_SVC, "cancel state, return cancel code.");
1321 TransSetSocketChannelStateBySession(param->sessionName, param->sessionId, CORE_SESSION_STATE_WAIT_LANE);
1322 int32_t ret = SOFTBUS_OK;
1323 TransEventExtra extra;
1324 if (!(param->isQosLane)) {
1325 LaneRequestOption requestOption;
1326 (void)memset_s(&requestOption, sizeof(LaneRequestOption), 0, sizeof(LaneRequestOption));
1327 ret = GetRequestOptionBySessionParam(param, &requestOption);
1328 TRANS_CHECK_AND_RETURN_RET_LOGE(
1329 ret == SOFTBUS_OK, ret, TRANS_SVC, "get request option failed ret=%{public}d", ret);
1330 ret = TransGetLaneInfoByOption(&requestOption, connInfo, laneHandle);
1331 extra.linkType = connInfo->type;
1332 BuildTransEventExtra(&extra, param, *laneHandle, requestOption.requestInfo.trans.transType, ret);
1333 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_SELECT_LANE, extra);
1334 TransUpdateSocketChannelLaneInfoBySession(
1335 param->sessionName, param->sessionId, *laneHandle, param->isQosLane, param->isAsync);
1336 TRANS_CHECK_AND_RETURN_RET_LOGE(
1337 ret == SOFTBUS_OK, ret, TRANS_SVC, "get lane info by option failed, ret=%{public}d", ret);
1338 } else {
1339 LaneAllocInfo allocInfo;
1340 (void)memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo));
1341 ret = GetAllocInfoBySessionParam(param, &allocInfo);
1342 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SVC, "get alloc Info failed ret=%{public}d", ret);
1343 TRANS_CHECK_AND_RETURN_RET_LOGE(
1344 GetLaneManager() != NULL, SOFTBUS_TRANS_GET_LANE_INFO_ERR, TRANS_SVC, "GetLaneManager is null");
1345 TRANS_CHECK_AND_RETURN_RET_LOGE(GetLaneManager()->lnnGetLaneHandle != NULL, SOFTBUS_TRANS_GET_LANE_INFO_ERR,
1346 TRANS_SVC, "lnnGetLaneHandle is null");
1347 *laneHandle = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_TRANS);
1348 TransUpdateSocketChannelLaneInfoBySession(
1349 param->sessionName, param->sessionId, *laneHandle, param->isQosLane, param->isAsync);
1350 ret = TransGetLaneInfoByQos(&allocInfo, connInfo, laneHandle);
1351 extra.linkType = connInfo->type;
1352 BuildTransEventExtra(&extra, param, *laneHandle, allocInfo.transType, ret);
1353 TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_SELECT_LANE, extra);
1354 if (ret != SOFTBUS_OK) {
1355 *laneHandle = INVALID_LANE_REQ_ID; // qos lane failed no need free lane again
1356 TRANS_LOGE(TRANS_SVC, "get lane info by allocInfo failed, ret=%{public}d", ret);
1357 return ret;
1358 }
1359 }
1360 return SOFTBUS_OK;
1361 }
1362
TransAsyncGetLaneInfoByOption(const SessionParam * param,const LaneRequestOption * requestOption,uint32_t * laneHandle,uint32_t callingTokenId,int64_t timeStart)1363 int32_t TransAsyncGetLaneInfoByOption(const SessionParam *param, const LaneRequestOption *requestOption,
1364 uint32_t *laneHandle, uint32_t callingTokenId, int64_t timeStart)
1365 {
1366 if (param == NULL || requestOption == NULL || laneHandle == NULL) {
1367 TRANS_LOGE(TRANS_SVC, "async get lane info param error.");
1368 return SOFTBUS_INVALID_PARAM;
1369 }
1370 TRANS_CHECK_AND_RETURN_RET_LOGE(
1371 GetLaneManager() != NULL, SOFTBUS_TRANS_GET_LANE_INFO_ERR, TRANS_SVC, "GetLaneManager is null");
1372 TRANS_CHECK_AND_RETURN_RET_LOGE(GetLaneManager()->lnnGetLaneHandle != NULL, SOFTBUS_TRANS_GET_LANE_INFO_ERR,
1373 TRANS_SVC, "lnnGetLaneHandle is null");
1374 *laneHandle = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_TRANS);
1375 TransUpdateSocketChannelLaneInfoBySession(
1376 param->sessionName, param->sessionId, *laneHandle, param->isQosLane, param->isAsync);
1377 int32_t ret = TransAddAsyncLaneReqFromPendingList(*laneHandle, param, callingTokenId, timeStart);
1378 if (ret != SOFTBUS_OK) {
1379 TRANS_LOGE(
1380 TRANS_SVC, "add laneHandle=%{public}u to async pending list failed, ret=%{public}d", *laneHandle, ret);
1381 return ret;
1382 }
1383 ILaneListener listener;
1384 listener.onLaneRequestSuccess = TransOnAsyncLaneSuccess;
1385 listener.onLaneRequestFail = TransOnAsyncLaneFail;
1386 ret = LnnRequestLane(*laneHandle, requestOption, &listener);
1387 if (ret != SOFTBUS_OK) {
1388 TRANS_LOGE(TRANS_SVC, "trans request lane failed, laneHandle=%{public}u, ret=%{public}d", *laneHandle, ret);
1389 (void)TransDelLaneReqFromPendingList(*laneHandle, true);
1390 return ret;
1391 }
1392 CoreSessionState state = CORE_SESSION_STATE_INIT;
1393 TransGetSocketChannelStateBySession(param->sessionName, param->sessionId, &state);
1394 if (state == CORE_SESSION_STATE_CANCELLING) {
1395 CancelLaneOnWaitLaneState(*laneHandle, param->isQosLane);
1396 (void)TransDelLaneReqFromPendingList(*laneHandle, true);
1397 return SOFTBUS_TRANS_STOP_BIND_BY_CANCEL;
1398 }
1399 TransSetSocketChannelStateBySession(param->sessionName, param->sessionId, CORE_SESSION_STATE_WAIT_LANE);
1400 return SOFTBUS_OK;
1401 }
1402
TransAsyncGetLaneInfoByQos(const SessionParam * param,const LaneAllocInfo * allocInfo,uint32_t * laneHandle,uint32_t callingTokenId,int64_t timeStart)1403 int32_t TransAsyncGetLaneInfoByQos(const SessionParam *param, const LaneAllocInfo *allocInfo,
1404 uint32_t *laneHandle, uint32_t callingTokenId, int64_t timeStart)
1405 {
1406 if (param == NULL || allocInfo == NULL || laneHandle == NULL) {
1407 TRANS_LOGE(TRANS_SVC, "async get lane info param error.");
1408 return SOFTBUS_INVALID_PARAM;
1409 }
1410 TRANS_CHECK_AND_RETURN_RET_LOGE(
1411 GetLaneManager() != NULL, SOFTBUS_TRANS_GET_LANE_INFO_ERR, TRANS_SVC, "GetLaneManager is null");
1412 TRANS_CHECK_AND_RETURN_RET_LOGE(GetLaneManager()->lnnGetLaneHandle != NULL, SOFTBUS_TRANS_GET_LANE_INFO_ERR,
1413 TRANS_SVC, "lnnGetLaneHandle is null");
1414 *laneHandle = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_TRANS);
1415 TransUpdateSocketChannelLaneInfoBySession(
1416 param->sessionName, param->sessionId, *laneHandle, param->isQosLane, param->isAsync);
1417 int32_t ret = TransAddAsyncLaneReqFromPendingList(*laneHandle, param, callingTokenId, timeStart);
1418 if (ret != SOFTBUS_OK) {
1419 TRANS_LOGE(
1420 TRANS_SVC, "add laneHandle=%{public}u to async pending list failed, ret=%{public}d", *laneHandle, ret);
1421 TransFreeLane(*laneHandle, true, true);
1422 return ret;
1423 }
1424 LaneAllocListener allocListener;
1425 allocListener.onLaneAllocSuccess = TransOnAsyncLaneSuccess;
1426 allocListener.onLaneAllocFail = TransOnAsyncLaneFail;
1427 allocListener.onLaneFreeSuccess = TransOnLaneFreeSuccess;
1428 allocListener.onLaneFreeFail = TransOnLaneFreeFail;
1429 allocListener.onLaneQosEvent = TransOnLaneQosEvent;
1430 TRANS_CHECK_AND_RETURN_RET_LOGE(GetLaneManager()->lnnAllocLane != NULL, SOFTBUS_TRANS_GET_LANE_INFO_ERR,
1431 TRANS_SVC, "lnnAllocLane is null");
1432 ret = GetLaneManager()->lnnAllocLane(*laneHandle, allocInfo, &allocListener);
1433 if (ret != SOFTBUS_OK) {
1434 TRANS_LOGE(TRANS_SVC, "trans request lane failed, ret=%{public}d", ret);
1435 (void)TransDelLaneReqFromPendingList(*laneHandle, true);
1436 return ret;
1437 }
1438 CoreSessionState state = CORE_SESSION_STATE_INIT;
1439 TransGetSocketChannelStateBySession(param->sessionName, param->sessionId, &state);
1440 if (state == CORE_SESSION_STATE_CANCELLING) {
1441 CancelLaneOnWaitLaneState(*laneHandle, param->isQosLane);
1442 (void)TransDelLaneReqFromPendingList(*laneHandle, true);
1443 return SOFTBUS_TRANS_STOP_BIND_BY_CANCEL;
1444 }
1445 TransSetSocketChannelStateBySession(param->sessionName, param->sessionId, CORE_SESSION_STATE_WAIT_LANE);
1446 return SOFTBUS_OK;
1447 }
1448
TransAsyncGetLaneInfo(const SessionParam * param,uint32_t * laneHandle,uint32_t callingTokenId,int64_t timeStart)1449 int32_t TransAsyncGetLaneInfo(
1450 const SessionParam *param, uint32_t *laneHandle, uint32_t callingTokenId, int64_t timeStart)
1451 {
1452 if (param == NULL || laneHandle == NULL) {
1453 TRANS_LOGE(TRANS_SVC, "async get lane info param error.");
1454 return SOFTBUS_INVALID_PARAM;
1455 }
1456 int32_t ret = SOFTBUS_OK;
1457 LaneAllocInfo allocInfo;
1458 (void)memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo));
1459 ret = GetAllocInfoBySessionParam(param, &allocInfo);
1460 if (ret != SOFTBUS_OK) {
1461 TRANS_LOGE(TRANS_SVC, "get alloc Info failed. laneHandle=%{public}u, ret=%{public}d", *laneHandle, ret);
1462 return ret;
1463 }
1464 ret = TransAsyncGetLaneInfoByQos(param, &allocInfo, laneHandle, callingTokenId, timeStart);
1465 if (ret != SOFTBUS_OK) {
1466 TRANS_LOGE(TRANS_SVC, "get lane info by allocInfo failed, ret=%{public}d", ret);
1467 *laneHandle = INVALID_LANE_REQ_ID; // qos lane failed no need free lane again
1468 return ret;
1469 }
1470
1471 return SOFTBUS_OK;
1472 }
1473
SetP2pConnInfo(const P2pConnInfo * p2pInfo,ConnectOption * connOpt)1474 static int32_t SetP2pConnInfo(const P2pConnInfo *p2pInfo, ConnectOption *connOpt)
1475 {
1476 TRANS_LOGI(TRANS_SVC, "set p2p conn info.");
1477 connOpt->type = CONNECT_P2P;
1478 if (strcpy_s(connOpt->socketOption.addr, sizeof(connOpt->socketOption.addr), p2pInfo->peerIp) != EOK) {
1479 TRANS_LOGE(TRANS_SVC, "set p2p localIp err");
1480 return SOFTBUS_STRCPY_ERR;
1481 }
1482 connOpt->socketOption.protocol = LNN_PROTOCOL_IP;
1483 connOpt->socketOption.port = -1;
1484 return SOFTBUS_OK;
1485 }
1486
SetP2pReusesConnInfo(const WlanConnInfo * connInfo,ConnectOption * connOpt)1487 static int32_t SetP2pReusesConnInfo(const WlanConnInfo *connInfo, ConnectOption *connOpt)
1488 {
1489 connOpt->type = CONNECT_P2P_REUSE;
1490 connOpt->socketOption.port = (int32_t)connInfo->port;
1491 connOpt->socketOption.protocol = connInfo->protocol;
1492 if (strcpy_s(connOpt->socketOption.addr, sizeof(connOpt->socketOption.addr), connInfo->addr) != EOK) {
1493 TRANS_LOGE(TRANS_SVC, "set p2p reuse localIp err");
1494 return SOFTBUS_STRCPY_ERR;
1495 }
1496 return SOFTBUS_OK;
1497 }
1498
SetWlanConnInfo(const WlanConnInfo * connInfo,ConnectOption * connOpt)1499 static int32_t SetWlanConnInfo(const WlanConnInfo *connInfo, ConnectOption *connOpt)
1500 {
1501 connOpt->type = CONNECT_TCP;
1502 connOpt->socketOption.port = (int32_t)connInfo->port;
1503 connOpt->socketOption.protocol = connInfo->protocol;
1504 if (strcpy_s(connOpt->socketOption.addr, sizeof(connOpt->socketOption.addr), connInfo->addr) != EOK) {
1505 TRANS_LOGE(TRANS_SVC, "set wlan localIp err");
1506 return SOFTBUS_STRCPY_ERR;
1507 }
1508 return SOFTBUS_OK;
1509 }
1510
SetBrConnInfo(const BrConnInfo * brInfo,ConnectOption * connOpt)1511 static int32_t SetBrConnInfo(const BrConnInfo *brInfo, ConnectOption *connOpt)
1512 {
1513 connOpt->type = CONNECT_BR;
1514 if (strcpy_s(connOpt->brOption.brMac, sizeof(connOpt->brOption.brMac), brInfo->brMac) != EOK) {
1515 TRANS_LOGE(TRANS_SVC, "set br mac err");
1516 return SOFTBUS_STRCPY_ERR;
1517 }
1518
1519 return SOFTBUS_OK;
1520 }
1521
SetBleConnInfo(const BleConnInfo * bleInfo,ConnectOption * connOpt)1522 static int32_t SetBleConnInfo(const BleConnInfo *bleInfo, ConnectOption *connOpt)
1523 {
1524 connOpt->type = CONNECT_BLE;
1525 if (strcpy_s(connOpt->bleOption.bleMac, sizeof(connOpt->bleOption.bleMac), bleInfo->bleMac) != EOK) {
1526 TRANS_LOGE(TRANS_SVC, "set ble mac err");
1527 return SOFTBUS_STRCPY_ERR;
1528 }
1529 if (memcpy_s(connOpt->bleOption.deviceIdHash, sizeof(connOpt->bleOption.deviceIdHash),
1530 bleInfo->deviceIdHash, sizeof(bleInfo->deviceIdHash)) != EOK) {
1531 TRANS_LOGE(TRANS_SVC, "memcpy_s deviceId hash err");
1532 return SOFTBUS_MEM_ERR;
1533 }
1534 connOpt->bleOption.protocol = bleInfo->protoType;
1535 connOpt->bleOption.psm = bleInfo->psm;
1536 connOpt->bleOption.fastestConnectEnable = true;
1537 return SOFTBUS_OK;
1538 }
1539
SetBleDirectConnInfo(const BleDirectConnInfo * bleDirect,ConnectOption * connOpt)1540 static int32_t SetBleDirectConnInfo(const BleDirectConnInfo *bleDirect, ConnectOption *connOpt)
1541 {
1542 if (strcpy_s(connOpt->bleDirectOption.networkId, NETWORK_ID_BUF_LEN, bleDirect->networkId) != EOK) {
1543 TRANS_LOGW(TRANS_SVC, "set networkId err.");
1544 return SOFTBUS_STRCPY_ERR;
1545 }
1546 connOpt->type = CONNECT_BLE_DIRECT;
1547 connOpt->bleDirectOption.protoType = bleDirect->protoType;
1548 return SOFTBUS_OK;
1549 }
1550
SetHmlConnectInfo(const P2pConnInfo * p2pInfo,ConnectOption * connOpt)1551 static int32_t SetHmlConnectInfo(const P2pConnInfo *p2pInfo, ConnectOption *connOpt)
1552 {
1553 TRANS_LOGI(TRANS_SVC, "set hml conn info.");
1554 connOpt->type = CONNECT_HML;
1555 if (strcpy_s(connOpt->socketOption.addr, sizeof(connOpt->socketOption.addr), p2pInfo->peerIp) != EOK) {
1556 TRANS_LOGE(TRANS_SVC, "set hml localIp err");
1557 return SOFTBUS_STRCPY_ERR;
1558 }
1559 connOpt->socketOption.protocol = LNN_PROTOCOL_IP;
1560 connOpt->socketOption.port = -1;
1561 return SOFTBUS_OK;
1562 }
1563
TransGetConnectOptByConnInfo(const LaneConnInfo * info,ConnectOption * connOpt)1564 int32_t TransGetConnectOptByConnInfo(const LaneConnInfo *info, ConnectOption *connOpt)
1565 {
1566 if (info == NULL || connOpt == NULL) {
1567 TRANS_LOGW(TRANS_SVC, "invalid param.");
1568 return SOFTBUS_INVALID_PARAM;
1569 }
1570 if (info->type == LANE_P2P) {
1571 return SetP2pConnInfo(&(info->connInfo.p2p), connOpt);
1572 } else if (info->type == LANE_WLAN_2P4G || info->type == LANE_WLAN_5G || info->type == LANE_ETH) {
1573 return SetWlanConnInfo(&(info->connInfo.wlan), connOpt);
1574 } else if (info->type == LANE_BR) {
1575 return SetBrConnInfo(&(info->connInfo.br), connOpt);
1576 } else if ((info->type == LANE_BLE) || (info->type == LANE_COC)) {
1577 return SetBleConnInfo(&(info->connInfo.ble), connOpt);
1578 } else if (info->type == LANE_P2P_REUSE) {
1579 return SetP2pReusesConnInfo(&(info->connInfo.wlan), connOpt);
1580 } else if (info->type == LANE_BLE_DIRECT || info->type == LANE_COC_DIRECT) {
1581 return SetBleDirectConnInfo(&(info->connInfo.bleDirect), connOpt);
1582 } else if (info->type == LANE_HML) {
1583 return SetHmlConnectInfo(&(info->connInfo.p2p), connOpt);
1584 }
1585
1586 TRANS_LOGE(TRANS_SVC, "get conn opt err: type=%{public}d", info->type);
1587 return SOFTBUS_TRANS_GET_CONN_OPT_FAILED;
1588 }
1589
TransGetAuthTypeByNetWorkId(const char * peerNetWorkId)1590 bool TransGetAuthTypeByNetWorkId(const char *peerNetWorkId)
1591 {
1592 int32_t value = 0;
1593 int32_t ret = LnnGetRemoteNumInfo(peerNetWorkId, NUM_KEY_META_NODE, &value);
1594 if (ret != SOFTBUS_OK) {
1595 TRANS_LOGE(TRANS_SVC, "GetAuthType fail, ret=%{public}d", ret);
1596 return false;
1597 }
1598 return ((uint32_t)value == (1 << ONLINE_METANODE)) ? true : false;
1599 }
1600
TransDeleteLaneReqItemByLaneHandle(uint32_t laneHandle,bool isAsync)1601 int32_t TransDeleteLaneReqItemByLaneHandle(uint32_t laneHandle, bool isAsync)
1602 {
1603 return TransDelLaneReqFromPendingList(laneHandle, isAsync);
1604 }
1605
TransCancelLaneItemCondByLaneHandle(uint32_t laneHandle,bool bSucc,bool isAsync,int32_t errCode)1606 int32_t TransCancelLaneItemCondByLaneHandle(uint32_t laneHandle, bool bSucc, bool isAsync, int32_t errCode)
1607 {
1608 SoftBusList *pendingList = isAsync ? g_asyncReqLanePendingList : g_reqLanePendingList;
1609 if (pendingList == NULL) {
1610 TRANS_LOGE(TRANS_SVC, "lane pending list no init.");
1611 return SOFTBUS_NO_INIT;
1612 }
1613 if (SoftBusMutexLock(&(pendingList->lock)) != SOFTBUS_OK) {
1614 TRANS_LOGE(TRANS_SVC, "lock failed.");
1615 return SOFTBUS_LOCK_ERR;
1616 }
1617
1618 TransReqLaneItem *item = NULL;
1619 LIST_FOR_EACH_ENTRY(item, &(pendingList->list), TransReqLaneItem, node) {
1620 if (item->laneHandle == laneHandle) {
1621 item->bSucc = bSucc;
1622 item->errCode = errCode;
1623 item->isFinished = true;
1624 if (!isAsync) {
1625 (void)SoftBusCondSignal(&item->cond);
1626 }
1627 (void)SoftBusMutexUnlock(&(pendingList->lock));
1628 return SOFTBUS_OK;
1629 }
1630 }
1631 (void)SoftBusMutexUnlock(&(pendingList->lock));
1632 TRANS_LOGE(TRANS_SVC, "trans lane request not found. laneHandle=%{public}u", laneHandle);
1633 return SOFTBUS_NOT_FIND;
1634 }
1635
TransAuthWithParaReqLanePendingInit(void)1636 int32_t TransAuthWithParaReqLanePendingInit(void)
1637 {
1638 g_authWithParaAsyncReqLaneList = CreateSoftBusList();
1639 if (g_authWithParaAsyncReqLaneList == NULL) {
1640 TRANS_LOGE(TRANS_INIT, "g_authWithParaAsyncReqLaneList is null.");
1641 return SOFTBUS_TRANS_LIST_INIT_FAILED;
1642 }
1643 return SOFTBUS_OK;
1644 }
1645
TransAuthWithParaReqLanePendingDeinit(void)1646 void TransAuthWithParaReqLanePendingDeinit(void)
1647 {
1648 TRANS_LOGI(TRANS_SVC, "enter.");
1649 TransAuthWithParaNode *item = NULL;
1650 TransAuthWithParaNode *next = NULL;
1651 if (g_authWithParaAsyncReqLaneList == NULL) {
1652 TRANS_LOGE(TRANS_INIT, "g_authWithParaAsyncReqLaneList is null.");
1653 return;
1654 }
1655
1656 if (SoftBusMutexLock(&g_authWithParaAsyncReqLaneList->lock) != SOFTBUS_OK) {
1657 TRANS_LOGE(TRANS_INIT, "lock failed.");
1658 return;
1659 }
1660
1661 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_authWithParaAsyncReqLaneList->list, TransAuthWithParaNode, node) {
1662 ListDelete(&item->node);
1663 SoftBusFree(item->sessionName);
1664 item->sessionName = NULL;
1665 SoftBusFree(item);
1666 item = NULL;
1667 }
1668 (void)SoftBusMutexUnlock(&g_authWithParaAsyncReqLaneList->lock);
1669 DestroySoftBusList(g_authWithParaAsyncReqLaneList);
1670 g_authWithParaAsyncReqLaneList = NULL;
1671 }
1672
FillTransAuthWithParaNode(TransAuthWithParaNode * item,uint32_t laneReqId,const char * sessionName,const LinkPara * linkPara,int32_t channelId)1673 static int32_t FillTransAuthWithParaNode(TransAuthWithParaNode *item, uint32_t laneReqId, const char *sessionName,
1674 const LinkPara *linkPara, int32_t channelId)
1675 {
1676 item->errCode = SOFTBUS_MALLOC_ERR;
1677 item->laneReqId = laneReqId;
1678 item->channelId = channelId;
1679 item->bSucc = false;
1680 item->isFinished = false;
1681 if (strcpy_s(item->sessionName, SESSION_NAME_SIZE_MAX, sessionName) != EOK) {
1682 TRANS_LOGE(TRANS_SVC, "TransAuthWithParaAddLaneReqToList: copy sessionName failed");
1683 return SOFTBUS_STRCPY_ERR;
1684 }
1685 if (memcpy_s(&(item->linkPara), sizeof(LinkPara), linkPara, sizeof(LinkPara)) != SOFTBUS_OK) {
1686 TRANS_LOGE(TRANS_SVC, "TransAuthWithParaAddLaneReqToList: copy linkPara failed");
1687 return SOFTBUS_MEM_ERR;
1688 }
1689 return SOFTBUS_OK;
1690 }
1691
TransAuthWithParaAddLaneReqToList(uint32_t laneReqId,const char * sessionName,const LinkPara * linkPara,int32_t channelId)1692 int32_t TransAuthWithParaAddLaneReqToList(uint32_t laneReqId, const char *sessionName,
1693 const LinkPara *linkPara, int32_t channelId)
1694 {
1695 int32_t errCode = SOFTBUS_TRANS_CHANNEL_OPEN_FAILED;
1696 if (g_authWithParaAsyncReqLaneList == NULL) {
1697 TRANS_LOGE(TRANS_SVC, "g_authWithParaAsyncReqLaneList no init.");
1698 return SOFTBUS_NO_INIT;
1699 }
1700
1701 if (sessionName == NULL || linkPara == NULL) {
1702 TRANS_LOGE(TRANS_SVC, "sessionName or linkPara is null.");
1703 return SOFTBUS_INVALID_PARAM;
1704 }
1705
1706 TransAuthWithParaNode *item = (TransAuthWithParaNode *)SoftBusCalloc(sizeof(TransAuthWithParaNode));
1707 TRANS_CHECK_AND_RETURN_RET_LOGE(
1708 item != NULL, SOFTBUS_MALLOC_ERR, TRANS_SVC, "SoftBusCalloc item failed");
1709
1710 item->sessionName = (char *)SoftBusCalloc(sizeof(char) * SESSION_NAME_SIZE_MAX);
1711 if (item->sessionName == NULL) {
1712 TRANS_LOGE(TRANS_SVC, "SoftBusCalloc item->sessionName failed.");
1713 SoftBusFree(item);
1714 return SOFTBUS_MALLOC_ERR;
1715 }
1716
1717 errCode = FillTransAuthWithParaNode(item, laneReqId, sessionName, linkPara, channelId);
1718 if (errCode != SOFTBUS_OK) {
1719 TRANS_LOGE(TRANS_SVC, "fill trans auth with para node failed. ret=%{public}d", errCode);
1720 goto ERR_EXIT;
1721 }
1722
1723 if (SoftBusMutexLock(&g_authWithParaAsyncReqLaneList->lock) != SOFTBUS_OK) {
1724 TRANS_LOGE(TRANS_SVC, "g_authWithParaAsyncReqLaneList lock failed.");
1725 errCode = SOFTBUS_LOCK_ERR;
1726 goto ERR_EXIT;
1727 }
1728 ListInit(&(item->node));
1729 ListAdd(&(g_authWithParaAsyncReqLaneList->list), &(item->node));
1730 g_authWithParaAsyncReqLaneList->cnt++;
1731 (void)SoftBusMutexUnlock(&g_authWithParaAsyncReqLaneList->lock);
1732 TRANS_LOGI(TRANS_SVC, "TransAuthWithParaAddLaneReqToList success laneReqId=%{public}u", laneReqId);
1733 return SOFTBUS_OK;
1734 ERR_EXIT:
1735 SoftBusFree(item->sessionName);
1736 item->sessionName = NULL;
1737 SoftBusFree(item);
1738 return errCode;
1739 }
1740
TransAuthWithParaDelLaneReqById(uint32_t laneReqId)1741 int32_t TransAuthWithParaDelLaneReqById(uint32_t laneReqId)
1742 {
1743 TRANS_LOGD(TRANS_SVC, "TransAuthWithParaDelLaneReqById laneReqId=%{public}u,", laneReqId);
1744 if (g_authWithParaAsyncReqLaneList == NULL) {
1745 TRANS_LOGE(TRANS_SVC, "TransAuthWithParaDelLaneReqById: g_authWithParaAsyncReqLaneList no init.");
1746 return SOFTBUS_NO_INIT;
1747 }
1748 if (SoftBusMutexLock(&(g_authWithParaAsyncReqLaneList->lock)) != SOFTBUS_OK) {
1749 TRANS_LOGE(TRANS_SVC, "g_authWithParaAsyncReqLaneList lock failed");
1750 return SOFTBUS_LOCK_ERR;
1751 }
1752
1753 TransAuthWithParaNode *laneItem = NULL;
1754 TransAuthWithParaNode *next = NULL;
1755 LIST_FOR_EACH_ENTRY_SAFE(laneItem, next, &(g_authWithParaAsyncReqLaneList->list), TransAuthWithParaNode, node) {
1756 if (laneItem->laneReqId == laneReqId) {
1757 TRANS_LOGI(TRANS_SVC, "delete laneReqId = %{public}u", laneItem->laneReqId);
1758 ListDelete(&(laneItem->node));
1759 g_authWithParaAsyncReqLaneList->cnt--;
1760 SoftBusFree(laneItem->sessionName);
1761 laneItem->sessionName = NULL;
1762 SoftBusFree(laneItem);
1763 laneItem = NULL;
1764 (void)SoftBusMutexUnlock(&(g_authWithParaAsyncReqLaneList->lock));
1765 return SOFTBUS_OK;
1766 }
1767 }
1768 (void)SoftBusMutexUnlock(&(g_authWithParaAsyncReqLaneList->lock));
1769 TRANS_LOGE(TRANS_SVC, "TransAuthWithParaDelLaneReqById not found, laneReqId=%{public}u", laneReqId);
1770 return SOFTBUS_TRANS_AUTH_CHANNEL_NOT_FOUND;
1771 }
1772
TransUpdateAuthWithParaLaneConnInfo(uint32_t laneHandle,bool bSucc,const LaneConnInfo * connInfo,int32_t errCode)1773 int32_t TransUpdateAuthWithParaLaneConnInfo(uint32_t laneHandle, bool bSucc, const LaneConnInfo *connInfo,
1774 int32_t errCode)
1775 {
1776 if (g_authWithParaAsyncReqLaneList == NULL) {
1777 TRANS_LOGE(TRANS_SVC, "lane pending list no init.");
1778 return SOFTBUS_INVALID_PARAM;
1779 }
1780 if (SoftBusMutexLock(&(g_authWithParaAsyncReqLaneList->lock)) != SOFTBUS_OK) {
1781 TRANS_LOGE(TRANS_SVC, "lock failed.");
1782 return SOFTBUS_LOCK_ERR;
1783 }
1784
1785 TransAuthWithParaNode *item = NULL;
1786 LIST_FOR_EACH_ENTRY(item, &(g_authWithParaAsyncReqLaneList->list), TransAuthWithParaNode, node) {
1787 if (item->laneReqId == laneHandle) {
1788 item->bSucc = bSucc;
1789 item->errCode = errCode;
1790 if ((connInfo != NULL) &&
1791 (memcpy_s(&(item->connInfo), sizeof(LaneConnInfo), connInfo, sizeof(LaneConnInfo)) != EOK)) {
1792 (void)SoftBusMutexUnlock(&(g_authWithParaAsyncReqLaneList->lock));
1793 return SOFTBUS_MEM_ERR;
1794 }
1795 item->isFinished = true;
1796 (void)SoftBusMutexUnlock(&(g_authWithParaAsyncReqLaneList->lock));
1797 return SOFTBUS_OK;
1798 }
1799 }
1800 (void)SoftBusMutexUnlock(&(g_authWithParaAsyncReqLaneList->lock));
1801 TRANS_LOGE(TRANS_SVC, "trans lane request not found. laneHandle=%{public}u", laneHandle);
1802 return SOFTBUS_TRANS_NODE_NOT_FOUND;
1803 }
1804
TransAuthWithParaGetLaneReqByLaneReqId(uint32_t laneReqId,TransAuthWithParaNode * paraNode)1805 int32_t TransAuthWithParaGetLaneReqByLaneReqId(uint32_t laneReqId, TransAuthWithParaNode *paraNode)
1806 {
1807 if (paraNode == NULL) {
1808 TRANS_LOGE(TRANS_CTRL, "TransAuthWithParaGetLaneReqByLaneReqId: invalid paraNode");
1809 return SOFTBUS_INVALID_PARAM;
1810 }
1811 if (g_authWithParaAsyncReqLaneList == NULL) {
1812 TRANS_LOGE(TRANS_SVC, "g_authWithParaAsyncReqLaneList hasn't init.");
1813 return SOFTBUS_NO_INIT;
1814 }
1815 if (SoftBusMutexLock(&(g_authWithParaAsyncReqLaneList->lock)) != SOFTBUS_OK) {
1816 TRANS_LOGE(TRANS_SVC, "g_authWithParaAsyncReqLaneList lock failed.");
1817 return SOFTBUS_LOCK_ERR;
1818 }
1819
1820 TransAuthWithParaNode *item = NULL;
1821 LIST_FOR_EACH_ENTRY(item, &(g_authWithParaAsyncReqLaneList->list), TransAuthWithParaNode, node) {
1822 if (item->laneReqId == laneReqId) {
1823 if (memcpy_s(paraNode, sizeof(TransAuthWithParaNode), item, sizeof(TransAuthWithParaNode)) != EOK) {
1824 (void)SoftBusMutexUnlock(&(g_authWithParaAsyncReqLaneList->lock));
1825 TRANS_LOGE(TRANS_SVC, "copy paraNode failed.");
1826 return SOFTBUS_MEM_ERR;
1827 }
1828 (void)SoftBusMutexUnlock(&(g_authWithParaAsyncReqLaneList->lock));
1829 return SOFTBUS_OK;
1830 }
1831 }
1832 (void)SoftBusMutexUnlock(&(g_authWithParaAsyncReqLaneList->lock));
1833 TRANS_LOGE(TRANS_SVC, "TransAuthWithParaGetLaneReqByLaneReqId not found. laneReqId=%{public}u", laneReqId);
1834 return SOFTBUS_TRANS_AUTH_CHANNEL_NOT_FOUND;
1835 }
1836
CheckLaneHandleIsExited(uint32_t laneHandle)1837 static bool CheckLaneHandleIsExited(uint32_t laneHandle)
1838 {
1839 if (g_freeLanePendingList == NULL) {
1840 TRANS_LOGE(TRANS_INIT, "g_freeLanePendingList is NULL.");
1841 return false;
1842 }
1843
1844 if (SoftBusMutexLock(&g_freeLanePendingList->lock) != SOFTBUS_OK) {
1845 TRANS_LOGE(TRANS_SVC, "lock failed.");
1846 return false;
1847 }
1848
1849 TransFreeLaneItem *freeItem = NULL;
1850 LIST_FOR_EACH_ENTRY(freeItem, &g_freeLanePendingList->list, TransFreeLaneItem, node) {
1851 if (freeItem->laneHandle == laneHandle) {
1852 (void)SoftBusMutexUnlock(&g_freeLanePendingList->lock);
1853 return true;
1854 }
1855 }
1856 (void)SoftBusMutexUnlock(&g_freeLanePendingList->lock);
1857 return false;
1858 }
1859
TransAddFreeLaneToPending(uint32_t laneHandle)1860 static int32_t TransAddFreeLaneToPending(uint32_t laneHandle)
1861 {
1862 TRANS_CHECK_AND_RETURN_RET_LOGE(g_freeLanePendingList != NULL,
1863 SOFTBUS_NO_INIT, TRANS_INIT, "lane pending list no init.");
1864
1865 TransFreeLaneItem *freeItem = (TransFreeLaneItem *)SoftBusCalloc(sizeof(TransFreeLaneItem));
1866 TRANS_CHECK_AND_RETURN_RET_LOGE(freeItem != NULL,
1867 SOFTBUS_MALLOC_ERR, TRANS_SVC, "malloc lane free item err.");
1868
1869 if (CheckLaneHandleIsExited(laneHandle)) {
1870 SoftBusFree(freeItem);
1871 return SOFTBUS_TRANS_LANE_IS_EXISTED;
1872 }
1873
1874 freeItem->errCode = SOFTBUS_OK;
1875 freeItem->laneHandle = laneHandle;
1876 freeItem->isSucc = false;
1877 freeItem->isFinished = false;
1878
1879 if (SoftBusCondInit(&freeItem->condVar) != SOFTBUS_OK) {
1880 SoftBusFree(freeItem);
1881 TRANS_LOGE(TRANS_SVC, "cond var init failed.");
1882 return SOFTBUS_TRANS_INIT_FAILED;
1883 }
1884 if (SoftBusMutexLock(&g_freeLanePendingList->lock) != SOFTBUS_OK) {
1885 (void)SoftBusCondDestroy(&freeItem->condVar);
1886 SoftBusFree(freeItem);
1887 TRANS_LOGE(TRANS_SVC, "lock failed.");
1888 return SOFTBUS_LOCK_ERR;
1889 }
1890 ListInit(&(freeItem->node));
1891 ListAdd(&(g_freeLanePendingList->list), &(freeItem->node));
1892 g_freeLanePendingList->cnt++;
1893 (void)SoftBusMutexUnlock(&g_freeLanePendingList->lock);
1894
1895 TRANS_LOGI(TRANS_SVC, "add tran free lane to pending laneHandle=%{public}u", laneHandle);
1896 return SOFTBUS_OK;
1897 }
1898
TransWaitingFreeCallback(uint32_t laneHandle)1899 static int32_t TransWaitingFreeCallback(uint32_t laneHandle)
1900 {
1901 TRANS_CHECK_AND_RETURN_RET_LOGE(g_freeLanePendingList != NULL,
1902 SOFTBUS_NO_INIT, TRANS_INIT, "free lane pending list no init.");
1903 TRANS_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_freeLanePendingList->lock) == SOFTBUS_OK,
1904 SOFTBUS_LOCK_ERR, TRANS_SVC, "lock failed.");
1905
1906 bool isFound = false;
1907 TransFreeLaneItem *freeItem = NULL;
1908 LIST_FOR_EACH_ENTRY(freeItem, &(g_freeLanePendingList->list), TransFreeLaneItem, node) {
1909 if (freeItem->laneHandle == laneHandle) {
1910 isFound = true;
1911 break;
1912 }
1913 }
1914 if (!isFound) {
1915 (void)SoftBusMutexUnlock(&(g_freeLanePendingList->lock));
1916 TRANS_LOGI(TRANS_SVC, "not found laneHandle in free pending. laneHandle=%{public}u", laneHandle);
1917 return SOFTBUS_NOT_FIND;
1918 }
1919 if (freeItem->isFinished == false) {
1920 int32_t rc = TransSoftBusCondWait(&freeItem->condVar, &g_freeLanePendingList->lock, TRANS_FREE_LANE_TIMEOUT);
1921 if (rc != SOFTBUS_OK) {
1922 (void)SoftBusMutexUnlock(&(g_freeLanePendingList->lock));
1923 TRANS_LOGE(TRANS_SVC, "wait cond var failed laneHandle=%{public}u", laneHandle);
1924 return rc;
1925 }
1926 }
1927 (void)SoftBusMutexUnlock(&(g_freeLanePendingList->lock));
1928 TRANS_LOGI(TRANS_SVC, "wait free lane succ laneHandle=%{public}u", laneHandle);
1929 return SOFTBUS_OK;
1930 }
1931
TransDelLaneFreeFromPending(uint32_t laneHandle,bool isAsync)1932 static int32_t TransDelLaneFreeFromPending(uint32_t laneHandle, bool isAsync)
1933 {
1934 TRANS_LOGD(TRANS_SVC, "del tran free from pending laneHandle=%{public}u, isAsync=%{public}d",
1935 laneHandle, isAsync);
1936 SoftBusList *pendingList = g_freeLanePendingList;
1937 TRANS_CHECK_AND_RETURN_RET_LOGE(pendingList != NULL,
1938 SOFTBUS_NO_INIT, TRANS_SVC, "free lane pending list no init.");
1939 TRANS_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(pendingList->lock)) == SOFTBUS_OK,
1940 SOFTBUS_LOCK_ERR, TRANS_SVC, "lock failed.");
1941
1942 TransFreeLaneItem *laneItem = NULL;
1943 TransFreeLaneItem *next = NULL;
1944 LIST_FOR_EACH_ENTRY_SAFE(laneItem, next, &(pendingList->list), TransFreeLaneItem, node) {
1945 if (laneItem->laneHandle == laneHandle) {
1946 if (!isAsync) {
1947 (void)SoftBusCondDestroy(&laneItem->condVar);
1948 }
1949 ListDelete(&(laneItem->node));
1950 TRANS_LOGI(TRANS_SVC, "delete free lane laneHandle = %{public}u", laneItem->laneHandle);
1951 pendingList->cnt--;
1952 SoftBusFree(laneItem);
1953 (void)SoftBusMutexUnlock(&(pendingList->lock));
1954 return SOFTBUS_OK;
1955 }
1956 }
1957 (void)SoftBusMutexUnlock(&(pendingList->lock));
1958 TRANS_LOGE(TRANS_SVC, "trans free lane not found, laneHandle=%{public}u", laneHandle);
1959 return SOFTBUS_TRANS_NODE_NOT_FOUND;
1960 }
1961
TransWaitingFreeLane(uint32_t laneHandle)1962 static int32_t TransWaitingFreeLane(uint32_t laneHandle)
1963 {
1964 int32_t ret = TransAddFreeLaneToPending(laneHandle);
1965 if (ret != SOFTBUS_OK) {
1966 TRANS_LOGE(TRANS_SVC, "add free lane to pending failed. laneHandle=%{public}u, ret=%{public}d",
1967 laneHandle, ret);
1968 return ret;
1969 }
1970
1971 TRANS_CHECK_AND_RETURN_RET_LOGE(GetLaneManager() != NULL,
1972 SOFTBUS_TRANS_GET_LANE_INFO_ERR, TRANS_CTRL, "GetLaneManager is null");
1973 TRANS_CHECK_AND_RETURN_RET_LOGE(GetLaneManager()->lnnFreeLane != NULL,
1974 SOFTBUS_TRANS_GET_LANE_INFO_ERR, TRANS_CTRL, "lnnFreeLane is null");
1975 ret = GetLaneManager()->lnnFreeLane(laneHandle);
1976 if (ret != SOFTBUS_OK) {
1977 TRANS_LOGE(TRANS_SVC, "trans free lane failed. ret=%{public}d", ret);
1978 (void)TransDelLaneFreeFromPending(laneHandle, false);
1979 return ret;
1980 }
1981 TRANS_LOGI(TRANS_SVC, "free lane start waiting. laneHandle=%{public}u", laneHandle);
1982 ret = TransWaitingFreeCallback(laneHandle);
1983 (void)TransDelLaneFreeFromPending(laneHandle, false);
1984 return ret;
1985 }
1986
TransFreeLaneByLaneHandle(uint32_t laneHandle,bool isAsync)1987 int32_t TransFreeLaneByLaneHandle(uint32_t laneHandle, bool isAsync)
1988 {
1989 int32_t ret = SOFTBUS_OK;
1990 if (isAsync) {
1991 TRANS_CHECK_AND_RETURN_RET_LOGE(GetLaneManager() != NULL,
1992 SOFTBUS_TRANS_GET_LANE_INFO_ERR, TRANS_CTRL, "GetLaneManager is null");
1993 TRANS_CHECK_AND_RETURN_RET_LOGE(GetLaneManager()->lnnFreeLane != NULL,
1994 SOFTBUS_TRANS_GET_LANE_INFO_ERR, TRANS_CTRL, "lnnFreeLane is null");
1995 ret = GetLaneManager()->lnnFreeLane(laneHandle);
1996 } else {
1997 ret = TransWaitingFreeLane(laneHandle);
1998 }
1999 return ret;
2000 }