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_callback.h"
17 
18 #include <securec.h>
19 #include <unistd.h>
20 
21 #include "anonymizer.h"
22 #include "client_trans_proxy_manager.h"
23 #include "client_trans_session_manager.h"
24 #include "client_trans_socket_manager.h"
25 #include "client_trans_udp_manager.h"
26 #include "softbus_adapter_mem.h"
27 #include "softbus_def.h"
28 #include "softbus_errcode.h"
29 #include "trans_log.h"
30 
31 #define RETRY_GET_INFO_TIMES_MS 300
32 
33 static IClientSessionCallBack g_sessionCb;
34 
AcceptSessionAsServer(const char * sessionName,const ChannelInfo * channel,uint32_t flag,int32_t * sessionId)35 static int32_t AcceptSessionAsServer(const char *sessionName, const ChannelInfo *channel, uint32_t flag,
36     int32_t *sessionId)
37 {
38     TRANS_LOGD(TRANS_SDK, "enter.");
39     SessionInfo *session = (SessionInfo *)SoftBusCalloc(sizeof(SessionInfo));
40     if (session == NULL) {
41         TRANS_LOGE(TRANS_SDK, "malloc failed");
42         return SOFTBUS_MALLOC_ERR;
43     }
44 
45     session->channelId = channel->channelId;
46     session->channelType = (ChannelType)channel->channelType;
47     session->peerPid = channel->peerPid;
48     session->peerUid = channel->peerUid;
49     session->isServer = channel->isServer;
50     session->enableStatus = ENABLE_STATUS_SUCCESS;
51     session->info.flag = (int32_t)flag;
52     session->isEncrypt = channel->isEncrypt;
53     session->businessType = channel->businessType;
54     session->routeType = channel->routeType;
55     session->fileEncrypt = channel->fileEncrypt;
56     session->algorithm = channel->algorithm;
57     session->crc = channel->crc;
58     session->dataConfig = channel->dataConfig;
59     session->isAsync = false;
60     session->osType = channel->osType;
61     session->lifecycle.sessionState = SESSION_STATE_CALLBACK_FINISHED;
62     if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, channel->peerSessionName) != EOK ||
63         strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, channel->peerDeviceId) != EOK ||
64         strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, channel->groupId) != EOK) {
65         TRANS_LOGE(TRANS_SDK, "client or peer session name, device id, group id failed");
66         SoftBusFree(session);
67         return SOFTBUS_STRCPY_ERR;
68     }
69 
70     int32_t ret = ClientAddNewSession(sessionName, session);
71     if (ret != SOFTBUS_OK) {
72         TRANS_LOGE(TRANS_SDK, "client add session failed, ret=%{public}d", ret);
73         SoftBusFree(session);
74         return ret;
75     }
76     *sessionId = session->sessionId;
77     TRANS_LOGD(TRANS_SDK, "ok");
78     return SOFTBUS_OK;
79 }
80 
GetSessionCallbackByChannelId(int32_t channelId,int32_t channelType,int32_t * sessionId,ISessionListener * listener)81 static int32_t GetSessionCallbackByChannelId(int32_t channelId, int32_t channelType,
82     int32_t *sessionId, ISessionListener *listener)
83 {
84     if ((channelId < 0) || (sessionId == NULL) || (listener == NULL)) {
85         TRANS_LOGW(TRANS_SDK, "Invalid param");
86         return SOFTBUS_INVALID_PARAM;
87     }
88     int32_t ret = ClientGetSessionIdByChannelId(channelId, channelType, sessionId);
89     if (ret != SOFTBUS_OK) {
90         TRANS_LOGE(TRANS_SDK, "get sessionId failed, channelId=%{public}d, ret=%{public}d", channelId, ret);
91         return ret;
92     }
93     ret = ClientGetSessionCallbackById(*sessionId, listener);
94     if (ret != SOFTBUS_OK) {
95         TRANS_LOGE(TRANS_SDK, "get session listener failed, ret=%{public}d", ret);
96         return ret;
97     }
98     return SOFTBUS_OK;
99 }
100 
GetSocketCallbackAdapterByChannelId(int32_t channelId,int32_t channelType,int32_t * sessionId,SessionListenerAdapter * sessionCallback,bool * isServer)101 static int32_t GetSocketCallbackAdapterByChannelId(int32_t channelId, int32_t channelType, int32_t *sessionId,
102     SessionListenerAdapter *sessionCallback, bool *isServer)
103 {
104     if ((channelId < 0) || (sessionId == NULL) || (sessionCallback == NULL)) {
105         TRANS_LOGE(TRANS_SDK, "Invalid param");
106         return SOFTBUS_INVALID_PARAM;
107     }
108 
109     int32_t ret = ClientGetSessionIdByChannelId(channelId, channelType, sessionId);
110     if (ret != SOFTBUS_OK) {
111         TRANS_LOGE(TRANS_SDK, "get sessionId failed, channelId=%{public}d, ret=%{public}d", channelId, ret);
112         return ret;
113     }
114     ret = ClientGetSessionCallbackAdapterById(*sessionId, sessionCallback, isServer);
115     if (ret != SOFTBUS_OK) {
116         TRANS_LOGE(TRANS_SDK, "get socket callback failed, ret=%{public}d", ret);
117         return ret;
118     }
119     return SOFTBUS_OK;
120 }
121 
TransOnBindSuccess(int32_t sessionId,const ISocketListener * socketCallback)122 NO_SANITIZE("cfi") static int32_t TransOnBindSuccess(int32_t sessionId, const ISocketListener *socketCallback)
123 {
124     if (socketCallback == NULL || socketCallback->OnBind == NULL) {
125         TRANS_LOGE(TRANS_SDK, "Invalid OnBind callback function");
126         return SOFTBUS_INVALID_PARAM;
127     }
128 
129     PeerSocketInfo info;
130     int32_t ret = ClientGetPeerSocketInfoById(sessionId, &info);
131     if (ret != SOFTBUS_OK) {
132         TRANS_LOGE(TRANS_SDK, "Get peer socket info failed, ret=%{public}d", ret);
133         return ret;
134     }
135 
136     (void)socketCallback->OnBind(sessionId, info);
137     return SOFTBUS_OK;
138 }
139 
140 NO_SANITIZE("cfi")
TransOnBindFailed(int32_t sessionId,const ISocketListener * socketCallback,int32_t errCode)141 static int32_t TransOnBindFailed(int32_t sessionId, const ISocketListener *socketCallback, int32_t errCode)
142 {
143     (void)ClientHandleBindWaitTimer(sessionId, 0, TIMER_ACTION_STOP);
144     bool isAsync = true;
145     int32_t ret = ClientGetSessionIsAsyncBySessionId(sessionId, &isAsync);
146     if (ret != SOFTBUS_OK) {
147         TRANS_LOGE(TRANS_SDK, "get is async type failed, sessionId=%{public}d, ret=%{public}d", sessionId, ret);
148         return ret;
149     }
150     if (!isAsync) {
151         (void)ClientSignalSyncBind(sessionId, errCode);
152         return SOFTBUS_OK;
153     }
154     if (socketCallback == NULL || socketCallback->OnError == NULL) {
155         TRANS_LOGE(TRANS_SDK, "Invalid OnBind callback function");
156         return SOFTBUS_INVALID_PARAM;
157     }
158 
159     SocketLifecycleData lifecycle;
160     (void)memset_s(&lifecycle, sizeof(SocketLifecycleData), 0, sizeof(SocketLifecycleData));
161     ret = GetSocketLifecycleAndSessionNameBySessionId(sessionId, NULL, &lifecycle);
162     (void)SetSessionStateBySessionId(sessionId, SESSION_STATE_INIT, 0);
163     if (ret == SOFTBUS_OK && lifecycle.sessionState == SESSION_STATE_CANCELLING) {
164         TRANS_LOGW(TRANS_SDK, "socket is cancelling, no need call back, socket=%{public}d, bindErrCode=%{public}d",
165             sessionId, lifecycle.bindErrCode);
166         return lifecycle.bindErrCode;
167     }
168 
169     (void)socketCallback->OnError(sessionId, errCode);
170     TRANS_LOGI(TRANS_SDK, "OnError success, client socket=%{public}d", sessionId);
171     return SOFTBUS_OK;
172 }
173 
HandleAsyncBindSuccess(int32_t sessionId,const ISocketListener * socketClient,const SocketLifecycleData * lifecycle)174 static int32_t HandleAsyncBindSuccess(
175     int32_t sessionId, const ISocketListener *socketClient, const SocketLifecycleData *lifecycle)
176 {
177     int32_t ret = ClientHandleBindWaitTimer(sessionId, 0, TIMER_ACTION_STOP);
178     if (ret != SOFTBUS_OK) {
179         TRANS_LOGE(TRANS_SDK, "stop bind wait timer failed, ret=%{public}d", ret);
180         return ret;
181     }
182     if (lifecycle->sessionState == SESSION_STATE_CANCELLING) {
183         TRANS_LOGW(TRANS_SDK, "session is cancelling, no need call back");
184         return SOFTBUS_OK;
185     }
186     ret = SetSessionStateBySessionId(sessionId, SESSION_STATE_CALLBACK_FINISHED, 0);
187     if (ret != SOFTBUS_OK) {
188         TRANS_LOGE(TRANS_SDK, "set session state failed, ret=%{public}d", ret);
189         return ret;
190     }
191 
192     return TransOnBindSuccess(sessionId, socketClient);
193 }
194 
TransOnNegotiate(int32_t socket,const ISocketListener * socketCallback)195 NO_SANITIZE("cfi") static int32_t TransOnNegotiate(int32_t socket, const ISocketListener *socketCallback)
196 {
197     if (socketCallback == NULL) {
198         TRANS_LOGE(TRANS_SDK, "Invalid socketCallback socket=%{public}d", socket);
199         return SOFTBUS_INVALID_PARAM;
200     }
201 
202     if (socketCallback->OnNegotiate == NULL) {
203         TRANS_LOGW(TRANS_SDK, "no OnNegotiate callback function socket=%{public}d", socket);
204         return SOFTBUS_OK;
205     }
206 
207     PeerSocketInfo info = {0};
208     int32_t ret = ClientGetPeerSocketInfoById(socket, &info);
209     if (ret != SOFTBUS_OK) {
210         TRANS_LOGE(TRANS_SDK, "Get peer socket info failed, ret=%{public}d, socket=%{public}d", ret, socket);
211         return ret;
212     }
213 
214     if (!socketCallback->OnNegotiate(socket, info)) {
215         TRANS_LOGW(TRANS_SDK, "The negotiate rejected the socket=%{public}d", socket);
216         return SOFTBUS_TRANS_NEGOTIATE_REJECTED;
217     }
218 
219     return SOFTBUS_OK;
220 }
221 
HandleServerOnNegotiate(int32_t socket,const ISocketListener * socketServer)222 static int32_t HandleServerOnNegotiate(int32_t socket, const ISocketListener *socketServer)
223 {
224     int32_t ret = TransOnNegotiate(socket, socketServer);
225     if (ret != SOFTBUS_OK) {
226         TRANS_LOGE(TRANS_SDK, "OnBind failed, ret=%{public}d", ret);
227         (void)ClientDeleteSocketSession(socket);
228         return ret;
229     }
230     return SOFTBUS_OK;
231 }
232 
HandleSyncBindSuccess(int32_t sessionId,const SocketLifecycleData * lifecycle)233 static int32_t HandleSyncBindSuccess(int32_t sessionId, const SocketLifecycleData *lifecycle)
234 {
235     if (lifecycle->sessionState == SESSION_STATE_CANCELLING) {
236         TRANS_LOGW(
237             TRANS_SDK, "socket=%{public}d is cancelling, bindErrCode=%{public}d", sessionId, lifecycle->bindErrCode);
238         return SOFTBUS_OK;
239     }
240 
241     int32_t ret = ClientSignalSyncBind(sessionId, 0);
242     if (ret != SOFTBUS_OK) {
243         TRANS_LOGE(TRANS_SDK, "sync signal bind failed, ret=%{public}d, socket=%{public}d", ret, sessionId);
244         return ret;
245     }
246 
247     (void)SetSessionStateBySessionId(sessionId, SESSION_STATE_CALLBACK_FINISHED, 0);
248     return SOFTBUS_OK;
249 }
250 
HandleOnBindSuccess(int32_t sessionId,SessionListenerAdapter sessionCallback,bool isServer)251 static int32_t HandleOnBindSuccess(int32_t sessionId, SessionListenerAdapter sessionCallback, bool isServer)
252 {
253     // async bind call back client and server， sync bind only call back server.
254     bool isAsync = true;
255     int32_t ret = ClientGetSessionIsAsyncBySessionId(sessionId, &isAsync);
256     if (ret != SOFTBUS_OK) {
257         TRANS_LOGE(TRANS_SDK, "Get is async type failed");
258         return ret;
259     }
260 
261     SocketLifecycleData lifecycle;
262     (void)memset_s(&lifecycle, sizeof(SocketLifecycleData), 0, sizeof(SocketLifecycleData));
263     ret = GetSocketLifecycleAndSessionNameBySessionId(sessionId, NULL, &lifecycle);
264     if (ret != SOFTBUS_OK) {
265         TRANS_LOGE(TRANS_SDK, "Get session lifecycle failed, ret=%{public}d", ret);
266         return ret;
267     }
268 
269     if (isServer) {
270         return HandleServerOnNegotiate(sessionId, &sessionCallback.socketServer);
271     } else if (isAsync) {
272         return HandleAsyncBindSuccess(sessionId, &sessionCallback.socketClient, &lifecycle);
273     } else { // sync bind
274         return HandleSyncBindSuccess(sessionId, &lifecycle);
275     }
276 
277     return SOFTBUS_OK;
278 }
279 
AnonymizeLogTransOnSessionOpenedInfo(const char * sessionName,const ChannelInfo * channel,SessionType flag)280 static void AnonymizeLogTransOnSessionOpenedInfo(const char *sessionName, const ChannelInfo *channel, SessionType flag)
281 {
282     char *tmpName = NULL;
283     Anonymize(sessionName, &tmpName);
284     TRANS_LOGI(TRANS_SDK,
285         "TransOnSessionOpened: sessionName=%{public}s, channelId=%{public}d, channelType=%{public}d, flag=%{public}d,"
286         "isServer=%{public}d, type=%{public}d, crc=%{public}d",
287         tmpName, channel->channelId, channel->channelType, flag, channel->isServer, channel->routeType, channel->crc);
288     AnonymizeFree(tmpName);
289 }
290 
TransOnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag)291 NO_SANITIZE("cfi") int32_t TransOnSessionOpened(const char *sessionName, const ChannelInfo *channel, SessionType flag)
292 {
293     if ((sessionName == NULL) || (channel == NULL)) {
294         TRANS_LOGW(TRANS_SDK, "Invalid param");
295         return SOFTBUS_INVALID_PARAM;
296     }
297     AnonymizeLogTransOnSessionOpenedInfo(sessionName, channel, flag);
298     SessionListenerAdapter sessionCallback;
299     (void)memset_s(&sessionCallback, sizeof(SessionListenerAdapter), 0, sizeof(SessionListenerAdapter));
300     int32_t ret = ClientGetSessionCallbackAdapterByName(sessionName, &sessionCallback);
301     if (ret != SOFTBUS_OK) {
302         TRANS_LOGE(TRANS_SDK, "get session listener failed, ret=%{public}d", ret);
303         return ret;
304     }
305 
306     int32_t sessionId = INVALID_SESSION_ID;
307     if (channel->isServer) {
308         ret = AcceptSessionAsServer(sessionName, channel, flag, &sessionId);
309     } else {
310         ret = ClientEnableSessionByChannelId(channel, &sessionId);
311         if (ret == SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND) {
312             SoftBusSleepMs(RETRY_GET_INFO_TIMES_MS); // avoid set channel info later than sesssion opened callback
313             ret = ClientEnableSessionByChannelId(channel, &sessionId);
314         }
315     }
316 
317     if (ret != SOFTBUS_OK) {
318         TRANS_LOGE(TRANS_SDK, "accept session failed, ret=%{public}d", ret);
319         return ret;
320     }
321     if (channel->channelType == CHANNEL_TYPE_UDP && channel->businessType == BUSINESS_TYPE_FILE) {
322         TransSetUdpChanelSessionId(channel->channelId, sessionId);
323     }
324     if (sessionCallback.isSocketListener) {
325         ret = HandleOnBindSuccess(sessionId, sessionCallback, channel->isServer);
326         return ret;
327     }
328     TRANS_LOGD(TRANS_SDK, "trigger session open callback");
329     if ((sessionCallback.session.OnSessionOpened == NULL) ||
330         (sessionCallback.session.OnSessionOpened(sessionId, SOFTBUS_OK) != SOFTBUS_OK)) {
331         TRANS_LOGE(TRANS_SDK, "OnSessionOpened failed");
332         (void)ClientDeleteSession(sessionId);
333         return SOFTBUS_TRANS_ON_SESSION_OPENED_FAILED;
334     }
335     TRANS_LOGI(TRANS_SDK, "ok, sessionId=%{public}d", sessionId);
336     return SOFTBUS_OK;
337 }
338 
TransOnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)339 NO_SANITIZE("cfi") int32_t TransOnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
340 {
341     int32_t sessionId = INVALID_SESSION_ID;
342     SessionListenerAdapter sessionCallback;
343     (void)memset_s(&sessionCallback, sizeof(SessionListenerAdapter), 0, sizeof(SessionListenerAdapter));
344     if (channelType == CHANNEL_TYPE_UNDEFINED) {
345         sessionId = channelId;
346         (void)ClientSetEnableStatusBySocket(sessionId, ENABLE_STATUS_FAILED);
347         // only client async bind failed call
348         bool tmpIsServer = false;
349         ClientGetSessionCallbackAdapterById(sessionId, &sessionCallback, &tmpIsServer);
350         (void)TransOnBindFailed(sessionId, &sessionCallback.socketClient, errCode);
351         return SOFTBUS_OK;
352     }
353     TRANS_LOGI(TRANS_SDK, "trigger session open failed callback, channelId=%{public}d, channelType=%{public}d",
354         channelId, channelType);
355     bool isServer = false;
356     (void)GetSocketCallbackAdapterByChannelId(channelId, channelType, &sessionId, &sessionCallback, &isServer);
357     if (sessionCallback.isSocketListener) {
358         (void)ClientSetEnableStatusBySocket(sessionId, ENABLE_STATUS_FAILED);
359         bool isAsync = true;
360         int ret = ClientGetSessionIsAsyncBySessionId(sessionId, &isAsync);
361         if (ret != SOFTBUS_OK) {
362             TRANS_LOGE(TRANS_SDK, "get is async type failed, ret=%{public}d", ret);
363             return ret;
364         }
365 
366         if (isServer) {
367             (void)ClientDeleteSocketSession(sessionId);
368         } else if (isAsync) {
369             (void)TransOnBindFailed(sessionId, &sessionCallback.socketClient, errCode);
370         } else { // sync bind
371             (void)ClientSignalSyncBind(sessionId, errCode);
372         }
373         TRANS_LOGI(TRANS_SDK, "ok, sessionid=%{public}d", sessionId);
374         return SOFTBUS_OK;
375     }
376     if (sessionCallback.session.OnSessionOpened != NULL) {
377         (void)sessionCallback.session.OnSessionOpened(sessionId, errCode);
378     }
379     (void)ClientDeleteSession(sessionId);
380     TRANS_LOGI(TRANS_SDK, "ok, sessionid=%{public}d", sessionId);
381     return SOFTBUS_OK;
382 }
383 
TransOnSessionClosed(int32_t channelId,int32_t channelType,ShutdownReason reason)384 NO_SANITIZE("cfi") int32_t TransOnSessionClosed(int32_t channelId, int32_t channelType, ShutdownReason reason)
385 {
386     TRANS_LOGI(TRANS_SDK, "channelId=%{public}d, channelType=%{public}d", channelId, channelType);
387     int32_t sessionId = INVALID_SESSION_ID;
388     int32_t ret = SOFTBUS_NO_INIT;
389     SessionListenerAdapter sessionCallback;
390     SessionEnableStatus enableStatus;
391     bool isServer = false;
392     (void)memset_s(&sessionCallback, sizeof(SessionListenerAdapter), 0, sizeof(SessionListenerAdapter));
393     (void)GetSocketCallbackAdapterByChannelId(channelId, channelType, &sessionId, &sessionCallback, &isServer);
394 
395     (void)ClientGetChannelBySessionId(sessionId, NULL, NULL, &enableStatus);
396     TRANS_LOGI(TRANS_SDK, "trigger session close callback");
397     if (sessionCallback.isSocketListener && enableStatus == ENABLE_STATUS_SUCCESS) {
398         ISocketListener *listener = isServer ? &sessionCallback.socketServer : &sessionCallback.socketClient;
399         if (listener->OnShutdown != NULL) {
400             listener->OnShutdown(sessionId, reason);
401         }
402         ret = ClientDeleteSocketSession(sessionId);
403     } else if (sessionCallback.session.OnSessionClosed != NULL) {
404         sessionCallback.session.OnSessionClosed(sessionId);
405         ret = ClientDeleteSession(sessionId);
406     }
407 
408     if (ret != SOFTBUS_OK) {
409         TRANS_LOGE(TRANS_SDK, "client delete session failed");
410         return ret;
411     }
412     TRANS_LOGI(TRANS_SDK, "ok, sessionId=%{public}d", sessionId);
413     return SOFTBUS_OK;
414 }
415 
ProcessReceivedFileData(int32_t sessionId,int32_t channelId,const char * data,uint32_t len,SessionPktType type)416 static int32_t ProcessReceivedFileData(int32_t sessionId, int32_t channelId, const char *data, uint32_t len,
417     SessionPktType type)
418 {
419     char sessionName[SESSION_NAME_SIZE_MAX] = { 0 };
420     int32_t ret = ClientGetSessionDataById(sessionId, sessionName, SESSION_NAME_SIZE_MAX, KEY_SESSION_NAME);
421     if (ret != SOFTBUS_OK) {
422         TRANS_LOGE(TRANS_FILE, "get sessionName by sessionId=%{public}d failed, ret=%{public}d", sessionId, ret);
423         return ret;
424     }
425 
426     ret = ProcessFileFrameData(sessionId, channelId, data, len, type);
427     if (ret != SOFTBUS_OK) {
428         TRANS_LOGE(TRANS_FILE, "process file frame data failed, ret=%{public}d", ret);
429         return ret;
430     }
431     return SOFTBUS_OK;
432 }
433 
TransOnDataReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)434 NO_SANITIZE("cfi") int32_t TransOnDataReceived(int32_t channelId, int32_t channelType,
435     const void *data, uint32_t len, SessionPktType type)
436 {
437     int32_t sessionId;
438     SessionListenerAdapter sessionCallback;
439     bool isServer = false;
440     (void)memset_s(&sessionCallback, sizeof(SessionListenerAdapter), 0, sizeof(SessionListenerAdapter));
441     int32_t ret = GetSocketCallbackAdapterByChannelId(channelId, channelType, &sessionId, &sessionCallback, &isServer);
442     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SDK, "get session callback failed");
443     (void)ClientResetIdleTimeoutById(sessionId);
444     ISocketListener *listener = isServer ? &sessionCallback.socketServer : &sessionCallback.socketClient;
445     switch (type) {
446         case TRANS_SESSION_BYTES:
447             if (sessionCallback.isSocketListener) {
448                 if (listener->OnBytes != NULL) {
449                     listener->OnBytes(sessionId, data, len);
450                 }
451             } else if (sessionCallback.session.OnBytesReceived != NULL) {
452                 sessionCallback.session.OnBytesReceived(sessionId, data, len);
453             }
454             break;
455         case TRANS_SESSION_MESSAGE:
456             if (sessionCallback.isSocketListener) {
457                 if (listener->OnMessage != NULL) {
458                     listener->OnMessage(sessionId, data, len);
459                 }
460             } else if (sessionCallback.session.OnMessageReceived != NULL) {
461                 sessionCallback.session.OnMessageReceived(sessionId, data, len);
462             }
463             break;
464         case TRANS_SESSION_FILE_FIRST_FRAME:
465         case TRANS_SESSION_FILE_ONGOINE_FRAME:
466         case TRANS_SESSION_FILE_LAST_FRAME:
467         case TRANS_SESSION_FILE_ONLYONE_FRAME:
468         case TRANS_SESSION_FILE_ALLFILE_SENT:
469         case TRANS_SESSION_FILE_CRC_CHECK_FRAME:
470         case TRANS_SESSION_FILE_RESULT_FRAME:
471         case TRANS_SESSION_FILE_ACK_REQUEST_SENT:
472         case TRANS_SESSION_FILE_ACK_RESPONSE_SENT:
473             if (channelType == CHANNEL_TYPE_PROXY) {
474                 return ProcessReceivedFileData(sessionId, channelId, (char *)data, len, type);
475             }
476             break;
477         default:
478             TRANS_LOGE(TRANS_FILE, "revc unknown session type = %{public}d", type);
479             return SOFTBUS_TRANS_INVALID_SESSION_TYPE;
480     }
481 
482     return SOFTBUS_OK;
483 }
484 
TransOnOnStreamRecevied(int32_t channelId,int32_t channelType,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)485 NO_SANITIZE("cfi") int32_t TransOnOnStreamRecevied(int32_t channelId, int32_t channelType,
486     const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
487 {
488     int32_t sessionId;
489     SessionListenerAdapter sessionCallback;
490     bool isServer = false;
491     (void)memset_s(&sessionCallback, sizeof(SessionListenerAdapter), 0, sizeof(SessionListenerAdapter));
492     int32_t ret = GetSocketCallbackAdapterByChannelId(channelId, channelType, &sessionId, &sessionCallback, &isServer);
493     if (ret != SOFTBUS_OK) {
494         TRANS_LOGE(TRANS_STREAM, "get session callback failed");
495         return ret;
496     }
497 
498     (void)ClientResetIdleTimeoutById(sessionId);
499     if (sessionCallback.isSocketListener) {
500         ISocketListener *listener = isServer ? &sessionCallback.socketServer : &sessionCallback.socketClient;
501         if (listener->OnStream != NULL) {
502             listener->OnStream(sessionId, data, ext, param);
503         }
504         return SOFTBUS_OK;
505     }
506 
507     if (sessionCallback.session.OnStreamReceived == NULL) {
508         TRANS_LOGE(TRANS_STREAM, "listener OnStreamReceived is NULL");
509         return SOFTBUS_NO_INIT;
510     }
511 
512     sessionCallback.session.OnStreamReceived(sessionId, data, ext, param);
513     return SOFTBUS_OK;
514 }
515 
TransOnQosEvent(int32_t channelId,int32_t channelType,int32_t eventId,int32_t tvCount,const QosTv * tvList)516 NO_SANITIZE("cfi") int32_t TransOnQosEvent(int32_t channelId, int32_t channelType, int32_t eventId,
517     int32_t tvCount, const QosTv *tvList)
518 {
519     int32_t sessionId;
520     ISessionListener listener = {0};
521     int32_t ret = GetSessionCallbackByChannelId(channelId, channelType, &sessionId, &listener);
522     if (ret != SOFTBUS_OK) {
523         TRANS_LOGE(TRANS_QOS, "get session callback failed");
524         return ret;
525     }
526     if (listener.OnQosEvent == NULL) {
527         TRANS_LOGE(TRANS_QOS, "listener OnQosEvent is NULL, channelId=%{public}d, sessionId=%{public}d",
528                    channelId, sessionId);
529         return SOFTBUS_NO_INIT;
530     }
531     listener.OnQosEvent(sessionId, eventId, tvCount, tvList);
532     return SOFTBUS_OK;
533 }
534 
ClientTransOnChannelBind(int32_t channelId,int32_t channelType)535 int32_t ClientTransOnChannelBind(int32_t channelId, int32_t channelType)
536 {
537     TRANS_LOGI(TRANS_SDK, "channelId=%{public}d, channelType=%{public}d", channelId, channelType);
538     int32_t socket = INVALID_SESSION_ID;
539     SessionListenerAdapter sessionCallback;
540     bool isServer = false;
541     (void)memset_s(&sessionCallback, sizeof(SessionListenerAdapter), 0, sizeof(SessionListenerAdapter));
542     int32_t ret = GetSocketCallbackAdapterByChannelId(channelId, channelType, &socket, &sessionCallback, &isServer);
543     if (ret != SOFTBUS_OK) {
544         TRANS_LOGE(TRANS_SDK, "get session callback failed channelId=%{public}d", channelId);
545         return ret;
546     }
547 
548     if (!sessionCallback.isSocketListener) {
549         TRANS_LOGW(TRANS_SDK, "QoS recv session callback channelId=%{public}d", channelId);
550         return SOFTBUS_NOT_NEED_UPDATE;
551     }
552 
553     if (!isServer) {
554         TRANS_LOGW(TRANS_SDK, "only server need OnChannelBind channelId=%{public}d", channelId);
555         return SOFTBUS_NOT_NEED_UPDATE;
556     }
557 
558     ISocketListener *listener = &sessionCallback.socketServer;
559     ret = TransOnBindSuccess(socket, listener);
560     if (ret != SOFTBUS_OK) {
561         TRANS_LOGE(TRANS_SDK, "client on bind failed channelId=%{public}d", channelId);
562         return ret;
563     }
564     TRANS_LOGI(TRANS_SDK, "ok, channelId=%{public}d", channelId);
565     return SOFTBUS_OK;
566 }
567 
ClientTransIfChannelForSocket(const char * sessionName,bool * isSocket)568 int32_t ClientTransIfChannelForSocket(const char *sessionName, bool *isSocket)
569 {
570     if (sessionName == NULL || isSocket == NULL) {
571         TRANS_LOGE(TRANS_SDK, "sessionName or isSocket is NULL");
572         return SOFTBUS_INVALID_PARAM;
573     }
574 
575     SessionListenerAdapter sessionCallback;
576     (void)memset_s(&sessionCallback, sizeof(SessionListenerAdapter), 0, sizeof(SessionListenerAdapter));
577     int32_t ret = ClientGetSessionCallbackAdapterByName(sessionName, &sessionCallback);
578     if (ret != SOFTBUS_OK) {
579         char *tmpName = NULL;
580         Anonymize(sessionName, &tmpName);
581         TRANS_LOGE(TRANS_SDK, "get session callback failed, sessionName=%{public}s", tmpName);
582         AnonymizeFree(tmpName);
583         return ret;
584     }
585 
586     *isSocket = sessionCallback.isSocketListener;
587     return SOFTBUS_OK;
588 }
589 
ClientTransOnQos(int32_t channelId,int32_t channelType,QoSEvent event,const QosTV * qos,uint32_t count)590 int32_t ClientTransOnQos(int32_t channelId, int32_t channelType, QoSEvent event, const QosTV *qos, uint32_t count)
591 {
592     if (qos == NULL) {
593         TRANS_LOGE(TRANS_SDK, "qos is NULL");
594         return SOFTBUS_INVALID_PARAM;
595     }
596     char sessionName[SESSION_NAME_SIZE_MAX + 1] = { 0 };
597     if (ClientGetSessionNameByChannelId(channelId, channelType, sessionName, SESSION_NAME_SIZE_MAX)) {
598         TRANS_LOGE(TRANS_SDK, "failed to get sessionName, channelId=%{public}d", channelId);
599         return SOFTBUS_TRANS_SESSION_NAME_NO_EXIST;
600     }
601     if (!IsDistributedDataSession(sessionName)) {
602         TRANS_LOGI(TRANS_SDK, "not report qos event on non-distributed data session");
603         return SOFTBUS_OK;
604     }
605     int32_t socket = INVALID_SESSION_ID;
606     SessionListenerAdapter sessionCallback;
607     bool isServer = false;
608     (void)memset_s(&sessionCallback, sizeof(SessionListenerAdapter), 0, sizeof(SessionListenerAdapter));
609     int32_t ret = GetSocketCallbackAdapterByChannelId(channelId, channelType, &socket, &sessionCallback, &isServer);
610     if (ret != SOFTBUS_OK) {
611         TRANS_LOGE(TRANS_SDK, "get session callback failed channelId=%{public}d", channelId);
612         return ret;
613     }
614     if (isServer) {
615         TRANS_LOGI(TRANS_SDK, "not report qos event on server side");
616         return SOFTBUS_OK;
617     }
618     if (!sessionCallback.isSocketListener) {
619         TRANS_LOGI(TRANS_SDK, "not report qos event on non-socket session");
620         return SOFTBUS_OK;
621     }
622     if (sessionCallback.socketClient.OnQos != NULL) {
623         sessionCallback.socketClient.OnQos(socket, event, qos, count);
624         TRANS_LOGI(
625             TRANS_SDK, "successful report qos event to client socket=%{public}d, event=%{public}d", socket, event);
626     }
627     return SOFTBUS_OK;
628 }
629 
GetClientSessionCb(void)630 IClientSessionCallBack *GetClientSessionCb(void)
631 {
632     g_sessionCb.OnSessionOpened = TransOnSessionOpened;
633     g_sessionCb.OnSessionClosed = TransOnSessionClosed;
634     g_sessionCb.OnSessionOpenFailed = TransOnSessionOpenFailed;
635     g_sessionCb.OnDataReceived = TransOnDataReceived;
636     g_sessionCb.OnStreamReceived = TransOnOnStreamRecevied;
637     g_sessionCb.OnGetSessionId = ClientGetSessionIdByChannelId;
638     g_sessionCb.OnQosEvent = TransOnQosEvent;
639     g_sessionCb.OnIdleTimeoutReset = ClientResetIdleTimeoutById;
640     g_sessionCb.OnRawStreamEncryptDefOptGet = ClientRawStreamEncryptDefOptGet;
641     g_sessionCb.OnRawStreamEncryptOptGet = ClientRawStreamEncryptOptGet;
642     g_sessionCb.OnChannelBind = ClientTransOnChannelBind;
643     g_sessionCb.IfChannelForSocket = ClientTransIfChannelForSocket;
644     g_sessionCb.OnQos = ClientTransOnQos;
645     return &g_sessionCb;
646 }
647