1 /*
2  * Copyright (c) 2021-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_session_service.h"
17 
18 #ifndef _GNU_SOURCE
19 #define _GNU_SOURCE
20 #endif
21 
22 #include <unistd.h>
23 
24 #include "anonymizer.h"
25 #include "client_qos_manager.h"
26 #include "client_trans_channel_manager.h"
27 #include "client_trans_file_listener.h"
28 #include "client_trans_session_adapter.h"
29 #include "client_trans_session_manager.h"
30 #include "client_trans_socket_manager.h"
31 #include "dfs_session.h"
32 #include "inner_session.h"
33 #include "securec.h"
34 #include "session_ipc_adapter.h"
35 #include "softbus_adapter_mem.h"
36 #include "softbus_client_frame_manager.h"
37 #include "softbus_def.h"
38 #include "softbus_errcode.h"
39 #include "softbus_feature_config.h"
40 #include "softbus_json_utils.h"
41 #include "softbus_trans_def.h"
42 #include "softbus_utils.h"
43 #include "trans_log.h"
44 #include "trans_server_proxy.h"
45 
46 typedef int (*SessionOptionRead)(int32_t channelId, int32_t type, void* value, uint32_t valueSize);
47 typedef int (*SessionOptionWrite)(int32_t channelId, int32_t type, void* value, uint32_t valueSize);
48 
49 typedef struct {
50     bool canRead;
51     SessionOptionRead readFunc;
52 } SessionOptionItem;
53 
54 typedef struct {
55     int32_t channelType;
56     int32_t businessType;
57     ConfigType configType;
58 } ConfigTypeMap;
59 
IsValidSessionId(int sessionId)60 static bool IsValidSessionId(int sessionId)
61 {
62     if (sessionId <= 0) {
63         TRANS_LOGE(TRANS_SDK, "invalid sessionId=%{public}d", sessionId);
64         return false;
65     }
66     return true;
67 }
68 
IsValidListener(const ISessionListener * listener)69 static bool IsValidListener(const ISessionListener *listener)
70 {
71     if ((listener != NULL) &&
72         (listener->OnSessionOpened != NULL) &&
73         (listener->OnSessionClosed != NULL)) {
74         return true;
75     }
76     TRANS_LOGE(TRANS_SDK, "invalid ISessionListener");
77     return false;
78 }
79 
OpenSessionWithExistSession(int32_t sessionId,bool isEnabled)80 static int32_t OpenSessionWithExistSession(int32_t sessionId, bool isEnabled)
81 {
82     if (!isEnabled) {
83         int32_t errCode = SOFTBUS_TRANS_SESSION_OPENING;
84         TRANS_LOGI(TRANS_SDK, "the channel is opening, errCode=%{public}d", errCode);
85         return sessionId;
86     }
87 
88     ISessionListener listener = { 0 };
89     int32_t ret = ClientGetSessionCallbackById(sessionId, &listener);
90     if (ret != SOFTBUS_OK) {
91         TRANS_LOGE(TRANS_SDK, "get session listener failed, ret=%{public}d", ret);
92         CloseSession(sessionId);
93         return SOFTBUS_TRANS_INVALID_SESSION_ID;
94     }
95 
96     ret = listener.OnSessionOpened(sessionId, SOFTBUS_OK);
97     if (ret != 0) {
98         TRANS_LOGE(TRANS_SDK, "session callback OnSessionOpened failed, ret=%{public}d", ret);
99         CloseSession(sessionId);
100         return SOFTBUS_TRANS_INVALID_SESSION_ID;
101     }
102     return sessionId;
103 }
104 
CreateSessionServer(const char * pkgName,const char * sessionName,const ISessionListener * listener)105 int CreateSessionServer(const char *pkgName, const char *sessionName, const ISessionListener *listener)
106 {
107     if (!IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1) || !IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1) ||
108         !IsValidListener(listener)) {
109         TRANS_LOGW(TRANS_SDK, "invalid param");
110         return SOFTBUS_INVALID_PARAM;
111     }
112     char *tmpName = NULL;
113     Anonymize(sessionName, &tmpName);
114     TRANS_LOGI(TRANS_SDK, "pkgName=%{public}s, sessionName=%{public}s", pkgName, tmpName);
115     AnonymizeFree(tmpName);
116     if (InitSoftBus(pkgName) != SOFTBUS_OK) {
117         TRANS_LOGE(TRANS_SDK, "init softbus err");
118         return SOFTBUS_TRANS_SESSION_ADDPKG_FAILED;
119     }
120 
121     if (CheckPackageName(pkgName) != SOFTBUS_OK) {
122         TRANS_LOGE(TRANS_SDK, "invalid pkg name");
123         return SOFTBUS_INVALID_PKGNAME;
124     }
125 
126     int ret = ClientAddSessionServer(SEC_TYPE_CIPHERTEXT, pkgName, sessionName, listener);
127     if (ret == SOFTBUS_SERVER_NAME_REPEATED) {
128         TRANS_LOGI(TRANS_SDK, "SessionServer is already created in client");
129     } else if (ret != SOFTBUS_OK) {
130         TRANS_LOGE(TRANS_SDK, "add session server err, ret=%{public}d.", ret);
131         return ret;
132     }
133 
134     ret = ServerIpcCreateSessionServer(pkgName, sessionName);
135     if (ret == SOFTBUS_SERVER_NAME_REPEATED) {
136         TRANS_LOGW(TRANS_SDK, "ok, SessionServer is already created in server");
137         return SOFTBUS_OK;
138     } else if (ret != SOFTBUS_OK) {
139         TRANS_LOGE(TRANS_SDK, "createSessionServer failed, ret=%{public}d", ret);
140         (void)ClientDeleteSessionServer(SEC_TYPE_CIPHERTEXT, sessionName);
141         return ret;
142     }
143     TRANS_LOGI(TRANS_SDK, "ok");
144     return ret;
145 }
146 
RemoveSessionServer(const char * pkgName,const char * sessionName)147 int RemoveSessionServer(const char *pkgName, const char *sessionName)
148 {
149     if (!IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1) || !IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1)) {
150         TRANS_LOGW(TRANS_SDK, "invalid param");
151         return SOFTBUS_INVALID_PARAM;
152     }
153     char *tmpName = NULL;
154     Anonymize(sessionName, &tmpName);
155     TRANS_LOGI(TRANS_SDK, "pkgName=%{public}s, sessionName=%{public}s", pkgName, tmpName);
156 
157     int32_t ret = ServerIpcRemoveSessionServer(pkgName, sessionName);
158     if (ret != SOFTBUS_OK) {
159         TRANS_LOGE(TRANS_SDK, "remove in server failed, ret=%{public}d.", ret);
160         AnonymizeFree(tmpName);
161         return ret;
162     }
163 
164     ret = ClientDeleteSessionServer(SEC_TYPE_CIPHERTEXT, sessionName);
165     if (ret != SOFTBUS_OK) {
166         TRANS_LOGE(TRANS_SDK, "delete session server failed, sessionName=%{public}s, ret=%{public}d.", tmpName, ret);
167         DeleteFileListener(sessionName);
168         AnonymizeFree(tmpName);
169         return ret;
170     }
171     DeleteFileListener(sessionName);
172     AnonymizeFree(tmpName);
173     TRANS_LOGI(TRANS_SDK, "ok");
174     return ret;
175 }
176 
CheckParamIsValid(const char * mySessionName,const char * peerSessionName,const char * peerNetworkId,const char * groupId,const SessionAttribute * attr)177 static int32_t CheckParamIsValid(const char *mySessionName, const char *peerSessionName,
178     const char *peerNetworkId, const char *groupId, const SessionAttribute *attr)
179 {
180     if (!IsValidString(mySessionName, SESSION_NAME_SIZE_MAX - 1)) {
181         char *tmpMyName = NULL;
182         Anonymize(mySessionName, &tmpMyName);
183         TRANS_LOGE(TRANS_SDK, "invalid mySessionName. tmpMyName=%{public}s", tmpMyName);
184         AnonymizeFree(tmpMyName);
185         return SOFTBUS_TRANS_INVALID_SESSION_NAME;
186     }
187     if (!IsValidString(peerSessionName, SESSION_NAME_SIZE_MAX - 1)) {
188         char *tmpPeerName = NULL;
189         Anonymize(peerSessionName, &tmpPeerName);
190         TRANS_LOGE(TRANS_SDK, "invalid peerSessionName. tmpPeerName=%{public}s", tmpPeerName);
191         AnonymizeFree(tmpPeerName);
192         return SOFTBUS_TRANS_INVALID_SESSION_NAME;
193     }
194     if (!IsValidString(peerNetworkId, DEVICE_ID_SIZE_MAX - 1)) {
195         char *tmpPeerNetworkId = NULL;
196         Anonymize(peerNetworkId, &tmpPeerNetworkId);
197         TRANS_LOGE(TRANS_SDK, "invalid peerNetworkId. tmpPeerNetworkId=%{public}s", tmpPeerNetworkId);
198         AnonymizeFree(tmpPeerNetworkId);
199         return SOFTBUS_INVALID_PARAM;
200     }
201     if (attr == NULL) {
202         TRANS_LOGE(TRANS_SDK, "attr is NULL");
203         return SOFTBUS_INVALID_PARAM;
204     }
205     if (groupId == NULL) {
206         TRANS_LOGE(TRANS_SDK, "groupId is NULL");
207         return SOFTBUS_INVALID_PARAM;
208     }
209     if (strlen(groupId) >= GROUP_ID_SIZE_MAX) {
210         TRANS_LOGE(TRANS_SDK, "groupId length is invalid");
211         return SOFTBUS_INVALID_PARAM;
212     }
213 
214     return SOFTBUS_OK;
215 }
216 
PrintSessionName(const char * mySessionName,const char * peerSessionName)217 static void PrintSessionName(const char *mySessionName, const char *peerSessionName)
218 {
219     char *tmpMyName = NULL;
220     char *tmpPeerName = NULL;
221     Anonymize(mySessionName, &tmpMyName);
222     Anonymize(peerSessionName, &tmpPeerName);
223     TRANS_LOGI(TRANS_SDK, "OpenSession: mySessionName=%{public}s, peerSessionName=%{public}s",
224         tmpMyName, tmpPeerName);
225     AnonymizeFree(tmpMyName);
226     AnonymizeFree(tmpPeerName);
227 }
228 
BuildParamSessionAttribute(const SessionAttribute * attr)229 static SessionAttribute *BuildParamSessionAttribute(const SessionAttribute *attr)
230 {
231     SessionAttribute *tmpAttr = (SessionAttribute *)SoftBusCalloc(sizeof(SessionAttribute));
232     if (tmpAttr == NULL) {
233         TRANS_LOGE(TRANS_SDK, "SoftBusCalloc SessionAttribute failed");
234         return NULL;
235     }
236     if (memcpy_s(tmpAttr, sizeof(SessionAttribute), attr, sizeof(SessionAttribute)) != EOK) {
237         TRANS_LOGE(TRANS_SDK, "memcpy_s SessionAttribute failed");
238         SoftBusFree(tmpAttr);
239         return NULL;
240     }
241     tmpAttr->fastTransData = NULL;
242     tmpAttr->fastTransDataSize = 0;
243     return tmpAttr;
244 }
245 
InitSessionParam(const char * mySessionName,const char * peerSessionName,const char * peerNetworkId,const char * groupId,SessionParam * param)246 static void InitSessionParam(const char *mySessionName, const char *peerSessionName, const char *peerNetworkId,
247     const char *groupId, SessionParam *param)
248 {
249     param->sessionName = mySessionName;
250     param->peerSessionName = peerSessionName;
251     param->peerDeviceId = peerNetworkId;
252     param->groupId = groupId;
253     param->isQosLane = false;
254     param->qosCount = 0;
255     param->isAsync = false;
256     param->actionId = INVALID_ACTION_ID;
257 }
258 
OpenSession(const char * mySessionName,const char * peerSessionName,const char * peerNetworkId,const char * groupId,const SessionAttribute * attr)259 int OpenSession(const char *mySessionName, const char *peerSessionName, const char *peerNetworkId,
260     const char *groupId, const SessionAttribute *attr)
261 {
262     int32_t ret = CheckParamIsValid(mySessionName, peerSessionName, peerNetworkId, groupId, attr);
263     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SDK, "invalid session name.");
264 
265     PrintSessionName(mySessionName, peerSessionName);
266     SessionAttribute *tmpAttr = BuildParamSessionAttribute(attr);
267     TRANS_CHECK_AND_RETURN_RET_LOGE(tmpAttr != NULL, SOFTBUS_MEM_ERR, TRANS_SDK, "Build SessionAttribute failed.");
268     SessionParam param = { 0 };
269     InitSessionParam(mySessionName, peerSessionName, peerNetworkId, groupId, &param);
270     param.attr = tmpAttr;
271     (void)memset_s(param.qos, sizeof(param.qos), 0, sizeof(param.qos));
272 
273     int32_t sessionId = INVALID_SESSION_ID;
274     SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
275 
276     ret = ClientAddSession(&param, &sessionId, &isEnabled);
277     if (ret != SOFTBUS_OK) {
278         SoftBusFree(tmpAttr);
279         if (ret == SOFTBUS_TRANS_SESSION_REPEATED) {
280             TRANS_LOGI(TRANS_SDK, "session already opened");
281             return OpenSessionWithExistSession(sessionId, isEnabled);
282         }
283         TRANS_LOGE(TRANS_SDK, "add session err: ret=%{public}d", ret);
284         return ret;
285     }
286     param.sessionId = sessionId;
287     TransInfo transInfo = { 0 };
288     ret = ServerIpcOpenSession(&param, &transInfo);
289     if (ret != SOFTBUS_OK) {
290         TRANS_LOGE(TRANS_SDK, "open session ipc err: ret=%{public}d", ret);
291         SoftBusFree(tmpAttr);
292         (void)ClientDeleteSession(sessionId);
293         return ret;
294     }
295 
296     ret = ClientSetChannelBySessionId(sessionId, &transInfo);
297     if (ret != SOFTBUS_OK) {
298         TRANS_LOGE(TRANS_SDK, "set channel by sessionId failed, ret=%{public}d", ret);
299         SoftBusFree(tmpAttr);
300         (void)ClientDeleteSession(sessionId);
301         return SOFTBUS_TRANS_SESSION_SET_CHANNEL_FAILED;
302     }
303     TRANS_LOGI(TRANS_SDK, "ok: sessionId=%{public}d, channelId=%{public}d, channelType=%{public}d",
304         sessionId, transInfo.channelId, transInfo.channelType);
305     SoftBusFree(tmpAttr);
306     return sessionId;
307 }
308 
ConvertAddrStr(const char * addrStr,ConnectionAddr * addrInfo)309 static int32_t ConvertAddrStr(const char *addrStr, ConnectionAddr *addrInfo)
310 {
311     TRANS_CHECK_AND_RETURN_RET_LOGE(
312         (addrStr != NULL && addrInfo != NULL), SOFTBUS_INVALID_PARAM, TRANS_SDK, "invalid param");
313     cJSON *obj = cJSON_Parse(addrStr);
314     TRANS_CHECK_AND_RETURN_RET_LOGE(obj != NULL, SOFTBUS_PARSE_JSON_ERR, TRANS_SDK, "addrStr parse failed.");
315     int32_t port;
316     if (GetJsonObjectStringItem(obj, "ETH_IP", addrInfo->info.ip.ip, IP_STR_MAX_LEN) &&
317         GetJsonObjectNumberItem(obj, "ETH_PORT", &port)) {
318         addrInfo->info.ip.port = (uint16_t)port;
319         if (IsValidString(addrInfo->info.ip.ip, IP_STR_MAX_LEN) && addrInfo->info.ip.port > 0) {
320             cJSON_Delete(obj);
321             addrInfo->type = CONNECTION_ADDR_ETH;
322             return SOFTBUS_OK;
323         }
324     }
325     if (GetJsonObjectStringItem(obj, "WIFI_IP", addrInfo->info.ip.ip, IP_STR_MAX_LEN) &&
326         GetJsonObjectNumberItem(obj, "WIFI_PORT", &port)) {
327         addrInfo->info.ip.port = (uint16_t)port;
328         if (IsValidString(addrInfo->info.ip.ip, IP_STR_MAX_LEN) && addrInfo->info.ip.port > 0) {
329             cJSON_Delete(obj);
330             addrInfo->type = CONNECTION_ADDR_WLAN;
331             return SOFTBUS_OK;
332         }
333     }
334     if (GetJsonObjectStringItem(obj, "BR_MAC", addrInfo->info.br.brMac, BT_MAC_LEN)) {
335         cJSON_Delete(obj);
336         addrInfo->type = CONNECTION_ADDR_BR;
337         return SOFTBUS_OK;
338     }
339     if (GetJsonObjectStringItem(obj, "BLE_MAC", addrInfo->info.ble.bleMac, BT_MAC_LEN)) {
340         char udidHash[UDID_HASH_LEN] = {0};
341         if (GetJsonObjectStringItem(obj, "deviceId", udidHash, UDID_HASH_LEN)) {
342             char *tmpUdidHash = NULL;
343             Anonymize(udidHash, &tmpUdidHash);
344             int ret = ConvertHexStringToBytes(
345                 (unsigned char *)addrInfo->info.ble.udidHash, UDID_HASH_LEN, udidHash, strlen(udidHash));
346             TRANS_LOGI(TRANS_SDK, "string to bytes ret=%{public}d, udidHash=%{public}s",
347                 ret, AnonymizeWrapper(tmpUdidHash));
348             AnonymizeFree(tmpUdidHash);
349         }
350         cJSON_Delete(obj);
351         addrInfo->type = CONNECTION_ADDR_BLE;
352         return SOFTBUS_OK;
353     }
354     cJSON_Delete(obj);
355     TRANS_LOGE(TRANS_SDK, "addr convert fail");
356     return SOFTBUS_PARSE_JSON_ERR;
357 }
358 
IsValidAddrInfoArr(const ConnectionAddr * addrInfo,int num)359 static int IsValidAddrInfoArr(const ConnectionAddr *addrInfo, int num)
360 {
361     int32_t addrIndex = -1;
362     if (addrInfo == NULL || num <= 0) {
363         return addrIndex;
364     }
365     int32_t wifiIndex = -1;
366     int32_t brIndex = -1;
367     int32_t bleIndex = -1;
368     for (int32_t index = 0; index < num; index++) {
369         if ((addrInfo[index].type == CONNECTION_ADDR_ETH || addrInfo[index].type == CONNECTION_ADDR_WLAN) &&
370             wifiIndex < 0) {
371             wifiIndex = index;
372         }
373         if (addrInfo[index].type == CONNECTION_ADDR_BR && brIndex < 0) {
374             brIndex = index;
375         }
376         if (addrInfo[index].type == CONNECTION_ADDR_BLE && bleIndex < 0) {
377             bleIndex = index;
378         }
379     }
380     addrIndex = (wifiIndex >= 0) ? wifiIndex : addrIndex;
381     addrIndex = (addrIndex < 0) ? brIndex : addrIndex;
382     addrIndex = (addrIndex < 0) ? bleIndex : addrIndex;
383     return addrIndex;
384 }
385 
OpenAuthSession(const char * sessionName,const ConnectionAddr * addrInfo,int num,const char * mixAddr)386 int OpenAuthSession(const char *sessionName, const ConnectionAddr *addrInfo, int num, const char *mixAddr)
387 {
388     if (!IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1)) {
389         TRANS_LOGW(TRANS_SDK, "invalid param");
390         return SOFTBUS_INVALID_PARAM;
391     }
392     TransInfo transInfo;
393     int32_t addrIndex = IsValidAddrInfoArr(addrInfo, num);
394     ConnectionAddr *addr = NULL;
395     ConnectionAddr mix;
396     if (memset_s(&mix, sizeof(ConnectionAddr), 0x0, sizeof(ConnectionAddr)) != EOK) {
397         TRANS_LOGE(TRANS_SDK, "memset_s info fail");
398         return SOFTBUS_MEM_ERR;
399     }
400     if (addrIndex < 0) {
401         if (ConvertAddrStr(mixAddr, &mix) != SOFTBUS_OK) {
402             TRANS_LOGE(TRANS_SDK, "invalid addrInfo param");
403             return SOFTBUS_INVALID_PARAM;
404         }
405         addr = &mix;
406     } else {
407         addr = (ConnectionAddr *)&addrInfo[addrIndex];
408     }
409     char *tmpName = NULL;
410     Anonymize(sessionName, &tmpName);
411     TRANS_LOGI(TRANS_SDK, "sessionName=%{public}s", tmpName);
412     AnonymizeFree(tmpName);
413     int32_t sessionId;
414     int32_t ret = ClientAddAuthSession(sessionName, &sessionId);
415     if (ret != SOFTBUS_OK) {
416         TRANS_LOGE(TRANS_SDK, "add non encrypt session err: ret=%{public}d", ret);
417         return ret;
418     }
419 
420     transInfo.channelId = ServerIpcOpenAuthSession(sessionName, addr);
421     if (addr->type == CONNECTION_ADDR_BR || addr->type == CONNECTION_ADDR_BLE) {
422         transInfo.channelType = CHANNEL_TYPE_PROXY;
423     } else {
424         transInfo.channelType = CHANNEL_TYPE_AUTH;
425     }
426     ret = ClientSetChannelBySessionId(sessionId, &transInfo);
427     if (ret != SOFTBUS_OK) {
428         TRANS_LOGE(TRANS_SDK, "set channel by sessionId failed, ret=%{public}d", ret);
429         (void)ClientDeleteSession(sessionId);
430         return SOFTBUS_TRANS_SESSION_SET_CHANNEL_FAILED;
431     }
432     TRANS_LOGI(TRANS_SDK, "ok: sessionId=%{public}d, channelId=%{public}d, channelType=%{public}d",
433         sessionId, transInfo.channelId, transInfo.channelType);
434     return sessionId;
435 }
436 
NotifyAuthSuccess(int sessionId)437 void NotifyAuthSuccess(int sessionId)
438 {
439     int32_t channelId = -1;
440     int32_t channelType = -1;
441     TRANS_LOGI(TRANS_SDK, "sessionId=%{public}d", sessionId);
442     int32_t ret = ClientGetChannelBySessionId(sessionId, &channelId, &channelType, NULL);
443     if (ret != SOFTBUS_OK) {
444         TRANS_LOGE(TRANS_SDK, "get channel err, sessionId=%{public}d, ret=%{public}d", sessionId, ret);
445         return;
446     }
447 
448     int32_t isServer = 0;
449     ret = ClientGetSessionIntegerDataById(sessionId, &isServer, KEY_IS_SERVER);
450     if (ret != SOFTBUS_OK) {
451         TRANS_LOGE(TRANS_SDK, "get isServer failed, ret=%{public}d", ret);
452         return;
453     }
454     if (isServer == 1) {
455         TRANS_LOGE(TRANS_SDK, "device is service side, no notification");
456         return;
457     }
458     TRANS_LOGI(TRANS_SDK,
459         "client side, notify auth success channelId=%{public}d, channelType=%{public}d", channelId, channelType);
460 
461     ret = ServerIpcNotifyAuthSuccess(channelId, channelType);
462     if (ret != SOFTBUS_OK) {
463         TRANS_LOGE(TRANS_SDK,
464             "ServerIpcNotifyAuthSuccess err channelId=%{public}d, ret=%{public}d", channelId, ret);
465         return;
466     }
467 }
468 
CheckSessionIsOpened(int32_t sessionId,bool isCancelCheck)469 static int32_t CheckSessionIsOpened(int32_t sessionId, bool isCancelCheck)
470 {
471 #define SESSION_STATUS_CHECK_MAX_NUM 100
472 #define SESSION_STATUS_CANCEL_CHECK_MAX_NUM 5
473 #define SESSION_CHECK_PERIOD 200000
474     int32_t checkMaxNum = isCancelCheck ? SESSION_STATUS_CANCEL_CHECK_MAX_NUM : SESSION_STATUS_CHECK_MAX_NUM;
475     int32_t i = 0;
476     SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
477     while (i < checkMaxNum) {
478         if (ClientGetChannelBySessionId(sessionId, NULL, NULL, &enableStatus) != SOFTBUS_OK) {
479             return SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED;
480         }
481         if (enableStatus == ENABLE_STATUS_SUCCESS) {
482             TRANS_LOGD(TRANS_SDK, "session is enable");
483             return SOFTBUS_OK;
484         }
485 
486         if (enableStatus == ENABLE_STATUS_FAILED) {
487             TRANS_LOGE(TRANS_SDK, "socket is failed");
488             return SOFTBUS_TRANS_SESSION_NO_ENABLE;
489         }
490         usleep(SESSION_CHECK_PERIOD);
491         i++;
492     }
493 
494     TRANS_LOGE(TRANS_SDK, "session open timeout");
495     return SOFTBUS_TIMOUT;
496 }
497 
OpenSessionSync(const char * mySessionName,const char * peerSessionName,const char * peerNetworkId,const char * groupId,const SessionAttribute * attr)498 int OpenSessionSync(const char *mySessionName, const char *peerSessionName, const char *peerNetworkId,
499     const char *groupId, const SessionAttribute *attr)
500 {
501     int ret = CheckParamIsValid(mySessionName, peerSessionName, peerNetworkId, groupId, attr);
502     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SDK, "invalid session name.");
503     PrintSessionName(mySessionName, peerSessionName);
504 
505     SessionParam param = {
506         .sessionName = mySessionName,
507         .peerSessionName = peerSessionName,
508         .peerDeviceId = peerNetworkId,
509         .groupId = groupId,
510         .attr = attr,
511         .isQosLane = false,
512         .qosCount = 0,
513     };
514     (void)memset_s(param.qos, sizeof(param.qos), 0, sizeof(param.qos));
515 
516     int32_t sessionId = INVALID_SESSION_ID;
517     SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
518 
519     ret = ClientAddSession(&param, &sessionId, &isEnabled);
520     if (ret != SOFTBUS_OK) {
521         if (ret == SOFTBUS_TRANS_SESSION_REPEATED) {
522             TRANS_LOGI(TRANS_SDK, "session already opened");
523             CheckSessionIsOpened(sessionId, false);
524             return OpenSessionWithExistSession(sessionId, isEnabled);
525         }
526         TRANS_LOGE(TRANS_SDK, "add session err: ret=%{public}d", ret);
527         return ret;
528     }
529     param.isAsync = false;
530     param.sessionId = sessionId;
531     TransInfo transInfo = {0};
532     ret = ServerIpcOpenSession(&param, &transInfo);
533     if (ret != SOFTBUS_OK) {
534         TRANS_LOGE(TRANS_SDK, "open session ipc err: ret=%{public}d", ret);
535         (void)ClientDeleteSession(sessionId);
536         return ret;
537     }
538     ret = ClientSetChannelBySessionId(sessionId, &transInfo);
539     if (ret != SOFTBUS_OK) {
540         TRANS_LOGE(TRANS_SDK, "set channel by sessionId=%{public}d, ret=%{public}d", sessionId, ret);
541         (void)ClientDeleteSession(sessionId);
542         return SOFTBUS_TRANS_SESSION_SET_CHANNEL_FAILED;
543     }
544 
545     ret = CheckSessionIsOpened(sessionId, false);
546     if (ret != SOFTBUS_OK) {
547         TRANS_LOGE(TRANS_SDK, "CheckSessionIsOpened err: ret=%{public}d", ret);
548         (void)ClientDeleteSession(sessionId);
549         return SOFTBUS_TRANS_SESSION_NO_ENABLE;
550     }
551     TRANS_LOGI(TRANS_SDK, "ok: sessionId=%{public}d, channelId=%{public}d", sessionId, transInfo.channelId);
552     return sessionId;
553 }
554 
CloseSession(int sessionId)555 void CloseSession(int sessionId)
556 {
557     TRANS_LOGI(TRANS_SDK, "sessionId=%{public}d", sessionId);
558     int32_t channelId = INVALID_CHANNEL_ID;
559     int32_t type = CHANNEL_TYPE_BUTT;
560     int32_t ret;
561 
562     if (!IsValidSessionId(sessionId)) {
563         TRANS_LOGW(TRANS_SDK, "invalid param");
564         return;
565     }
566     ret = ClientGetChannelBySessionId(sessionId, &channelId, &type, NULL);
567     if (ret != SOFTBUS_OK) {
568         TRANS_LOGE(TRANS_SDK, "get channel by sessionId=%{public}d, ret=%{public}d", sessionId, ret);
569         return;
570     }
571     AddSessionStateClosing();
572     ret = ClientTransCloseChannel(channelId, type);
573     if (ret != SOFTBUS_OK) {
574         TRANS_LOGE(TRANS_SDK, "close channel err: ret=%{public}d, channelId=%{public}d, channelType=%{public}d",
575             ret, channelId, type);
576     }
577     ret = ClientDeleteSession(sessionId);
578     if (ret != SOFTBUS_OK) {
579         TRANS_LOGE(TRANS_SDK, "delete session err: ret=%{public}d", ret);
580         return;
581     }
582     TRANS_LOGD(TRANS_SDK, "ok");
583 }
584 
GetMySessionName(int sessionId,char * sessionName,unsigned int len)585 int GetMySessionName(int sessionId, char *sessionName, unsigned int len)
586 {
587     if (!IsValidSessionId(sessionId) || (sessionName == NULL) || (len > SESSION_NAME_SIZE_MAX)) {
588         TRANS_LOGE(TRANS_SDK, "invalid param");
589         return SOFTBUS_INVALID_PARAM;
590     }
591     TRANS_LOGI(TRANS_SDK, "get client sessionName by sessionId=%{public}d", sessionId);
592     return ClientGetSessionDataById(sessionId, sessionName, len, KEY_SESSION_NAME);
593 }
594 
GetPeerSessionName(int sessionId,char * sessionName,unsigned int len)595 int GetPeerSessionName(int sessionId, char *sessionName, unsigned int len)
596 {
597     if (!IsValidSessionId(sessionId) || (sessionName == NULL) || (len > SESSION_NAME_SIZE_MAX)) {
598         TRANS_LOGE(TRANS_SDK, "invalid param");
599         return SOFTBUS_INVALID_PARAM;
600     }
601     TRANS_LOGI(TRANS_SDK, "get server sessionName by sessionId=%{public}d", sessionId);
602     return ClientGetSessionDataById(sessionId, sessionName, len, KEY_PEER_SESSION_NAME);
603 }
604 
GetPeerDeviceId(int sessionId,char * networkId,unsigned int len)605 int GetPeerDeviceId(int sessionId, char *networkId, unsigned int len)
606 {
607     if (!IsValidSessionId(sessionId) || (networkId  == NULL) || (len > SESSION_NAME_SIZE_MAX)) {
608         TRANS_LOGE(TRANS_SDK, "invalid param");
609         return SOFTBUS_INVALID_PARAM;
610     }
611     TRANS_LOGI(TRANS_SDK, "get server deviceId by sessionId=%{public}d", sessionId);
612     return ClientGetSessionDataById(sessionId, networkId, len, KEY_PEER_DEVICE_ID);
613 }
614 
GetSessionSide(int sessionId)615 int GetSessionSide(int sessionId)
616 {
617     TRANS_LOGI(TRANS_SDK, "get session side by sessionId=%{public}d", sessionId);
618     return ClientGetSessionSide(sessionId);
619 }
620 
IsValidFileReceivePath(const char * rootDir)621 static bool IsValidFileReceivePath(const char *rootDir)
622 {
623     if (!IsValidString(rootDir, FILE_RECV_ROOT_DIR_SIZE_MAX)) {
624         TRANS_LOGE(TRANS_SDK, "recvPath invalid. recvPath=%{private}s", rootDir);
625         return false;
626     }
627     char *absPath = realpath(rootDir, NULL);
628     if (absPath == NULL) {
629         TRANS_LOGE(TRANS_SDK, "recvPath not exist, recvPath=%{private}s, errno=%{public}d.", rootDir, errno);
630         return false;
631     }
632     SoftBusFree(absPath);
633     return true;
634 }
635 
SetFileReceiveListener(const char * pkgName,const char * sessionName,const IFileReceiveListener * recvListener,const char * rootDir)636 int SetFileReceiveListener(const char *pkgName, const char *sessionName,
637     const IFileReceiveListener *recvListener, const char *rootDir)
638 {
639     if (!IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1) || !IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1) ||
640         !IsValidFileReceivePath(rootDir) || (recvListener == NULL)) {
641         TRANS_LOGW(TRANS_SDK, "set file receive listener invalid param");
642         return SOFTBUS_INVALID_PARAM;
643     }
644     if (InitSoftBus(pkgName) != SOFTBUS_OK) {
645         TRANS_LOGE(TRANS_SDK, "set file receive listener init softbus client error");
646         return SOFTBUS_TRANS_SESSION_ADDPKG_FAILED;
647     }
648     char *tmpName = NULL;
649     Anonymize(sessionName, &tmpName);
650     TRANS_LOGI(TRANS_SDK, "sessionName=%{public}s", tmpName);
651     AnonymizeFree(tmpName);
652     return TransSetFileReceiveListener(sessionName, recvListener, rootDir);
653 }
654 
SetFileSendListener(const char * pkgName,const char * sessionName,const IFileSendListener * sendListener)655 int SetFileSendListener(const char *pkgName, const char *sessionName, const IFileSendListener *sendListener)
656 {
657     if (!IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1) || !IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1) ||
658         sendListener == NULL) {
659         TRANS_LOGW(TRANS_SDK, "set file send listener invalid param");
660         return SOFTBUS_INVALID_PARAM;
661     }
662     if (InitSoftBus(pkgName) != SOFTBUS_OK) {
663         TRANS_LOGE(TRANS_SDK, "set file send listener init softbus client error");
664         return SOFTBUS_TRANS_SESSION_ADDPKG_FAILED;
665     }
666     char *tmpName = NULL;
667     Anonymize(sessionName, &tmpName);
668     TRANS_LOGI(TRANS_SDK, "sessionName=%{public}s", tmpName);
669     AnonymizeFree(tmpName);
670     return TransSetFileSendListener(sessionName, sendListener);
671 }
672 
673 static const char *g_busName = "DistributedFileService";
674 static const char *g_deviceStatusName = "ohos.msdp.device_status";
675 
IsValidDFSSession(int32_t sessionId,int32_t * channelId)676 static int32_t IsValidDFSSession(int32_t sessionId, int32_t *channelId)
677 {
678     char sessionName[SESSION_NAME_SIZE_MAX] = { 0 };
679     int32_t type;
680     int32_t ret = GetMySessionName(sessionId, sessionName, SESSION_NAME_SIZE_MAX);
681     if (ret != SOFTBUS_OK) {
682         TRANS_LOGE(TRANS_SDK, "get dfs session name failed");
683         return ret;
684     }
685     if (strncmp(sessionName, g_busName, strlen(g_busName)) != 0 &&
686         strncmp(sessionName, g_deviceStatusName, strlen(g_deviceStatusName)) != 0) {
687         TRANS_LOGE(TRANS_SDK, "invalid dfs session name");
688         return SOFTBUS_TRANS_FUNC_NOT_SUPPORT;
689     }
690 
691     ret = ClientGetChannelBySessionId(sessionId, channelId, &type, NULL);
692     if (ret != SOFTBUS_OK) {
693         TRANS_LOGE(TRANS_SDK, "get channel by sessionId=%{public}d failed, ret=%{public}d", sessionId, ret);
694         return SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED;
695     }
696     if (type != CHANNEL_TYPE_TCP_DIRECT) {
697         TRANS_LOGE(TRANS_SDK, "invalid channel type");
698         return SOFTBUS_TRANS_FUNC_NOT_SUPPORT;
699     }
700     return SOFTBUS_OK;
701 }
702 
GetSessionKey(int32_t sessionId,char * key,unsigned int len)703 int32_t GetSessionKey(int32_t sessionId, char *key, unsigned int len)
704 {
705     int32_t channelId;
706     if (!IsValidSessionId(sessionId) || key == NULL || len < SESSION_KEY_LEN) {
707         TRANS_LOGW(TRANS_SDK, "invalid param");
708         return SOFTBUS_INVALID_PARAM;
709     }
710     if (IsValidDFSSession(sessionId, &channelId) != SOFTBUS_OK) {
711         TRANS_LOGE(TRANS_SDK, "invalid dfs session");
712         return SOFTBUS_TRANS_FUNC_NOT_SUPPORT;
713     }
714     return ClientGetSessionKey(channelId, key, len);
715 }
716 
GetSessionHandle(int32_t sessionId,int * handle)717 int32_t GetSessionHandle(int32_t sessionId, int *handle)
718 {
719     int32_t channelId;
720     if (!IsValidSessionId(sessionId) || handle == NULL) {
721         TRANS_LOGW(TRANS_SDK, "invalid param");
722         return SOFTBUS_INVALID_PARAM;
723     }
724     if (IsValidDFSSession(sessionId, &channelId) != SOFTBUS_OK) {
725         TRANS_LOGE(TRANS_SDK, "invalid dfs session");
726         return SOFTBUS_TRANS_FUNC_NOT_SUPPORT;
727     }
728     return ClientGetHandle(channelId, handle);
729 }
730 
DisableSessionListener(int32_t sessionId)731 int32_t DisableSessionListener(int32_t sessionId)
732 {
733     int32_t channelId;
734     if (!IsValidSessionId(sessionId)) {
735         TRANS_LOGW(TRANS_SDK, "invalid param");
736         return SOFTBUS_INVALID_PARAM;
737     }
738     if (IsValidDFSSession(sessionId, &channelId) != SOFTBUS_OK) {
739         TRANS_LOGE(TRANS_SDK, "invalid dfs session");
740         return SOFTBUS_TRANS_FUNC_NOT_SUPPORT;
741     }
742     return ClientDisableSessionListener(channelId);
743 }
744 
QosReport(int32_t sessionId,int32_t appType,int32_t quality)745 int32_t QosReport(int32_t sessionId, int32_t appType, int32_t quality)
746 {
747     if (quality != QOS_IMPROVE && quality != QOS_RECOVER) {
748         TRANS_LOGW(TRANS_SDK, "qos report invalid param");
749         return SOFTBUS_INVALID_PARAM;
750     }
751 
752     int32_t channelId = INVALID_CHANNEL_ID;
753     int32_t type = CHANNEL_TYPE_BUTT;
754     int32_t ret = ClientGetChannelBySessionId(sessionId, &channelId, &type, NULL);
755     if (ret != SOFTBUS_OK) {
756         TRANS_LOGE(TRANS_SDK, "get channel by sessionId=%{public}d failed, ret=%{public}d.", sessionId, ret);
757         return SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED;
758     }
759     if (ClientGetSessionSide(sessionId) != IS_CLIENT) {
760         TRANS_LOGE(TRANS_SDK,
761             "qos report not exist or not client side. sessionId=%{public}d", sessionId);
762         return SOFTBUS_TRANS_INVALID_SESSION_ID;
763     }
764     ret = ClientQosReport(channelId, type, appType, quality);
765     if (ret != SOFTBUS_OK) {
766         TRANS_LOGE(TRANS_SDK, "qos report failed. sessionId=%{public}d, ret=%{public}d", sessionId, ret);
767     }
768     return ret;
769 }
770 
771 static const ConfigTypeMap g_configTypeMap[] = {
772     {CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BYTE, SOFTBUS_INT_AUTH_MAX_BYTES_LENGTH},
773     {CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, SOFTBUS_INT_AUTH_MAX_MESSAGE_LENGTH},
774     {CHANNEL_TYPE_PROXY, BUSINESS_TYPE_BYTE, SOFTBUS_INT_PROXY_MAX_BYTES_LENGTH},
775     {CHANNEL_TYPE_PROXY, BUSINESS_TYPE_MESSAGE, SOFTBUS_INT_PROXY_MAX_MESSAGE_LENGTH},
776     {CHANNEL_TYPE_TCP_DIRECT, BUSINESS_TYPE_BYTE, SOFTBUS_INT_MAX_BYTES_LENGTH},
777     {CHANNEL_TYPE_TCP_DIRECT, BUSINESS_TYPE_MESSAGE, SOFTBUS_INT_MAX_MESSAGE_LENGTH},
778 };
779 
GetDefaultConfigType(int32_t channelType,int32_t businessType)780 int32_t GetDefaultConfigType(int32_t channelType, int32_t businessType)
781 {
782     const uint32_t nums = sizeof(g_configTypeMap) / sizeof(ConfigTypeMap);
783     for (uint32_t i = 0; i < nums; i++) {
784         if ((g_configTypeMap[i].channelType == channelType) &&
785             (g_configTypeMap[i].businessType == businessType)) {
786                 return g_configTypeMap[i].configType;
787             }
788     }
789     return SOFTBUS_CONFIG_TYPE_MAX;
790 }
791 
ReadMaxSendBytesSize(int32_t channelId,int32_t type,void * value,uint32_t valueSize)792 int ReadMaxSendBytesSize(int32_t channelId, int32_t type, void* value, uint32_t valueSize)
793 {
794     if (valueSize != sizeof(uint32_t)) {
795         TRANS_LOGE(TRANS_SDK, "valueSize not match. valueSize=%{public}d", valueSize);
796         return SOFTBUS_INVALID_PARAM;
797     }
798 
799     uint32_t dataConfig = INVALID_DATA_CONFIG;
800     if (ClientGetDataConfigByChannelId(channelId, type, &dataConfig) != SOFTBUS_OK) {
801         TRANS_LOGE(TRANS_SDK, "get config failed.");
802         return SOFTBUS_GET_CONFIG_VAL_ERR;
803     }
804 
805     (*(uint32_t*)value) = dataConfig;
806     return SOFTBUS_OK;
807 }
808 
ReadMaxSendMessageSize(int32_t channelId,int32_t type,void * value,uint32_t valueSize)809 int ReadMaxSendMessageSize(int32_t channelId, int32_t type, void* value, uint32_t valueSize)
810 {
811     if (value == NULL) {
812         TRANS_LOGE(TRANS_SDK, "param invalid");
813         return SOFTBUS_INVALID_PARAM;
814     }
815     if (valueSize != sizeof(uint32_t)) {
816         TRANS_LOGE(TRANS_SDK, "valueSize not match. valueSize=%{public}d", valueSize);
817         return SOFTBUS_INVALID_PARAM;
818     }
819 
820     uint32_t dataConfig = INVALID_DATA_CONFIG;
821     if (ClientGetDataConfigByChannelId(channelId, type, &dataConfig) != SOFTBUS_OK) {
822         TRANS_LOGE(TRANS_SDK, "get config failed.");
823         return SOFTBUS_GET_CONFIG_VAL_ERR;
824     }
825 
826     (*(uint32_t*)value) = dataConfig;
827     return SOFTBUS_OK;
828 }
829 
ReadSessionLinkType(int32_t channelId,int32_t type,void * value,uint32_t valueSize)830 int ReadSessionLinkType(int32_t channelId, int32_t type, void* value, uint32_t valueSize)
831 {
832     if (value == NULL) {
833         TRANS_LOGE(TRANS_SDK, "param invalid");
834         return SOFTBUS_INVALID_PARAM;
835     }
836     if (valueSize != sizeof(uint32_t)) {
837         TRANS_LOGE(TRANS_SDK, "valueSize not match. valueSize=%{public}d", valueSize);
838         return SOFTBUS_INVALID_PARAM;
839     }
840 
841     int32_t routeType = INVALID_ROUTE_TYPE;
842     if (ClientGetRouteTypeByChannelId(channelId, type, &routeType) != SOFTBUS_OK) {
843         TRANS_LOGE(TRANS_SDK, "get link type failed.");
844         return SOFTBUS_GET_CONFIG_VAL_ERR;
845     }
846 
847     (*(int32_t*)value) = routeType;
848     return SOFTBUS_OK;
849 }
850 
851 static const SessionOptionItem g_SessionOptionArr[SESSION_OPTION_BUTT] = {
852     {true, ReadMaxSendBytesSize},
853     {true, ReadMaxSendMessageSize},
854     {true, ReadSessionLinkType},
855 };
856 
GetSessionOption(int sessionId,SessionOption option,void * optionValue,uint32_t valueSize)857 int GetSessionOption(int sessionId, SessionOption option, void* optionValue, uint32_t valueSize)
858 {
859     if ((option >= SESSION_OPTION_BUTT) || (optionValue == NULL) || (valueSize == 0)) {
860         TRANS_LOGW(TRANS_SDK, "invalid param");
861         return SOFTBUS_INVALID_PARAM;
862     }
863     if (!g_SessionOptionArr[option].canRead) {
864         TRANS_LOGE(TRANS_SDK, "option can not be get. option=%{public}d", option);
865         return SOFTBUS_INVALID_PARAM;
866     }
867 
868     int32_t channelId = INVALID_CHANNEL_ID;
869     int32_t type = CHANNEL_TYPE_BUTT;
870     int32_t ret = ClientGetChannelBySessionId(sessionId, &channelId, &type, NULL);
871     if (ret != SOFTBUS_OK) {
872         TRANS_LOGE(TRANS_SDK, "get channel by sessionId=%{public}d failed, ret=%{public}d.", sessionId, ret);
873         return SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED;
874     }
875 
876     return g_SessionOptionArr[option].readFunc(channelId, type, optionValue, valueSize);
877 }
878 
RemoveAppIdFromSessionName(const char * sessionName,char * newSessionName)879 bool RemoveAppIdFromSessionName(const char *sessionName, char *newSessionName)
880 {
881     if ((sessionName == NULL) || (newSessionName == NULL)) {
882         TRANS_LOGE(TRANS_SDK, "invalid param");
883         return false;
884     }
885     const char tag = '-';
886     const char *posName = strchr(sessionName, tag);
887     if (posName == NULL) {
888         TRANS_LOGE(TRANS_SDK, "sdk not find bundlename");
889         return false;
890     }
891     const char *posId = strchr(posName + 1, tag);
892     if (posId == NULL) {
893         TRANS_LOGE(TRANS_SDK, "sdk not find appid");
894         return false;
895     }
896     size_t len = posId - sessionName;
897     if (strncpy_s(newSessionName, SESSION_NAME_SIZE_MAX + 1, sessionName, len) != EOK) {
898         TRANS_LOGE(TRANS_SDK, "copy sessionName failed");
899         return false;
900     }
901     return true;
902 }
903 
CreateSocket(const char * pkgName,const char * sessionName)904 int CreateSocket(const char *pkgName, const char *sessionName)
905 {
906     if (!IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1) || !IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1)) {
907         TRANS_LOGE(TRANS_SDK, "invalid pkgName or sessionName");
908         return SOFTBUS_INVALID_PARAM;
909     }
910     if (InitSoftBus(pkgName) != SOFTBUS_OK) {
911         TRANS_LOGE(TRANS_SDK, "init softbus err");
912         return SOFTBUS_TRANS_SESSION_ADDPKG_FAILED;
913     }
914     if (CheckPackageName(pkgName) != SOFTBUS_OK) {
915         TRANS_LOGE(TRANS_SDK, "invalid pkg name");
916         return SOFTBUS_INVALID_PKGNAME;
917     }
918     char newSessionName[SESSION_NAME_SIZE_MAX + 1] = {0};
919     if (strncpy_s(newSessionName, SESSION_NAME_SIZE_MAX + 1, sessionName, strlen(sessionName)) != EOK) {
920         TRANS_LOGE(TRANS_SDK, "copy session name failed");
921         return SOFTBUS_STRCPY_ERR;
922     }
923     if (CheckIsNormalApp(sessionName)) {
924         if (!RemoveAppIdFromSessionName(sessionName, newSessionName)) {
925             TRANS_LOGE(TRANS_SDK, "invalid bundlename or appId and delete appId failed");
926             return SOFTBUS_TRANS_NOT_FIND_APPID;
927         }
928     }
929     int32_t ret = ClientAddSocketServer(SEC_TYPE_CIPHERTEXT, pkgName, (const char *)newSessionName);
930     if (ret == SOFTBUS_SERVER_NAME_REPEATED) {
931         TRANS_LOGD(TRANS_SDK, "SocketServer is already created in client");
932     } else if (ret != SOFTBUS_OK) {
933         TRANS_LOGE(TRANS_SDK, "add socket server err, ret=%{public}d", ret);
934         return ret;
935     }
936     ret = ServerIpcCreateSessionServer(pkgName, sessionName);
937     if (ret == SOFTBUS_SERVER_NAME_REPEATED) {
938         TRANS_LOGD(TRANS_SDK, "ok, SocketServer is already created in server");
939         return SOFTBUS_OK;
940     } else if (ret != SOFTBUS_OK) {
941         SocketServerStateUpdate(newSessionName);
942         TRANS_LOGE(TRANS_SDK, "createSocketServer failed, ret=%{public}d", ret);
943         (void)ClientDeleteSessionServer(SEC_TYPE_CIPHERTEXT, newSessionName);
944         return ret;
945     }
946     TRANS_LOGD(TRANS_SDK, "ok");
947     return SOFTBUS_OK;
948 }
949 
CreateSessionAttributeBySocketInfoTrans(const SocketInfo * info,bool * isEncyptedRawStream)950 static SessionAttribute *CreateSessionAttributeBySocketInfoTrans(const SocketInfo *info, bool *isEncyptedRawStream)
951 {
952     SessionAttribute *tmpAttr = (SessionAttribute *)SoftBusCalloc(sizeof(SessionAttribute));
953     if (tmpAttr == NULL) {
954         TRANS_LOGE(TRANS_SDK, "SoftBusCalloc SessionAttribute failed");
955         return NULL;
956     }
957 
958     *isEncyptedRawStream = false;
959     tmpAttr->fastTransData = NULL;
960     tmpAttr->fastTransDataSize = 0;
961     switch (info->dataType) {
962         case DATA_TYPE_MESSAGE:
963             tmpAttr->dataType = TYPE_MESSAGE;
964             break;
965         case DATA_TYPE_BYTES:
966             tmpAttr->dataType = TYPE_BYTES;
967             break;
968         case DATA_TYPE_FILE:
969             tmpAttr->dataType = TYPE_FILE;
970             break;
971         case DATA_TYPE_RAW_STREAM:
972         case DATA_TYPE_RAW_STREAM_ENCRYPED:
973             tmpAttr->dataType = TYPE_STREAM;
974             tmpAttr->attr.streamAttr.streamType = RAW_STREAM;
975             *isEncyptedRawStream = (info->dataType == DATA_TYPE_RAW_STREAM_ENCRYPED);
976             break;
977         case DATA_TYPE_VIDEO_STREAM:
978             tmpAttr->dataType = TYPE_STREAM;
979             tmpAttr->attr.streamAttr.streamType = COMMON_VIDEO_STREAM;
980             break;
981         case DATA_TYPE_AUDIO_STREAM:
982             tmpAttr->dataType = TYPE_STREAM;
983             tmpAttr->attr.streamAttr.streamType = COMMON_AUDIO_STREAM;
984             break;
985         case DATA_TYPE_SLICE_STREAM:
986             tmpAttr->dataType = TYPE_STREAM;
987             tmpAttr->attr.streamAttr.streamType = VIDEO_SLICE_STREAM;
988             break;
989         default:
990             // The socket used for listening does not require setting the data type
991             break;
992     }
993     return tmpAttr;
994 }
995 
ClientAddSocket(const SocketInfo * info,int32_t * sessionId)996 int32_t ClientAddSocket(const SocketInfo *info, int32_t *sessionId)
997 {
998     if (info == NULL || sessionId == NULL) {
999         TRANS_LOGE(TRANS_SDK, "ClientAddSocket invalid param");
1000         return SOFTBUS_INVALID_PARAM;
1001     }
1002 
1003     bool isEncyptedRawStream = false;
1004     SessionAttribute *tmpAttr = CreateSessionAttributeBySocketInfoTrans(info, &isEncyptedRawStream);
1005     if (tmpAttr == NULL) {
1006         TRANS_LOGE(TRANS_SDK, "Create SessionAttribute failed");
1007         return SOFTBUS_MALLOC_ERR;
1008     }
1009 
1010     SessionParam param = {
1011         .sessionName = info->name != NULL ? info->name : "",
1012         .peerSessionName = info->peerName != NULL ? info->peerName : "",
1013         .peerDeviceId = info->peerNetworkId != NULL ? info->peerNetworkId : "",
1014         .groupId = "reserved",
1015         .actionId = INVALID_ACTION_ID,
1016         .attr = tmpAttr,
1017     };
1018 
1019     SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
1020     int32_t ret = ClientAddSocketSession(&param, isEncyptedRawStream, sessionId, &isEnabled);
1021     if (ret != SOFTBUS_OK) {
1022         SoftBusFree(tmpAttr);
1023         if (ret == SOFTBUS_TRANS_SESSION_REPEATED) {
1024             TRANS_LOGI(TRANS_SDK, "socket already create");
1025             return SOFTBUS_OK;
1026         }
1027         TRANS_LOGE(TRANS_SDK, "add socket err: ret=%{public}d", ret);
1028         return ret;
1029     }
1030     SoftBusFree(tmpAttr);
1031     return SOFTBUS_OK;
1032 }
1033 
IsValidSocketListener(const ISocketListener * listener,bool isListenSocket)1034 static bool IsValidSocketListener(const ISocketListener *listener, bool isListenSocket)
1035 {
1036     if (listener == NULL || listener->OnShutdown == NULL) {
1037         TRANS_LOGE(TRANS_SDK, "listener is null or OnShutdown is null");
1038         return false;
1039     }
1040 
1041     if (isListenSocket && listener->OnBind == NULL) {
1042         TRANS_LOGE(TRANS_SDK, "no OnBind callback function of listen socket");
1043         return false;
1044     }
1045 
1046     return true;
1047 }
1048 
IsValidAsyncBindSocketListener(const ISocketListener * listener,bool isAsync)1049 static bool IsValidAsyncBindSocketListener(const ISocketListener *listener, bool isAsync)
1050 {
1051     if (isAsync && (listener->OnBind == NULL)) {
1052         TRANS_LOGE(TRANS_SDK, "no OnBind callback function of async bind");
1053         return false;
1054     }
1055     if (isAsync && (listener->OnError == NULL)) {
1056         TRANS_LOGE(TRANS_SDK, "no onError callback function of async bind");
1057         return false;
1058     }
1059     return true;
1060 }
1061 
GetMaxIdleTimeout(const QosTV * qos,uint32_t qosCount,uint32_t * maxIdleTimeout)1062 static int32_t GetMaxIdleTimeout(const QosTV *qos, uint32_t qosCount, uint32_t *maxIdleTimeout)
1063 {
1064 #define TRANS_DEFAULT_MAX_IDLE_TIMEOUT 0
1065     int32_t tmpIdleTime = 0;
1066     int32_t ret = GetQosValue(qos, qosCount, QOS_TYPE_MAX_IDLE_TIMEOUT, &tmpIdleTime, TRANS_DEFAULT_MAX_IDLE_TIMEOUT);
1067     if (ret != SOFTBUS_OK) {
1068         TRANS_LOGE(TRANS_SDK, "get maximum idle time failed, ret=%{public}d", ret);
1069         return ret;
1070     }
1071 
1072     if (tmpIdleTime < 0) {
1073         TRANS_LOGE(TRANS_SDK, "invalid maximum idle time, maxIdleTimeout=%{public}d", tmpIdleTime);
1074         return SOFTBUS_INVALID_PARAM;
1075     }
1076 
1077     *maxIdleTimeout = (uint32_t)tmpIdleTime;
1078     return SOFTBUS_OK;
1079 }
1080 
CheckSessionCancelState(int32_t socket)1081 static int32_t CheckSessionCancelState(int32_t socket)
1082 {
1083     SocketLifecycleData lifecycle;
1084     (void)memset_s(&lifecycle, sizeof(SocketLifecycleData), 0, sizeof(SocketLifecycleData));
1085     int32_t ret = GetSocketLifecycleAndSessionNameBySessionId(socket, NULL, &lifecycle);
1086     if (ret != SOFTBUS_OK) {
1087         TRANS_LOGE(TRANS_SDK, "get socket state failed, socket=%{public}d failed, ret=%{public}d", socket, ret);
1088         return ret;
1089     }
1090     if (lifecycle.sessionState == SESSION_STATE_CANCELLING) {
1091         TRANS_LOGW(TRANS_SDK, "This socket already in cancelling state. socket=%{public}d", socket);
1092         int32_t channelId = INVALID_CHANNEL_ID;
1093         int32_t type = CHANNEL_TYPE_BUTT;
1094         ret = ClientGetChannelBySessionId(socket, &channelId, &type, NULL);
1095         if (ret != SOFTBUS_OK) {
1096             TRANS_LOGE(TRANS_SDK, "get channel by socket=%{public}d failed, ret=%{public}d", socket, ret);
1097         }
1098         ret = ClientTransCloseChannel(channelId, type);
1099         if (ret != SOFTBUS_OK) {
1100             TRANS_LOGE(TRANS_SDK, "close channel err: ret=%{public}d, channelId=%{public}d, channeType=%{public}d", ret,
1101                 channelId, type);
1102         }
1103         return lifecycle.bindErrCode;
1104     }
1105     return SOFTBUS_OK;
1106 }
1107 
ClientBind(int32_t socket,const QosTV qos[],uint32_t qosCount,const ISocketListener * listener,bool isAsync)1108 int32_t ClientBind(int32_t socket, const QosTV qos[], uint32_t qosCount, const ISocketListener *listener, bool isAsync)
1109 {
1110     if (!IsValidSessionId(socket) || !IsValidSocketListener(listener, false) ||
1111         !IsValidAsyncBindSocketListener(listener, isAsync) || !IsValidQosInfo(qos, qosCount)) {
1112         TRANS_LOGE(TRANS_SDK, "invalid param");
1113         return SOFTBUS_INVALID_PARAM;
1114     }
1115 
1116     // For rebind, clear the socket state.
1117     int32_t ret = ClientSetSocketState(socket, 0, SESSION_ROLE_INIT);
1118     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SDK, "init session role failed, ret=%{public}d", ret);
1119     ret = SetSessionStateBySessionId(socket, SESSION_STATE_INIT, 0);
1120     TRANS_CHECK_AND_RETURN_RET_LOGE(
1121         ret == SOFTBUS_OK, ret, TRANS_SDK, "init session state failed, ret=%{public}d", ret);
1122 
1123     ret = ClientSetListenerBySessionId(socket, listener, false);
1124     TRANS_CHECK_AND_RETURN_RET_LOGE(
1125         ret == SOFTBUS_OK, ret, TRANS_SDK, "set listener by socket=%{public}d failed, ret=%{public}d", socket, ret);
1126 
1127     uint32_t maxIdleTimeout = 0;
1128     ret = GetMaxIdleTimeout(qos, qosCount, &maxIdleTimeout);
1129     TRANS_CHECK_AND_RETURN_RET_LOGE(
1130         ret == SOFTBUS_OK, ret, TRANS_SDK, "get maximum idle time failed, ret=%{public}d", ret);
1131 
1132     ret = SetSessionIsAsyncById(socket, isAsync);
1133     TRANS_CHECK_AND_RETURN_RET_LOGE(
1134         ret == SOFTBUS_OK, ret, TRANS_SDK, "set session is async failed, ret=%{public}d", ret);
1135 
1136     TransInfo transInfo;
1137     ret = ClientIpcOpenSession(socket, qos, qosCount, &transInfo, isAsync);
1138     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SDK, "open session failed, ret=%{public}d", ret);
1139 
1140     if (!isAsync) {
1141         ret = CheckSessionCancelState(socket);
1142         TRANS_CHECK_AND_RETURN_RET_LOGE(
1143             ret == SOFTBUS_OK, ret, TRANS_SDK, "check session cancel state failed, ret=%{public}d", ret);
1144         ret = ClientWaitSyncBind(socket);
1145         TRANS_CHECK_AND_RETURN_RET_LOGE(
1146             ret == SOFTBUS_OK, ret, TRANS_SDK, "ClientWaitSyncBind err, ret=%{public}d", ret);
1147     }
1148     ret = ClientSetSocketState(socket, maxIdleTimeout, SESSION_ROLE_CLIENT);
1149     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SDK, "set session role failed, ret=%{public}d", ret);
1150 
1151     if (!isAsync) {
1152         (void)ClientGetChannelBySessionId(socket, &(transInfo.channelId), &(transInfo.channelType), NULL);
1153         TRANS_LOGI(TRANS_SDK, "Bind ok: socket=%{public}d, channelId=%{public}d, channelType=%{public}d", socket,
1154             transInfo.channelId, transInfo.channelType);
1155     } else {
1156         TRANS_LOGI(TRANS_SDK, "Bind async ok: socket=%{public}d", socket);
1157     }
1158     return SOFTBUS_OK;
1159 }
1160 
ClientListen(int32_t socket,const QosTV qos[],uint32_t qosCount,const ISocketListener * listener)1161 int32_t ClientListen(int32_t socket, const QosTV qos[], uint32_t qosCount, const ISocketListener *listener)
1162 {
1163     if (!IsValidSocketListener(listener, true) || !IsValidQosInfo(qos, qosCount)) {
1164         TRANS_LOGE(TRANS_SDK, "invalid param");
1165         return SOFTBUS_INVALID_PARAM;
1166     }
1167 
1168     int32_t ret = ClientSetListenerBySessionId(socket, listener, true);
1169     if (ret != SOFTBUS_OK) {
1170         TRANS_LOGE(TRANS_SDK, "set listener by socket=%{public}d failed. ret=%{public}d", socket, ret);
1171         return ret;
1172     }
1173 
1174     uint32_t maxIdleTimeout = 0;
1175     ret = GetMaxIdleTimeout(qos, qosCount, &maxIdleTimeout);
1176     if (ret != SOFTBUS_OK) {
1177         TRANS_LOGE(TRANS_SDK, "get maximum idle time failed, ret=%{public}d", ret);
1178         return ret;
1179     }
1180 
1181     ret = ClientSetSocketState(socket, maxIdleTimeout, SESSION_ROLE_SERVER);
1182     if (ret != SOFTBUS_OK) {
1183         TRANS_LOGE(TRANS_SDK, "set session role failed. ret=%{public}d", ret);
1184         return ret;
1185     }
1186 
1187     TRANS_LOGD(TRANS_SDK, "Listen ok: socket=%{public}d", socket);
1188     return SOFTBUS_OK;
1189 }
1190 
ClientShutdown(int32_t socket,int32_t cancelReason)1191 void ClientShutdown(int32_t socket, int32_t cancelReason)
1192 {
1193     if (!IsValidSessionId(socket)) {
1194         TRANS_LOGE(TRANS_SDK, "invalid param");
1195         return;
1196     }
1197 
1198     SocketLifecycleData lifecycle;
1199     (void)memset_s(&lifecycle, sizeof(SocketLifecycleData), 0, sizeof(SocketLifecycleData));
1200     char sessioName[SESSION_NAME_SIZE_MAX] = { 0 };
1201     int32_t ret = GetSocketLifecycleAndSessionNameBySessionId(socket, sessioName, &lifecycle);
1202     if (ret != SOFTBUS_OK) {
1203         TRANS_LOGE(TRANS_SDK, "get socket state failed, socket=%{public}d failed, ret=%{public}d", socket, ret);
1204         return;
1205     }
1206     if (lifecycle.sessionState == SESSION_STATE_CANCELLING) {
1207         TRANS_LOGW(TRANS_SDK, "This socket already in cancelling state. socket=%{public}d", socket);
1208     }
1209     SetSessionStateBySessionId(socket, SESSION_STATE_CANCELLING, cancelReason);
1210     if (lifecycle.sessionState == SESSION_STATE_INIT) {
1211         TRANS_LOGI(TRANS_SDK, "This socket state is init, socket=%{public}d", socket);
1212     } else if (lifecycle.sessionState == SESSION_STATE_OPENING) {
1213         TRANS_LOGI(TRANS_SDK, "This socket state is opening, socket=%{public}d", socket);
1214         int32_t ret = ServerIpcCloseChannel(sessioName, socket, CHANNEL_TYPE_UNDEFINED);
1215         if (ret != SOFTBUS_OK) {
1216             TRANS_LOGE(TRANS_SDK, "Call sa delete socket failed: ret=%{public}d", ret);
1217         }
1218         ret = ClientSignalSyncBind(socket, 0);
1219         if (ret != SOFTBUS_OK) {
1220             TRANS_LOGE(TRANS_SDK, "sync signal bind failed, ret=%{public}d, socket=%{public}d", ret, socket);
1221         }
1222     } else if (lifecycle.sessionState == SESSION_STATE_OPENED ||
1223         lifecycle.sessionState == SESSION_STATE_CALLBACK_FINISHED) {
1224         if (lifecycle.sessionState == SESSION_STATE_OPENED) {
1225             TRANS_LOGI(TRANS_SDK, "This socket state is opened, socket=%{public}d", socket);
1226             CheckSessionIsOpened(socket, true);
1227         }
1228         TRANS_LOGI(TRANS_SDK, "This socket state is callback finish, socket=%{public}d", socket);
1229         int32_t channelId = INVALID_CHANNEL_ID;
1230         int32_t type = CHANNEL_TYPE_BUTT;
1231         ret = ClientGetChannelBySessionId(socket, &channelId, &type, NULL);
1232         if (ret != SOFTBUS_OK) {
1233             TRANS_LOGE(TRANS_SDK, "get channel by socket=%{public}d failed, ret=%{public}d", socket, ret);
1234         } else {
1235             AddSessionStateClosing();
1236         }
1237         ret = ClientTransCloseChannel(channelId, type);
1238         if (ret != SOFTBUS_OK) {
1239             TRANS_LOGE(TRANS_SDK, "close channel err: ret=%{public}d, channelId=%{public}d, channeType=%{public}d", ret,
1240                 channelId, type);
1241         }
1242         if (lifecycle.sessionState == SESSION_STATE_OPENED) {
1243             (void)ClientSignalSyncBind(socket, cancelReason);
1244         }
1245     }
1246     if (cancelReason == SOFTBUS_TRANS_STOP_BIND_BY_TIMEOUT) {
1247         SetSessionInitInfoById(socket);
1248         TRANS_LOGI(TRANS_SDK, "Bind timeout Shutdown ok, no delete socket: socket=%{public}d", socket);
1249         return;
1250     }
1251     (void)ClientDeleteSocketSession(socket);
1252 
1253     TRANS_LOGI(TRANS_SDK, "Shutdown ok: socket=%{public}d", socket);
1254 }
1255 
GetSocketMtuSize(int32_t socket,uint32_t * mtuSize)1256 int32_t GetSocketMtuSize(int32_t socket, uint32_t *mtuSize)
1257 {
1258     if (!IsValidSessionId(socket) || mtuSize == NULL) {
1259         TRANS_LOGE(TRANS_SDK, "invalid param");
1260         return SOFTBUS_INVALID_PARAM;
1261     }
1262 
1263     int32_t channelId = INVALID_CHANNEL_ID;
1264     int32_t type = CHANNEL_TYPE_BUTT;
1265     SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
1266     int32_t ret = ClientGetChannelBySessionId(socket, &channelId, &type, &enableStatus);
1267     if (ret != SOFTBUS_OK) {
1268         TRANS_LOGE(TRANS_SDK, "get channel by socket=%{public}d failed, ret=%{public}d.", socket, ret);
1269         return ret;
1270     }
1271 
1272     if (enableStatus != ENABLE_STATUS_SUCCESS) {
1273         TRANS_LOGI(TRANS_SDK, "socket not enable");
1274         return SOFTBUS_TRANS_SESSION_NO_ENABLE;
1275     }
1276 
1277     uint32_t dataConfig = INVALID_DATA_CONFIG;
1278     if (ClientGetDataConfigByChannelId(channelId, type, &dataConfig) != SOFTBUS_OK) {
1279         TRANS_LOGE(TRANS_SDK, "get config by channelId=%{public}d failed", channelId);
1280         return SOFTBUS_GET_CONFIG_VAL_ERR;
1281     }
1282 
1283     *mtuSize = dataConfig;
1284     TRANS_LOGI(TRANS_SDK, "get mtuSize success, socket=%{public}d, mtu=%{public}" PRIu32, socket, *mtuSize);
1285     return SOFTBUS_OK;
1286 }
1287 
ClientDfsBind(int32_t socket,const ISocketListener * listener)1288 int32_t ClientDfsBind(int32_t socket, const ISocketListener *listener)
1289 {
1290     if (!IsValidSessionId(socket) || !IsValidSocketListener(listener, false)) {
1291         TRANS_LOGE(TRANS_SDK, "invalid param");
1292         return SOFTBUS_INVALID_PARAM;
1293     }
1294 
1295     int32_t ret = ClientSetListenerBySessionId(socket, listener, false);
1296     if (ret != SOFTBUS_OK) {
1297         TRANS_LOGE(TRANS_SDK, "set listener by socket=%{public}d failed, ret=%{public}d", socket, ret);
1298         return ret;
1299     }
1300 
1301     ret = SetSessionIsAsyncById(socket, false);
1302     TRANS_CHECK_AND_RETURN_RET_LOGE(
1303         ret == SOFTBUS_OK, ret, TRANS_SDK, "set session is async failed, ret=%{public}d", ret);
1304     TransInfo transInfo;
1305     ret = ClientDfsIpcOpenSession(socket, &transInfo);
1306     if (ret != SOFTBUS_OK) {
1307         TRANS_LOGE(TRANS_SDK, "open session failed, ret=%{public}d", ret);
1308         return ret;
1309     }
1310 
1311     ret = ClientSetChannelBySessionId(socket, &transInfo);
1312     TRANS_CHECK_AND_RETURN_RET_LOGE(
1313         ret == SOFTBUS_OK, ret, TRANS_SDK, "set channel by socket=%{public}d failed, ret=%{public}d", socket, ret);
1314     ret = SetSessionStateBySessionId(socket, SESSION_STATE_OPENED, 0);
1315     TRANS_CHECK_AND_RETURN_RET_LOGE(
1316         ret == SOFTBUS_OK, ret, TRANS_SDK, "set session state failed socket=%{public}d, ret=%{public}d", socket, ret);
1317     ret = ClientWaitSyncBind(socket);
1318     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SDK, "ClientWaitSyncBind err, ret=%{public}d", ret);
1319 
1320     ret = ClientSetSocketState(socket, 0, SESSION_ROLE_CLIENT);
1321     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SDK, "set session role failed, ret=%{public}d", ret);
1322     TRANS_LOGI(TRANS_SDK, "DfsBind ok: socket=%{public}d, channelId=%{public}d, channelType=%{public}d", socket,
1323         transInfo.channelId, transInfo.channelType);
1324     return SOFTBUS_OK;
1325 }
1326