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