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