1 /*
2  * Copyright (c) 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 "client_trans_socket_manager.h"
17 
18 #include <securec.h>
19 
20 #include "anonymizer.h"
21 #include "client_bus_center_manager.h"
22 #include "client_trans_channel_manager.h"
23 #include "client_trans_file_listener.h"
24 #include "client_trans_proxy_file_manager.h"
25 #include "client_trans_tcp_direct_manager.h"
26 #include "client_trans_udp_manager.h"
27 #include "softbus_adapter_mem.h"
28 #include "softbus_app_info.h"
29 #include "softbus_def.h"
30 #include "softbus_errcode.h"
31 #include "softbus_socket.h"
32 #include "softbus_utils.h"
33 #include "trans_log.h"
34 #include "trans_server_proxy.h"
35 
36 #define NETWORK_ID_LEN 7
37 #define GET_ROUTE_TYPE(type) ((uint32_t)(type) & 0xff)
38 #define GET_CONN_TYPE(type) (((uint32_t)(type) >> 8) & 0xff)
39 
40 #define DISTRIBUTED_DATA_SESSION "distributeddata-default"
41 
IsValidSessionParam(const SessionParam * param)42 bool IsValidSessionParam(const SessionParam *param)
43 {
44     if ((param == NULL) ||
45         (param->sessionName == NULL) ||
46         (param->peerSessionName == NULL) ||
47         (param->peerDeviceId == NULL) ||
48         (param->groupId == NULL) ||
49         (param->attr == NULL)) {
50         return false;
51     }
52     return true;
53 }
54 
CreateNewSession(const SessionParam * param)55 SessionInfo *CreateNewSession(const SessionParam *param)
56 {
57     if (param == NULL) {
58         TRANS_LOGE(TRANS_SDK, "param is null");
59         return NULL;
60     }
61     SessionInfo *session = (SessionInfo*)SoftBusCalloc(sizeof(SessionInfo));
62     if (session == NULL) {
63         TRANS_LOGE(TRANS_SDK, "calloc failed");
64         return NULL;
65     }
66 
67     if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName) != EOK ||
68         strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId) != EOK ||
69         strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId) != EOK ||
70         memcpy_s(session->linkType, sizeof(param->attr->linkType), param->attr->linkType,
71             sizeof(param->attr->linkType)) != EOK) {
72         TRANS_LOGE(TRANS_SDK, "strcpy failed");
73         SoftBusFree(session);
74         return NULL;
75     }
76 
77     session->sessionId = INVALID_SESSION_ID;
78     session->channelId = INVALID_CHANNEL_ID;
79     session->channelType = CHANNEL_TYPE_BUTT;
80     session->isServer = false;
81     session->role = SESSION_ROLE_INIT;
82     session->enableStatus = ENABLE_STATUS_INIT;
83     session->info.flag = param->attr->dataType;
84     session->isEncrypt = true;
85     session->isAsync = false;
86     session->lifecycle.sessionState = SESSION_STATE_INIT;
87     session->actionId = param->actionId;
88     return session;
89 }
90 
CreateDestroySessionNode(SessionInfo * sessionNode,const ClientSessionServer * server)91 NO_SANITIZE("cfi") DestroySessionInfo *CreateDestroySessionNode(SessionInfo *sessionNode,
92     const ClientSessionServer *server)
93 {
94     if (sessionNode == NULL || server == NULL) {
95         TRANS_LOGE(TRANS_SDK, "invalid param.");
96         return NULL;
97     }
98     DestroySessionInfo *destroyNode = (DestroySessionInfo *)SoftBusCalloc(sizeof(DestroySessionInfo));
99     if (destroyNode == NULL) {
100         TRANS_LOGE(TRANS_SDK, "destroyList malloc fail.");
101         return NULL;
102     }
103     destroyNode->sessionId = sessionNode->sessionId;
104     destroyNode->channelId = sessionNode->channelId;
105     destroyNode->channelType = sessionNode->channelType;
106     destroyNode->isAsync = sessionNode->isAsync;
107     if (!sessionNode->lifecycle.condIsWaiting) {
108         (void)SoftBusCondDestroy(&(sessionNode->lifecycle.callbackCond));
109     } else {
110         (void)SoftBusCondSignal(&(sessionNode->lifecycle.callbackCond)); // destroy in CheckSessionEnableStatus
111         TRANS_LOGI(TRANS_SDK, "sessionId=%{public}d condition is waiting", sessionNode->sessionId);
112     }
113     if (memcpy_s(destroyNode->sessionName, SESSION_NAME_SIZE_MAX, server->sessionName, SESSION_NAME_SIZE_MAX) != EOK) {
114         TRANS_LOGE(TRANS_SDK, "memcpy_s sessionName fail.");
115         SoftBusFree(destroyNode);
116         return NULL;
117     }
118     if (memcpy_s(destroyNode->pkgName, PKG_NAME_SIZE_MAX, server->pkgName, PKG_NAME_SIZE_MAX) != EOK) {
119         TRANS_LOGE(TRANS_SDK, "memcpy_s pkgName fail.");
120         SoftBusFree(destroyNode);
121         return NULL;
122     }
123     destroyNode->OnSessionClosed = server->listener.session.OnSessionClosed;
124     destroyNode->OnShutdown = sessionNode->isServer ? server->listener.socketServer.OnShutdown :
125         server->listener.socketClient.OnShutdown;
126     return destroyNode;
127 }
128 
ClientDestroySession(const ListNode * destroyList,ShutdownReason reason)129 NO_SANITIZE("cfi") void ClientDestroySession(const ListNode *destroyList, ShutdownReason reason)
130 {
131     if (destroyList == NULL) {
132         TRANS_LOGE(TRANS_SDK, "invalid param.");
133         return;
134     }
135     if (IsListEmpty(destroyList)) {
136         TRANS_LOGD(TRANS_SDK, "destroyList is empty fail.");
137         return;
138     }
139     DestroySessionInfo *destroyNode = NULL;
140     DestroySessionInfo *destroyNodeNext = NULL;
141     TRANS_LOGD(TRANS_SDK, "enter.");
142     LIST_FOR_EACH_ENTRY_SAFE(destroyNode, destroyNodeNext, destroyList, DestroySessionInfo, node) {
143         int32_t id = destroyNode->sessionId;
144         (void)ClientDeleteRecvFileList(id);
145         (void)ClientTransCloseChannel(destroyNode->channelId, destroyNode->channelType);
146         if (destroyNode->OnSessionClosed != NULL) {
147             destroyNode->OnSessionClosed(id);
148         } else if (destroyNode->OnShutdown != NULL) {
149             destroyNode->OnShutdown(id, reason);
150             (void)TryDeleteEmptySessionServer(destroyNode->pkgName, destroyNode->sessionName);
151         }
152         if ((!destroyNode->isAsync) && destroyNode->lifecycle.sessionState == SESSION_STATE_CANCELLING) {
153             (void)SoftBusCondSignal(&(destroyNode->lifecycle.callbackCond));
154         }
155         ListDelete(&(destroyNode->node));
156         SoftBusFree(destroyNode);
157     }
158     TRANS_LOGD(TRANS_SDK, "ok");
159 }
160 
DestroyClientSessionServer(ClientSessionServer * server,ListNode * destroyList)161 void DestroyClientSessionServer(ClientSessionServer *server, ListNode *destroyList)
162 {
163     if (server == NULL || destroyList == NULL) {
164         TRANS_LOGW(TRANS_SDK, "invalid param");
165         return;
166     }
167 
168     if (!IsListEmpty(&(server->sessionList))) {
169         SessionInfo *sessionNode = NULL;
170         SessionInfo *sessionNodeNext = NULL;
171         LIST_FOR_EACH_ENTRY_SAFE(sessionNode, sessionNodeNext, &(server->sessionList), SessionInfo, node) {
172             DestroySessionInfo *destroyNode = CreateDestroySessionNode(sessionNode, server);
173             if (destroyNode == NULL) {
174                 continue;
175             }
176             DestroySessionId();
177             ListDelete(&sessionNode->node);
178             ListAdd(destroyList, &(destroyNode->node));
179             SoftBusFree(sessionNode);
180         }
181     }
182 
183     ListDelete(&(server->node));
184     char *tmpName = NULL;
185     Anonymize(server->sessionName, &tmpName);
186     TRANS_LOGI(TRANS_SDK, "destroy session server sessionName=%{public}s", tmpName);
187     AnonymizeFree(tmpName);
188     SoftBusFree(server);
189 }
190 
GetNewSessionServer(SoftBusSecType type,const char * sessionName,const char * pkgName,const ISessionListener * listener)191 ClientSessionServer *GetNewSessionServer(SoftBusSecType type, const char *sessionName,
192     const char *pkgName, const ISessionListener *listener)
193 {
194     if (sessionName == NULL || pkgName == NULL || listener == NULL) {
195         TRANS_LOGW(TRANS_SDK, "invalid param");
196         return NULL;
197     }
198     ClientSessionServer *server = (ClientSessionServer *)SoftBusCalloc(sizeof(ClientSessionServer));
199     if (server == NULL) {
200         return NULL;
201     }
202     server->type = type;
203     if (strcpy_s(server->pkgName, sizeof(server->pkgName), pkgName) != EOK) {
204         goto EXIT_ERR;
205     }
206     if (strcpy_s(server->sessionName, sizeof(server->sessionName), sessionName) != EOK) {
207         goto EXIT_ERR;
208     }
209     if (memcpy_s(&server->listener.session, sizeof(ISessionListener), listener, sizeof(ISessionListener)) != EOK) {
210         goto EXIT_ERR;
211     }
212     server->listener.isSocketListener = false;
213     server->isSrvEncryptedRawStream = false;
214 
215     ListInit(&server->node);
216     ListInit(&server->sessionList);
217     return server;
218 
219 EXIT_ERR:
220     if (server != NULL) {
221         SoftBusFree(server);
222     }
223     return NULL;
224 }
225 
CreateNonEncryptSessionInfo(const char * sessionName)226 SessionInfo *CreateNonEncryptSessionInfo(const char *sessionName)
227 {
228     if (sessionName == NULL) {
229         TRANS_LOGW(TRANS_SDK, "Invalid param");
230         return NULL;
231     }
232     if (!IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1)) {
233         TRANS_LOGW(TRANS_SDK, "Invalid param");
234         return NULL;
235     }
236     SessionInfo *session = (SessionInfo *)SoftBusCalloc(sizeof(SessionInfo));
237     if (session == NULL) {
238         return NULL;
239     }
240     session->channelType = CHANNEL_TYPE_AUTH;
241     session->isEncrypt = false;
242     session->actionId = INVALID_ACTION_ID;
243     if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, sessionName) != EOK) {
244         SoftBusFree(session);
245         return NULL;
246     }
247     return session;
248 }
249 
ClientTransGetTdcIp(int32_t channelId,char * myIp,int32_t ipLen)250 static int32_t ClientTransGetTdcIp(int32_t channelId, char *myIp, int32_t ipLen)
251 {
252     TcpDirectChannelInfo channel;
253     if (TransTdcGetInfoById(channelId, &channel) == NULL) {
254         TRANS_LOGE(TRANS_SDK, "not found Tdc channel by channelId=%{public}d", channelId);
255         return SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND;
256     }
257 
258     if (strcpy_s(myIp, ipLen, channel.detail.myIp) != EOK) {
259         TRANS_LOGE(TRANS_SDK, "strcpy_s ip failed, len=%{public}zu", strlen(channel.detail.myIp));
260         return SOFTBUS_STRCPY_ERR;
261     }
262 
263     return SOFTBUS_OK;
264 }
265 
ClientTransGetUdpIp(int32_t channelId,char * myIp,int32_t ipLen)266 static int32_t ClientTransGetUdpIp(int32_t channelId, char *myIp, int32_t ipLen)
267 {
268     UdpChannel channel;
269     if (TransGetUdpChannel(channelId, &channel) != SOFTBUS_OK) {
270         TRANS_LOGE(TRANS_SDK, "not found Udp channel by channelId=%{public}d", channelId);
271         return SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND;
272     }
273 
274     if (strcpy_s(myIp, ipLen, channel.info.myIp) != EOK) {
275         TRANS_LOGE(TRANS_SDK, "strcpy_s ip failed, len=%{public}zu", strlen(channel.info.myIp));
276         return SOFTBUS_STRCPY_ERR;
277     }
278 
279     return SOFTBUS_OK;
280 }
281 
282 // determine connection type based on IP
ClientTransCheckHmlIp(const char * ip)283 static bool ClientTransCheckHmlIp(const char *ip)
284 {
285     if (IsHmlIpAddr(ip)) {
286         return true;
287     }
288 
289     return false;
290 }
291 
292 // determine connection type based on IP, delete session when connection type and parameter connType are consistent
ClientTransCheckNeedDel(SessionInfo * sessionNode,int32_t routeType,int32_t connType)293 static bool ClientTransCheckNeedDel(SessionInfo *sessionNode, int32_t routeType, int32_t connType)
294 {
295     if (connType == TRANS_CONN_ALL) {
296         if (routeType != ROUTE_TYPE_ALL && sessionNode->routeType != routeType) {
297             return false;
298         }
299         return true;
300     }
301     /*
302     * only when the function OnWifiDirectDeviceOffLine is called can reach this else branch,
303     * and routeType is WIFI_P2P, the connType is hml or p2p
304     */
305     if (sessionNode->routeType != routeType) {
306         return false;
307     }
308 
309     char myIp[IP_LEN] = {0};
310     if (sessionNode->channelType == CHANNEL_TYPE_UDP) {
311         if (ClientTransGetUdpIp(sessionNode->channelId, myIp, sizeof(myIp)) != SOFTBUS_OK) {
312             return false;
313         }
314     } else if (sessionNode->channelType == CHANNEL_TYPE_TCP_DIRECT) {
315         if (ClientTransGetTdcIp(sessionNode->channelId, myIp, sizeof(myIp)) != SOFTBUS_OK) {
316             return false;
317         }
318     } else if (sessionNode->channelType == CHANNEL_TYPE_AUTH) {
319         TRANS_LOGI(TRANS_SDK, "check channelType=%{public}d", sessionNode->channelType);
320         return true;
321     } else {
322         TRANS_LOGW(TRANS_SDK, "check channelType=%{public}d", sessionNode->channelType);
323         return false;
324     }
325 
326     bool isHml = ClientTransCheckHmlIp(myIp);
327     if (connType == TRANS_CONN_HML && isHml) {
328         return true;
329     } else if (connType == TRANS_CONN_P2P && !isHml) {
330         return true;
331     }
332 
333     return false;
334 }
335 
DestroyClientSessionByNetworkId(const ClientSessionServer * server,const char * networkId,int32_t type,ListNode * destroyList)336 void DestroyClientSessionByNetworkId(const ClientSessionServer *server,
337     const char *networkId, int32_t type, ListNode *destroyList)
338 {
339     if (server == NULL || networkId == NULL || destroyList == NULL) {
340         TRANS_LOGE(TRANS_SDK, "invalid param.");
341         return;
342     }
343     SessionInfo *sessionNode = NULL;
344     SessionInfo *sessionNodeNext = NULL;
345     // connType is set only in function OnWifiDirectDeviceOffLine, others is TRANS_CONN_ALL, and routeType is WIFI_P2P
346     int32_t routeType = (int32_t)GET_ROUTE_TYPE(type);
347     int32_t connType = (int32_t)GET_CONN_TYPE(type);
348 
349     LIST_FOR_EACH_ENTRY_SAFE(sessionNode, sessionNodeNext, &(server->sessionList), SessionInfo, node) {
350         if (strcmp(sessionNode->info.peerDeviceId, networkId) != 0) {
351             continue;
352         }
353 
354         if (!ClientTransCheckNeedDel(sessionNode, routeType, connType)) {
355             continue;
356         }
357 
358         TRANS_LOGI(TRANS_SDK, "channelId=%{public}d, channelType=%{public}d, routeType=%{public}d, type=%{public}d",
359             sessionNode->channelId, sessionNode->channelType, sessionNode->routeType, type);
360         DestroySessionInfo *destroyNode = CreateDestroySessionNode(sessionNode, server);
361         if (destroyNode == NULL) {
362             continue;
363         }
364         /*
365          * When the channel type is UDP and the business type is file, trigger DFILE_ON_CLEAR_POLICY_FILE_LIST event
366          * before cleaning up sessionNode.
367          */
368         if (sessionNode->channelType == CHANNEL_TYPE_UDP && sessionNode->businessType == BUSINESS_TYPE_FILE) {
369             ClientEmitFileEvent(sessionNode->channelId);
370         }
371         DestroySessionId();
372         ListDelete(&sessionNode->node);
373         ListAdd(destroyList, &(destroyNode->node));
374         SoftBusFree(sessionNode);
375     }
376 }
377 
CreateSessionServerInfoNode(const ClientSessionServer * clientSessionServer)378 SessionServerInfo *CreateSessionServerInfoNode(const ClientSessionServer *clientSessionServer)
379 {
380     if (clientSessionServer == NULL) {
381         TRANS_LOGE(TRANS_SDK, "invalid param.");
382         return NULL;
383     }
384 
385     SessionServerInfo *infoNode = (SessionServerInfo *)SoftBusCalloc(sizeof(SessionServerInfo));
386     if (infoNode == NULL) {
387         TRANS_LOGE(TRANS_SDK, "failed to malloc SessionServerInfo.");
388         return NULL;
389     }
390 
391     if (strcpy_s(infoNode->pkgName, SESSION_NAME_SIZE_MAX, clientSessionServer->pkgName) != EOK) {
392         SoftBusFree(infoNode);
393         TRANS_LOGE(TRANS_SDK, "failed to strcpy pkgName.");
394         return NULL;
395     }
396 
397     if (strcpy_s(infoNode->sessionName, SESSION_NAME_SIZE_MAX, clientSessionServer->sessionName) != EOK) {
398         SoftBusFree(infoNode);
399         TRANS_LOGE(TRANS_SDK, "failed to strcpy sessionName.");
400         return NULL;
401     }
402 
403     return infoNode;
404 }
405 
GetNewSocketServer(SoftBusSecType type,const char * sessionName,const char * pkgName)406 ClientSessionServer *GetNewSocketServer(SoftBusSecType type, const char *sessionName, const char *pkgName)
407 {
408     if (sessionName == NULL || pkgName == NULL) {
409         TRANS_LOGE(TRANS_SDK, "invalid param.");
410         return NULL;
411     }
412     ClientSessionServer *server = (ClientSessionServer *)SoftBusCalloc(sizeof(ClientSessionServer));
413     if (server == NULL) {
414         return NULL;
415     }
416     server->type = type;
417     if (strcpy_s(server->pkgName, sizeof(server->pkgName), pkgName) != EOK) {
418         goto EXIT_ERR;
419     }
420     if (strcpy_s(server->sessionName, sizeof(server->sessionName), sessionName) != EOK) {
421         goto EXIT_ERR;
422     }
423     server->sessionAddingCnt++;
424     server->isSrvEncryptedRawStream = false;
425     ListInit(&server->node);
426     ListInit(&server->sessionList);
427     return server;
428 
429 EXIT_ERR:
430     if (server != NULL) {
431         SoftBusFree(server);
432     }
433     return NULL;
434 }
435 
IsDistributedDataSession(const char * sessionName)436 bool IsDistributedDataSession(const char *sessionName)
437 {
438     if (sessionName == NULL) {
439         TRANS_LOGE(TRANS_SDK, "invalid param.");
440         return false;
441     }
442     uint32_t distributedDataSessionLen = strlen(DISTRIBUTED_DATA_SESSION);
443     if (strlen(sessionName) < distributedDataSessionLen ||
444         strncmp(sessionName, DISTRIBUTED_DATA_SESSION, distributedDataSessionLen) != 0) {
445         return false;
446     }
447     return true;
448 }
449 
IsDifferentDataType(const SessionInfo * sessionInfo,int dataType,bool isEncyptedRawStream)450 bool IsDifferentDataType(const SessionInfo *sessionInfo, int dataType, bool isEncyptedRawStream)
451 {
452     if (sessionInfo == NULL) {
453         TRANS_LOGE(TRANS_SDK, "invalid param.");
454         return false;
455     }
456     if (sessionInfo->info.flag != dataType) {
457         return true;
458     }
459 
460     if (dataType != RAW_STREAM) {
461         return false;
462     }
463 
464     return sessionInfo->isEncyptedRawStream != isEncyptedRawStream;
465 }
466 
ClientInitSession(SessionInfo * session,const SessionParam * param)467 static void ClientInitSession(SessionInfo *session, const SessionParam *param)
468 {
469     session->sessionId = INVALID_SESSION_ID;
470     session->channelId = INVALID_CHANNEL_ID;
471     session->channelType = CHANNEL_TYPE_BUTT;
472     session->isServer = false;
473     session->role = SESSION_ROLE_INIT;
474     session->enableStatus = ENABLE_STATUS_INIT;
475     session->info.flag = param->attr->dataType;
476     session->info.streamType = param->attr->attr.streamAttr.streamType;
477     session->isEncrypt = true;
478     session->isAsync = false;
479     session->lifecycle.sessionState = SESSION_STATE_INIT;
480     session->lifecycle.condIsWaiting = false;
481     session->actionId = param->actionId;
482 }
483 
CreateNewSocketSession(const SessionParam * param)484 SessionInfo *CreateNewSocketSession(const SessionParam *param)
485 {
486     if (param == NULL) {
487         TRANS_LOGE(TRANS_SDK, "invalid param.");
488         return NULL;
489     }
490     SessionInfo *session = (SessionInfo *)SoftBusCalloc(sizeof(SessionInfo));
491     if (session == NULL) {
492         TRANS_LOGE(TRANS_SDK, "calloc failed");
493         return NULL;
494     }
495 
496     if (param->peerSessionName != NULL &&
497         strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName) != EOK) {
498         char *anonySessionName = NULL;
499         Anonymize(param->peerSessionName, &anonySessionName);
500         TRANS_LOGI(TRANS_SDK, "strcpy peerName failed, peerName=%{public}s, peerNameLen=%{public}zu",
501             anonySessionName, strlen(param->peerSessionName));
502         AnonymizeFree(anonySessionName);
503         SoftBusFree(session);
504         return NULL;
505     }
506 
507     if (param->peerDeviceId != NULL &&
508         strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId) != EOK) {
509         char *anonyNetworkId = NULL;
510         Anonymize(param->peerDeviceId, &anonyNetworkId);
511         TRANS_LOGI(TRANS_SDK, "strcpy peerDeviceId failed, peerDeviceId=%{public}s, peerDeviceIdLen=%{public}zu",
512             anonyNetworkId, strlen(param->peerDeviceId));
513         AnonymizeFree(anonyNetworkId);
514         SoftBusFree(session);
515         return NULL;
516     }
517 
518     if (strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId) != EOK ||
519         memcpy_s(session->linkType, sizeof(param->attr->linkType), param->attr->linkType,
520             sizeof(param->attr->linkType)) != EOK) {
521         TRANS_LOGE(TRANS_SDK, "strcpy failed");
522         SoftBusFree(session);
523         return NULL;
524     }
525 
526     if (SoftBusCondInit(&session->lifecycle.callbackCond) != SOFTBUS_OK) {
527         SoftBusFree(session);
528         TRANS_LOGE(TRANS_SDK, "callbackCond Init failed");
529         return NULL;
530     }
531 
532     ClientInitSession(session, param);
533     return session;
534 }
535 
CheckBindSocketInfo(const SessionInfo * session)536 int32_t CheckBindSocketInfo(const SessionInfo *session)
537 {
538     if (session == NULL) {
539         TRANS_LOGE(TRANS_SDK, "invalid param.");
540         return SOFTBUS_INVALID_PARAM;
541     }
542     if (!IsValidString(session->info.peerSessionName, SESSION_NAME_SIZE_MAX - 1) ||
543         !IsValidString(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX - 1)) {
544         char *anonySessionName = NULL;
545         char *anonyNetworkId = NULL;
546         Anonymize(session->info.peerSessionName, &anonySessionName);
547         Anonymize(session->info.peerDeviceId, &anonyNetworkId);
548         TRANS_LOGI(TRANS_SDK, "invalid peerName=%{public}s, peerNameLen=%{public}zu, peerNetworkId=%{public}s, "
549                               "peerNetworkIdLen=%{public}zu", anonySessionName,
550             strlen(session->info.peerSessionName), anonyNetworkId, strlen(session->info.peerDeviceId));
551         AnonymizeFree(anonyNetworkId);
552         AnonymizeFree(anonySessionName);
553         return SOFTBUS_INVALID_PARAM;
554     }
555 
556     if (session->info.flag < TYPE_MESSAGE || session->info.flag >= TYPE_BUTT) {
557         TRANS_LOGE(TRANS_SDK, "invalid dataType");
558         return SOFTBUS_INVALID_PARAM;
559     }
560 
561     return SOFTBUS_OK;
562 }
563 
FillSessionParam(SessionParam * param,SessionAttribute * tmpAttr,ClientSessionServer * serverNode,SessionInfo * sessionNode)564 void FillSessionParam(SessionParam *param, SessionAttribute *tmpAttr,
565     ClientSessionServer *serverNode, SessionInfo *sessionNode)
566 {
567     if (param == NULL || tmpAttr == NULL || serverNode == NULL || sessionNode == NULL) {
568         TRANS_LOGE(TRANS_SDK, "invalid param.");
569         return;
570     }
571     tmpAttr->fastTransData = NULL;
572     tmpAttr->fastTransDataSize = 0;
573     tmpAttr->dataType = sessionNode->info.flag;
574     tmpAttr->attr.streamAttr.streamType = sessionNode->info.streamType;
575     tmpAttr->linkTypeNum = 0;
576     param->sessionName = serverNode->sessionName;
577     param->peerSessionName = sessionNode->info.peerSessionName;
578     param->peerDeviceId = sessionNode->info.peerDeviceId;
579     param->groupId = "reserved";
580     param->attr = tmpAttr;
581     param->isQosLane = true;
582     param->actionId = sessionNode->actionId;
583 }
584 
ClientConvertRetVal(int32_t socket,int32_t * retOut)585 void ClientConvertRetVal(int32_t socket, int32_t *retOut)
586 {
587     if (retOut == NULL) {
588         TRANS_LOGE(TRANS_SDK, "invalid param.");
589         return;
590     }
591     SocketLifecycleData lifecycle;
592     (void)memset_s(&lifecycle, sizeof(SocketLifecycleData), 0, sizeof(SocketLifecycleData));
593     int32_t ret = GetSocketLifecycleAndSessionNameBySessionId(socket, NULL, &lifecycle);
594     if (ret != SOFTBUS_OK) {
595         TRANS_LOGE(TRANS_SDK, "get info fail, socket=%{public}d", socket);
596         return;
597     }
598 
599     if (lifecycle.bindErrCode == SOFTBUS_OK) {
600         TRANS_LOGE(TRANS_SDK, "bindErrCode is SOFTBUS_OK, socket=%{public}d", socket);
601         return;
602     }
603 
604     if (lifecycle.bindErrCode == SOFTBUS_TRANS_STOP_BIND_BY_TIMEOUT) {
605         *retOut = SOFTBUS_TRANS_REQUEST_LANE_TIMEOUT;
606         return;
607     }
608     *retOut = lifecycle.bindErrCode;
609 }
610 
ClientCleanUpIdleTimeoutSocket(const ListNode * destroyList)611 void ClientCleanUpIdleTimeoutSocket(const ListNode *destroyList)
612 {
613     if (destroyList == NULL || IsListEmpty(destroyList)) {
614         TRANS_LOGD(TRANS_SDK, "destroyList is empty.");
615         return;
616     }
617     DestroySessionInfo *destroyNode = NULL;
618     DestroySessionInfo *destroyNodeNext = NULL;
619     LIST_FOR_EACH_ENTRY_SAFE(destroyNode, destroyNodeNext, destroyList, DestroySessionInfo, node) {
620         int32_t id = destroyNode->sessionId;
621         (void)ClientDeleteRecvFileList(id);
622         (void)ClientTransCloseChannel(destroyNode->channelId, destroyNode->channelType);
623         TRANS_LOGI(TRANS_SDK, "session is idle, sessionId=%{public}d", id);
624         if (destroyNode->OnShutdown != NULL) {
625             destroyNode->OnShutdown(id, SHUTDOWN_REASON_TIMEOUT);
626             (void)TryDeleteEmptySessionServer(destroyNode->pkgName, destroyNode->sessionName);
627         }
628         ListDelete(&(destroyNode->node));
629         SoftBusFree(destroyNode);
630     }
631     TRANS_LOGD(TRANS_SDK, "ok");
632 }
633 
ClientCheckWaitTimeOut(const ClientSessionServer * serverNode,SessionInfo * sessionNode,int32_t waitOutSocket[],uint32_t capacity,uint32_t * num)634 void ClientCheckWaitTimeOut(const ClientSessionServer *serverNode, SessionInfo *sessionNode,
635     int32_t waitOutSocket[], uint32_t capacity, uint32_t *num)
636 {
637     if (sessionNode == NULL || waitOutSocket == NULL || num == NULL) {
638         TRANS_LOGE(TRANS_SDK, "invalid param.");
639         return;
640     }
641     if (sessionNode->enableStatus == ENABLE_STATUS_SUCCESS &&
642         strcmp(serverNode->sessionName, ISHARE_AUTH_SESSION) != 0) {
643         return;
644     }
645 
646     sessionNode->lifecycle.waitTime += TIMER_TIMEOUT;
647     if (sessionNode->lifecycle.maxWaitTime == 0 ||
648         sessionNode->lifecycle.waitTime <= sessionNode->lifecycle.maxWaitTime) {
649         TRANS_LOGD(TRANS_SDK, "no wait timeout, socket=%{public}d", sessionNode->sessionId);
650         return;
651     }
652 
653     TRANS_LOGW(TRANS_SDK, "bind time out socket=%{public}d", sessionNode->sessionId);
654     // stop check time out
655     sessionNode->lifecycle.maxWaitTime = 0;
656 
657     uint32_t tmpNum = *num;
658     if (tmpNum + 1 > capacity) {
659         TRANS_LOGE(TRANS_SDK, "socket num invalid tmpNum=%{public}u, capacity=%{public}u", tmpNum, capacity);
660         return;
661     }
662     waitOutSocket[tmpNum] = sessionNode->sessionId;
663     *num = tmpNum + 1;
664 }
665 
CleanUpTimeoutAuthSession(int32_t sessionId)666 static bool CleanUpTimeoutAuthSession(int32_t sessionId)
667 {
668     SocketLifecycleData lifecycle;
669     (void)memset_s(&lifecycle, sizeof(SocketLifecycleData), 0, sizeof(SocketLifecycleData));
670     char sessionName[SESSION_NAME_SIZE_MAX] = { 0 };
671     int32_t ret = GetSocketLifecycleAndSessionNameBySessionId(sessionId, sessionName, &lifecycle);
672     if (ret != SOFTBUS_OK) {
673         TRANS_LOGE(TRANS_SDK, "Get sessionId=%{public}d name failed, ret=%{public}d", sessionId, ret);
674         return false;
675     }
676 
677     if (strcmp(sessionName, ISHARE_AUTH_SESSION) != 0) {
678         return false;
679     }
680 
681     TRANS_LOGI(TRANS_SDK, "sessionId=%{public}d is idle timeout.", sessionId);
682     CloseSession(sessionId);
683     return true;
684 }
685 
ClientCleanUpWaitTimeoutSocket(int32_t waitOutSocket[],uint32_t waitOutNum)686 void ClientCleanUpWaitTimeoutSocket(int32_t waitOutSocket[], uint32_t waitOutNum)
687 {
688     if (waitOutSocket == NULL) {
689         TRANS_LOGE(TRANS_SDK, "invalid param.");
690         return;
691     }
692     bool tmpIsServer = false;
693     SessionListenerAdapter callback = { 0 };
694     for (uint32_t i = 0; i < waitOutNum; ++i) {
695         TRANS_LOGI(TRANS_SDK, "time out shutdown socket=%{public}d", waitOutSocket[i]);
696         SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
697         int32_t ret = ClientGetChannelBySessionId(waitOutSocket[i], NULL, NULL, &enableStatus);
698         if (ret != SOFTBUS_OK) {
699             TRANS_LOGI(TRANS_SDK, "socket get channel failed, socket=%{public}d", waitOutSocket[i]);
700             continue;
701         }
702         if (enableStatus == ENABLE_STATUS_SUCCESS) {
703             if (CleanUpTimeoutAuthSession(waitOutSocket[i])) {
704                 continue;
705             }
706             TRANS_LOGI(TRANS_SDK, "socket has enabled, need not shutdown, socket=%{public}d", waitOutSocket[i]);
707             continue;
708         }
709         ClientGetSessionCallbackAdapterById(waitOutSocket[i], &callback, &tmpIsServer);
710         if (callback.socketClient.OnError != NULL) {
711             (void)callback.socketClient.OnError(waitOutSocket[i], SOFTBUS_TRANS_STOP_BIND_BY_TIMEOUT);
712         }
713         ClientShutdown(waitOutSocket[i], SOFTBUS_TRANS_STOP_BIND_BY_TIMEOUT);
714     }
715 }
716 
ClientUpdateIdleTimeout(const ClientSessionServer * serverNode,SessionInfo * sessionNode,ListNode * destroyList)717 void ClientUpdateIdleTimeout(const ClientSessionServer *serverNode, SessionInfo *sessionNode, ListNode *destroyList)
718 {
719     if (serverNode == NULL || sessionNode == NULL || destroyList == NULL) {
720         TRANS_LOGE(TRANS_SDK, "invalid param.");
721         return;
722     }
723     if (sessionNode->role != SESSION_ROLE_CLIENT || sessionNode->enableStatus != ENABLE_STATUS_SUCCESS) {
724         return;
725     }
726 
727     sessionNode->timeout += TIMER_TIMEOUT;
728     if (sessionNode->maxIdleTime == 0 || sessionNode->timeout <= sessionNode->maxIdleTime) {
729         return;
730     }
731 
732     DestroySessionInfo *destroyNode = CreateDestroySessionNode(sessionNode, serverNode);
733     if (destroyNode == NULL) {
734         TRANS_LOGE(TRANS_SDK, "failed to create destory session Node, sessionId=%{public}d", sessionNode->sessionId);
735         return;
736     }
737     ListAdd(destroyList, &(destroyNode->node));
738     DestroySessionId();
739     ListDelete(&sessionNode->node);
740     SoftBusFree(sessionNode);
741 }
742 
ReCreateSessionServerToServer(ListNode * sessionServerInfoList)743 int32_t ReCreateSessionServerToServer(ListNode *sessionServerInfoList)
744 {
745     TRANS_LOGD(TRANS_SDK, "enter.");
746     if (sessionServerInfoList == NULL) {
747         TRANS_LOGE(TRANS_INIT, "session server list not init");
748         return SOFTBUS_INVALID_PARAM;
749     }
750 
751     SessionServerInfo *infoNode = NULL;
752     SessionServerInfo *infoNodeNext = NULL;
753     char *tmpName = NULL;
754     LIST_FOR_EACH_ENTRY_SAFE(infoNode, infoNodeNext, sessionServerInfoList, SessionServerInfo, node) {
755         int32_t ret = ServerIpcCreateSessionServer(infoNode->pkgName, infoNode->sessionName);
756         Anonymize(infoNode->sessionName, &tmpName);
757         TRANS_LOGI(TRANS_SDK, "sessionName=%{public}s, pkgName=%{public}s, ret=%{public}d",
758             tmpName, infoNode->pkgName, ret);
759         AnonymizeFree(tmpName);
760         ListDelete(&infoNode->node);
761         SoftBusFree(infoNode);
762     }
763 
764     TRANS_LOGI(TRANS_SDK, "ok");
765     return SOFTBUS_OK;
766 }
767 
FillDfsSocketParam(SessionParam * param,SessionAttribute * tmpAttr,ClientSessionServer * serverNode,SessionInfo * sessionNode)768 void FillDfsSocketParam(
769     SessionParam *param, SessionAttribute *tmpAttr, ClientSessionServer *serverNode, SessionInfo *sessionNode)
770 {
771     if (param == NULL || tmpAttr == NULL || serverNode == NULL || sessionNode == NULL) {
772         TRANS_LOGE(TRANS_SDK, "invalid param.");
773         return;
774     }
775     tmpAttr->fastTransData = NULL;
776     tmpAttr->fastTransDataSize = 0;
777     tmpAttr->dataType = sessionNode->info.flag;
778     tmpAttr->attr.streamAttr.streamType = sessionNode->info.streamType;
779     // 2 means has two linkType
780     tmpAttr->linkTypeNum = 2;
781     tmpAttr->linkType[0] = LINK_TYPE_WIFI_WLAN_5G;
782     tmpAttr->linkType[1] = LINK_TYPE_WIFI_WLAN_2G;
783     param->sessionName = serverNode->sessionName;
784     param->peerSessionName = sessionNode->info.peerSessionName;
785     param->peerDeviceId = sessionNode->info.peerDeviceId;
786     param->groupId = "reserved";
787     param->attr = tmpAttr;
788     param->isQosLane = false;
789     param->qosCount = 0;
790     (void)memset_s(param->qos, sizeof(param->qos), 0, sizeof(param->qos));
791     param->isAsync = false;
792 }
793 
GetQosValue(const QosTV * qos,uint32_t qosCount,QosType type,int32_t * value,int32_t defVal)794 int32_t GetQosValue(const QosTV *qos, uint32_t qosCount, QosType type, int32_t *value, int32_t defVal)
795 {
796     if (!IsValidQosInfo(qos, qosCount) || value == NULL) {
797         TRANS_LOGE(TRANS_SDK, "invalid param");
798         return SOFTBUS_INVALID_PARAM;
799     }
800 
801     if (qos == NULL || qosCount == 0) {
802         TRANS_LOGW(TRANS_SDK, "no qos info, use defVal");
803         *value = defVal;
804         return SOFTBUS_OK;
805     }
806 
807     for (uint32_t i = 0; i < qosCount; i++) {
808         if (qos[i].qos != type) {
809             continue;
810         }
811         *value = qos[i].value;
812         return SOFTBUS_OK;
813     }
814     *value = defVal;
815     return SOFTBUS_OK;
816 }
817 
ClientGrantPermission(int uid,int pid,const char * busName)818 int32_t ClientGrantPermission(int uid, int pid, const char *busName)
819 {
820     if (uid < 0 || pid < 0 || busName == NULL) {
821         TRANS_LOGW(TRANS_SDK, "invalid parameter");
822         return SOFTBUS_INVALID_PARAM;
823     }
824     char *tmpName = NULL;
825     Anonymize(busName, &tmpName);
826     TRANS_LOGI(TRANS_SDK, "sessionName=%{public}s", tmpName);
827     AnonymizeFree(tmpName);
828     int32_t ret = ServerIpcGrantPermission(uid, pid, busName);
829     if (ret != SOFTBUS_OK) {
830         TRANS_LOGE(TRANS_SDK, "server grant permission failed, ret=%{public}d", ret);
831     }
832     return ret;
833 }
834 
ClientRemovePermission(const char * busName)835 int32_t ClientRemovePermission(const char *busName)
836 {
837     if (busName == NULL) {
838         TRANS_LOGW(TRANS_SDK, "invalid parameter");
839         return SOFTBUS_INVALID_PARAM;
840     }
841     char *tmpName = NULL;
842     Anonymize(busName, &tmpName);
843     TRANS_LOGI(TRANS_SDK, "sessionName=%{public}s", tmpName);
844     AnonymizeFree(tmpName);
845     int32_t ret = ServerIpcRemovePermission(busName);
846     if (ret != SOFTBUS_OK) {
847         TRANS_LOGE(TRANS_SDK, "server remove permission failed, ret=%{public}d", ret);
848     }
849     return ret;
850 }
851 
ClientDeleteSocketSession(int32_t sessionId)852 int32_t ClientDeleteSocketSession(int32_t sessionId)
853 {
854     if (sessionId <= 0) {
855         TRANS_LOGE(TRANS_SDK, "Invalid sessionId=%{public}d", sessionId);
856         return SOFTBUS_INVALID_PARAM;
857     }
858 
859     char pkgName[PKG_NAME_SIZE_MAX] = { 0 };
860     char sessionName[SESSION_NAME_SIZE_MAX] = { 0 };
861     int32_t ret = DeleteSocketSession(sessionId, pkgName, sessionName);
862     if (ret != SOFTBUS_OK) {
863         TRANS_LOGE(TRANS_SDK, "failed delete session");
864         return ret;
865     }
866 
867     ret = TryDeleteEmptySessionServer(pkgName, sessionName);
868     if (ret != SOFTBUS_OK) {
869         TRANS_LOGE(TRANS_SDK, "delete empty session server failed, ret=%{public}d", ret);
870         return ret;
871     }
872     return SOFTBUS_OK;
873 }
874