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_proxy_manager.h"
17 
18 #include <securec.h>
19 #include <unistd.h>
20 
21 #include "anonymizer.h"
22 #include "client_trans_proxy_file_manager.h"
23 #include "client_trans_tcp_direct_message.h"
24 #include "softbus_adapter_crypto.h"
25 #include "softbus_adapter_mem.h"
26 #include "softbus_adapter_socket.h"
27 #include "softbus_def.h"
28 #include "softbus_errcode.h"
29 #include "softbus_feature_config.h"
30 #include "softbus_utils.h"
31 #include "trans_log.h"
32 #include "trans_pending_pkt.h"
33 #include "trans_server_proxy.h"
34 
35 #define SLICE_LEN (4 * 1024)
36 #define PROXY_ACK_SIZE 4
37 #define OH_TYPE 10
38 
39 static IClientSessionCallBack g_sessionCb;
40 static uint32_t g_proxyMaxByteBufSize;
41 static uint32_t g_proxyMaxMessageBufSize;
42 
43 static SoftBusList *g_proxyChannelInfoList = NULL;
44 static SoftBusList *g_channelSliceProcessorList = NULL;
45 
46 typedef struct {
47     int32_t priority;
48     int32_t sliceNum;
49     int32_t sliceSeq;
50     int32_t reserved;
51 } SliceHead;
52 
53 typedef struct {
54     int32_t magicNumber;
55     int32_t seq;
56     int32_t flags;
57     int32_t dataLen;
58 } PacketHead;
59 
60 typedef struct {
61     uint8_t *inData;
62     uint32_t inLen;
63     uint8_t *outData;
64     uint32_t outLen;
65 } ClientProxyDataInfo;
66 
ClientPackSliceHead(SliceHead * data)67 void ClientPackSliceHead(SliceHead *data)
68 {
69     data->priority = (int32_t)SoftBusHtoLl((uint32_t)data->priority);
70     data->sliceNum = (int32_t)SoftBusHtoLl((uint32_t)data->sliceNum);
71     data->sliceSeq = (int32_t)SoftBusHtoLl((uint32_t)data->sliceSeq);
72     data->reserved = (int32_t)SoftBusHtoLl((uint32_t)data->reserved);
73 }
74 
ClientUnPackSliceHead(SliceHead * data)75 void ClientUnPackSliceHead(SliceHead *data)
76 {
77     data->priority = (int32_t)SoftBusLtoHl((uint32_t)data->priority);
78     data->sliceNum = (int32_t)SoftBusLtoHl((uint32_t)data->sliceNum);
79     data->sliceSeq = (int32_t)SoftBusLtoHl((uint32_t)data->sliceSeq);
80     data->reserved = (int32_t)SoftBusLtoHl((uint32_t)data->reserved);
81 }
82 
ClientPackPacketHead(PacketHead * data)83 void ClientPackPacketHead(PacketHead *data)
84 {
85     data->magicNumber = (int32_t)SoftBusHtoLl((uint32_t)data->magicNumber);
86     data->seq = (int32_t)SoftBusHtoLl((uint32_t)data->seq);
87     data->flags = (int32_t)SoftBusHtoLl((uint32_t)data->flags);
88     data->dataLen = (int32_t)SoftBusHtoLl((uint32_t)data->dataLen);
89 }
90 
ClientUnPackPacketHead(PacketHead * data)91 void ClientUnPackPacketHead(PacketHead *data)
92 {
93     data->magicNumber = (int32_t)SoftBusLtoHl((uint32_t)data->magicNumber);
94     data->seq = (int32_t)SoftBusLtoHl((uint32_t)data->seq);
95     data->flags = (int32_t)SoftBusLtoHl((uint32_t)data->flags);
96     data->dataLen = (int32_t)SoftBusLtoHl((uint32_t)data->dataLen);
97 }
98 
99 static void ClientTransProxySliceTimerProc(void);
100 
ClientTransProxyListInit()101 static int32_t ClientTransProxyListInit()
102 {
103     g_proxyChannelInfoList = CreateSoftBusList();
104     if (g_proxyChannelInfoList == NULL) {
105         return SOFTBUS_NO_INIT;
106     }
107     g_channelSliceProcessorList = CreateSoftBusList();
108     if (g_channelSliceProcessorList == NULL) {
109         DestroySoftBusList(g_proxyChannelInfoList);
110         return SOFTBUS_NO_INIT;
111     }
112     if (RegisterTimeoutCallback(SOFTBUS_PROXYSLICE_TIMER_FUN, ClientTransProxySliceTimerProc) != SOFTBUS_OK) {
113         TRANS_LOGE(TRANS_INIT, "register timeout fail");
114         DestroySoftBusList(g_proxyChannelInfoList);
115         DestroySoftBusList(g_channelSliceProcessorList);
116         return SOFTBUS_TIMOUT;
117     }
118     return SOFTBUS_OK;
119 }
120 
ClientTransProxyListDeinit(void)121 static void ClientTransProxyListDeinit(void)
122 {
123     if (g_proxyChannelInfoList != NULL) {
124         DestroySoftBusList(g_proxyChannelInfoList);
125         g_proxyChannelInfoList = NULL;
126     }
127     if (g_channelSliceProcessorList != NULL) {
128         DestroySoftBusList(g_channelSliceProcessorList);
129         g_channelSliceProcessorList = NULL;
130     }
131 }
132 
ClientTransProxyInit(const IClientSessionCallBack * cb)133 int32_t ClientTransProxyInit(const IClientSessionCallBack *cb)
134 {
135     if (cb == NULL) {
136         TRANS_LOGE(TRANS_INIT, "param is null!");
137         return SOFTBUS_INVALID_PARAM;
138     }
139 
140     g_sessionCb = *cb;
141     if (ClinetTransProxyFileManagerInit() != SOFTBUS_OK) {
142         TRANS_LOGE(TRANS_INIT, "ClinetTransProxyFileManagerInit init fail!");
143         return SOFTBUS_NO_INIT;
144     }
145     if (ClientTransProxyListInit() != SOFTBUS_OK) {
146         TRANS_LOGE(TRANS_INIT, "ClinetTransProxyListInit init fail!");
147         return SOFTBUS_NO_INIT;
148     }
149 
150     if (PendingInit(PENDING_TYPE_PROXY) != SOFTBUS_OK) {
151         TRANS_LOGE(TRANS_INIT, "trans proxy pending init failed.");
152         return SOFTBUS_NO_INIT;
153     }
154 
155     if (SoftbusGetConfig(SOFTBUS_INT_MAX_BYTES_NEW_LENGTH, (unsigned char *)&g_proxyMaxByteBufSize,
156                          sizeof(g_proxyMaxByteBufSize)) != SOFTBUS_OK) {
157         TRANS_LOGW(TRANS_INIT, "get auth proxy channel max bytes length fail");
158     }
159     if (SoftbusGetConfig(SOFTBUS_INT_MAX_MESSAGE_NEW_LENGTH, (unsigned char *)&g_proxyMaxMessageBufSize,
160                          sizeof(g_proxyMaxMessageBufSize)) != SOFTBUS_OK) {
161         TRANS_LOGW(TRANS_INIT, "get auth proxy channel max message length fail");
162     }
163     TRANS_LOGI(TRANS_INIT, "proxy auth byteSize=%{public}u, messageSize=%{public}u",
164         g_proxyMaxByteBufSize, g_proxyMaxMessageBufSize);
165     return SOFTBUS_OK;
166 }
167 
ClientTransProxyDeinit(void)168 void ClientTransProxyDeinit(void)
169 {
170     ClinetTransProxyFileManagerDeinit();
171     PendingDeinit(PENDING_TYPE_PROXY);
172     ClientTransProxyListDeinit();
173 }
174 
ClientTransProxyGetInfoByChannelId(int32_t channelId,ProxyChannelInfoDetail * info)175 int32_t ClientTransProxyGetInfoByChannelId(int32_t channelId, ProxyChannelInfoDetail *info)
176 {
177     if (info == NULL) {
178         TRANS_LOGE(TRANS_SDK, "param invalid.");
179         return SOFTBUS_INVALID_PARAM;
180     }
181     if (SoftBusMutexLock(&g_proxyChannelInfoList->lock) != SOFTBUS_OK) {
182         TRANS_LOGE(TRANS_SDK, "lock failed");
183         return SOFTBUS_LOCK_ERR;
184     }
185 
186     ClientProxyChannelInfo *item = NULL;
187     LIST_FOR_EACH_ENTRY(item, &(g_proxyChannelInfoList->list), ClientProxyChannelInfo, node) {
188         if (item->channelId == channelId) {
189             (void)memcpy_s(info, sizeof(ProxyChannelInfoDetail), &item->detail, sizeof(ProxyChannelInfoDetail));
190             item->detail.sequence++;
191             (void)SoftBusMutexUnlock(&g_proxyChannelInfoList->lock);
192             return SOFTBUS_OK;
193         }
194     }
195 
196     (void)SoftBusMutexUnlock(&g_proxyChannelInfoList->lock);
197     TRANS_LOGE(TRANS_SDK, "can not find proxy channel by channelId=%{public}d", channelId);
198     return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND;
199 }
200 
ClientTransProxyGetOsTypeByChannelId(int32_t channelId,int32_t * osType)201 int32_t ClientTransProxyGetOsTypeByChannelId(int32_t channelId, int32_t *osType)
202 {
203     if (osType == NULL || g_proxyChannelInfoList == NULL) {
204         TRANS_LOGE(TRANS_SDK, "param invalid channelId=%{public}d", channelId);
205         return SOFTBUS_INVALID_PARAM;
206     }
207     if (SoftBusMutexLock(&g_proxyChannelInfoList->lock) != SOFTBUS_OK) {
208         TRANS_LOGE(TRANS_SDK, "lock failed");
209         return SOFTBUS_LOCK_ERR;
210     }
211     ClientProxyChannelInfo *item = NULL;
212     LIST_FOR_EACH_ENTRY(item, &(g_proxyChannelInfoList->list), ClientProxyChannelInfo, node) {
213         if (item->channelId == channelId) {
214             *osType = item->detail.osType;
215             (void)SoftBusMutexUnlock(&g_proxyChannelInfoList->lock);
216             return SOFTBUS_OK;
217         }
218     }
219 
220     (void)SoftBusMutexUnlock(&g_proxyChannelInfoList->lock);
221     TRANS_LOGE(TRANS_SDK, "can not find proxy channelId=%{public}d", channelId);
222     return SOFTBUS_NOT_FIND;
223 }
224 
ClientTransProxyGetLinkTypeByChannelId(int32_t channelId,int32_t * linkType)225 int32_t ClientTransProxyGetLinkTypeByChannelId(int32_t channelId, int32_t *linkType)
226 {
227     if (linkType == NULL) {
228         TRANS_LOGE(TRANS_SDK, "param invalid.");
229         return SOFTBUS_INVALID_PARAM;
230     }
231     if (SoftBusMutexLock(&g_proxyChannelInfoList->lock) != SOFTBUS_OK) {
232         TRANS_LOGE(TRANS_SDK, "lock failed");
233         return SOFTBUS_LOCK_ERR;
234     }
235     ClientProxyChannelInfo *item = NULL;
236     LIST_FOR_EACH_ENTRY(item, &(g_proxyChannelInfoList->list), ClientProxyChannelInfo, node) {
237         if (item->channelId == channelId) {
238             *linkType = item->detail.linkType;
239             (void)SoftBusMutexUnlock(&g_proxyChannelInfoList->lock);
240             return SOFTBUS_OK;
241         }
242     }
243 
244     (void)SoftBusMutexUnlock(&g_proxyChannelInfoList->lock);
245     TRANS_LOGE(TRANS_SDK, "can not find proxy channelId=%{public}d", channelId);
246     return SOFTBUS_NOT_FIND;
247 }
248 
ClientTransProxyAddChannelInfo(ClientProxyChannelInfo * info)249 int32_t ClientTransProxyAddChannelInfo(ClientProxyChannelInfo *info)
250 {
251     if (info == NULL) {
252         TRANS_LOGE(TRANS_SDK, "param invalid.");
253         return SOFTBUS_INVALID_PARAM;
254     }
255     if (SoftBusMutexLock(&g_proxyChannelInfoList->lock) != SOFTBUS_OK) {
256         TRANS_LOGE(TRANS_SDK, "lock failed");
257         return SOFTBUS_LOCK_ERR;
258     }
259 
260     ClientProxyChannelInfo *item = NULL;
261     LIST_FOR_EACH_ENTRY(item, &(g_proxyChannelInfoList->list), ClientProxyChannelInfo, node) {
262         if (item->channelId == info->channelId) {
263             TRANS_LOGE(TRANS_SDK, "client is existed. channelId=%{public}d", item->channelId);
264             (void)SoftBusMutexUnlock(&g_proxyChannelInfoList->lock);
265             return SOFTBUS_ALREADY_EXISTED;
266         }
267     }
268 
269     ListAdd(&g_proxyChannelInfoList->list, &info->node);
270     TRANS_LOGI(TRANS_SDK, "add channelId=%{public}d", info->channelId);
271     (void)SoftBusMutexUnlock(&g_proxyChannelInfoList->lock);
272     return SOFTBUS_OK;
273 }
274 
ClientTransProxyDelChannelInfo(int32_t channelId)275 int32_t ClientTransProxyDelChannelInfo(int32_t channelId)
276 {
277     if (SoftBusMutexLock(&g_proxyChannelInfoList->lock) != SOFTBUS_OK) {
278         TRANS_LOGE(TRANS_SDK, "lock failed");
279         return SOFTBUS_LOCK_ERR;
280     }
281 
282     ClientProxyChannelInfo *item = NULL;
283     LIST_FOR_EACH_ENTRY(item, &(g_proxyChannelInfoList->list), ClientProxyChannelInfo, node) {
284         if (item->channelId == channelId) {
285             ListDelete(&item->node);
286             TRANS_LOGI(TRANS_SDK, "delete channelId=%{public}d", channelId);
287             SoftBusFree(item);
288             DelPendingPacket(channelId, PENDING_TYPE_PROXY);
289             (void)SoftBusMutexUnlock(&g_proxyChannelInfoList->lock);
290             return SOFTBUS_OK;
291         }
292     }
293 
294     (void)SoftBusMutexUnlock(&g_proxyChannelInfoList->lock);
295     TRANS_LOGE(TRANS_SDK, "can not find proxy channel by channelId=%{public}d", channelId);
296     return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND;
297 }
298 
ClientTransProxyCreateChannelInfo(const ChannelInfo * channel)299 static ClientProxyChannelInfo *ClientTransProxyCreateChannelInfo(const ChannelInfo *channel)
300 {
301     ClientProxyChannelInfo *info = (ClientProxyChannelInfo *)SoftBusCalloc(sizeof(ClientProxyChannelInfo));
302     if (info == NULL) {
303         TRANS_LOGE(TRANS_SDK, "info is null");
304         return NULL;
305     }
306     if (memcpy_s(info->detail.sessionKey, SESSION_KEY_LENGTH, channel->sessionKey, SESSION_KEY_LENGTH) != EOK) {
307         SoftBusFree(info);
308         TRANS_LOGE(TRANS_SDK, "sessionKey memcpy fail");
309         return NULL;
310     }
311     info->channelId = channel->channelId;
312     info->detail.isEncrypted = channel->isEncrypt;
313     info->detail.sequence = 0;
314     info->detail.linkType = channel->linkType;
315     info->detail.osType = channel->osType;
316     return info;
317 }
318 
ClientTransProxyOnChannelOpened(const char * sessionName,const ChannelInfo * channel)319 int32_t ClientTransProxyOnChannelOpened(const char *sessionName, const ChannelInfo *channel)
320 {
321     if (sessionName == NULL || channel == NULL) {
322         TRANS_LOGW(TRANS_SDK, "invalid param.");
323         return SOFTBUS_INVALID_PARAM;
324     }
325 
326     ClientProxyChannelInfo *info = ClientTransProxyCreateChannelInfo(channel);
327     if (info == NULL) {
328         TRANS_LOGE(TRANS_SDK, "create channel info fail, channelId=%{public}d", channel->channelId);
329         return SOFTBUS_MEM_ERR;
330     }
331 
332     int32_t ret = ClientTransProxyAddChannelInfo(info);
333     if (ret != SOFTBUS_OK) {
334         TRANS_LOGE(TRANS_SDK, "ClientTransProxyAddChannelInfo fail channelId=%{public}d", channel->channelId);
335         (void)memset_s(info->detail.sessionKey, SESSION_KEY_LENGTH, 0, SESSION_KEY_LENGTH);
336         SoftBusFree(info);
337         return ret;
338     }
339 
340     ret = g_sessionCb.OnSessionOpened(sessionName, channel, TYPE_MESSAGE);
341     if (ret != SOFTBUS_OK) {
342         (void)ClientTransProxyDelChannelInfo(channel->channelId);
343         char *tmpName = NULL;
344         Anonymize(sessionName, &tmpName);
345         TRANS_LOGE(TRANS_SDK, "notify session open fail, sessionName=%{public}s.", tmpName);
346         AnonymizeFree(tmpName);
347         return ret;
348     }
349     return SOFTBUS_OK;
350 }
351 
352 int32_t TransProxyDelSliceProcessorByChannelId(int32_t channelId);
353 
ClientTransProxyOnChannelClosed(int32_t channelId,ShutdownReason reason)354 int32_t ClientTransProxyOnChannelClosed(int32_t channelId, ShutdownReason reason)
355 {
356     (void)ClientTransProxyDelChannelInfo(channelId);
357     (void)TransProxyDelSliceProcessorByChannelId(channelId);
358 
359     int ret = g_sessionCb.OnSessionClosed(channelId, CHANNEL_TYPE_PROXY, reason);
360     if (ret != SOFTBUS_OK) {
361         TRANS_LOGE(TRANS_SDK, "notify session closed errCode=%{public}d, channelId=%{public}d.", ret, channelId);
362         return ret;
363     }
364     return SOFTBUS_OK;
365 }
366 
ClientTransProxyOnChannelOpenFailed(int32_t channelId,int32_t errCode)367 int32_t ClientTransProxyOnChannelOpenFailed(int32_t channelId, int32_t errCode)
368 {
369     int ret = g_sessionCb.OnSessionOpenFailed(channelId, CHANNEL_TYPE_PROXY, errCode);
370     if (ret != SOFTBUS_OK) {
371         TRANS_LOGE(TRANS_SDK, "notify session openfail errCode=%{public}d, channelId=%{public}d.", errCode, channelId);
372         return ret;
373     }
374 
375     return SOFTBUS_OK;
376 }
377 
ClientTransProxySessionDataLenCheck(uint32_t dataLen,SessionPktType type)378 int32_t ClientTransProxySessionDataLenCheck(uint32_t dataLen, SessionPktType type)
379 {
380     switch (type) {
381         case TRANS_SESSION_MESSAGE:
382         case TRANS_SESSION_ASYNC_MESSAGE: {
383             if (dataLen > g_proxyMaxMessageBufSize) {
384                 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
385             }
386             break;
387         }
388         case TRANS_SESSION_BYTES: {
389             if (dataLen > g_proxyMaxByteBufSize) {
390                 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
391             }
392             break;
393         }
394         default: {
395             return SOFTBUS_OK;
396         }
397     }
398     return SOFTBUS_OK;
399 }
400 
ClientTransProxyDecryptPacketData(int32_t channelId,int32_t seq,ClientProxyDataInfo * dataInfo)401 static int32_t ClientTransProxyDecryptPacketData(int32_t channelId, int32_t seq, ClientProxyDataInfo *dataInfo)
402 {
403     ProxyChannelInfoDetail info;
404     int32_t ret = ClientTransProxyGetInfoByChannelId(channelId, &info);
405     if (ret != SOFTBUS_OK) {
406         TRANS_LOGE(TRANS_SDK, "get channel Info by channelId=%{public}d failed, ret=%{public}d", channelId, ret);
407         return ret;
408     }
409     AesGcmCipherKey cipherKey = { 0 };
410     cipherKey.keyLen = SESSION_KEY_LENGTH;
411     if (memcpy_s(cipherKey.key, SESSION_KEY_LENGTH, info.sessionKey, SESSION_KEY_LENGTH) != EOK) {
412         TRANS_LOGE(TRANS_SDK, "memcpy key error.");
413         return SOFTBUS_MEM_ERR;
414     }
415     ret = SoftBusDecryptDataWithSeq(
416         &cipherKey, dataInfo->inData, dataInfo->inLen, dataInfo->outData, &(dataInfo->outLen), seq);
417     (void)memset_s(&cipherKey, sizeof(AesGcmCipherKey), 0, sizeof(AesGcmCipherKey));
418     if (ret != SOFTBUS_OK) {
419         TRANS_LOGE(TRANS_SDK, "trans proxy Decrypt Data fail. ret=%{public}d ", ret);
420         return SOFTBUS_DECRYPT_ERR;
421     }
422 
423     return SOFTBUS_OK;
424 }
425 
ClientTransProxyCheckSliceHead(const SliceHead * head)426 static int32_t ClientTransProxyCheckSliceHead(const SliceHead *head)
427 {
428     if (head == NULL) {
429         TRANS_LOGW(TRANS_SDK, "invalid param.");
430         return SOFTBUS_INVALID_PARAM;
431     }
432     if (head->priority < 0 || head->priority >= PROXY_CHANNEL_PRORITY_BUTT) {
433         TRANS_LOGE(TRANS_SDK, "invalid index=%{public}d", head->priority);
434         return SOFTBUS_INVALID_DATA_HEAD;
435     }
436 
437     if (head->sliceNum != 1 && head->sliceSeq >= head->sliceNum) {
438         TRANS_LOGE(TRANS_SDK, "sliceNum=%{public}d, sliceSeq=%{public}d", head->sliceNum, head->sliceSeq);
439         return SOFTBUS_INVALID_DATA_HEAD;
440     }
441 
442     return SOFTBUS_OK;
443 }
444 
445 int32_t TransProxyPackAndSendData(
446     int32_t channelId, const void *data, uint32_t len, ProxyChannelInfoDetail *info, SessionPktType pktType);
447 
ClientTransProxySendSessionAck(int32_t channelId,int32_t seq)448 static void ClientTransProxySendSessionAck(int32_t channelId, int32_t seq)
449 {
450     unsigned char ack[PROXY_ACK_SIZE] = { 0 };
451     int32_t tmpSeq = 0;
452     ProxyChannelInfoDetail info;
453     if (ClientTransProxyGetInfoByChannelId(channelId, &info) != SOFTBUS_OK) {
454         TRANS_LOGE(TRANS_SDK, "get proxy info err, channelId=%{public}d", channelId);
455         return;
456     }
457     if (info.osType == OH_TYPE) {
458         tmpSeq = (int32_t)SoftBusHtoLl((uint32_t)seq);
459     } else {
460         tmpSeq = (int32_t)SoftBusHtoNl((uint32_t)seq); // convet host order to net order
461     }
462     if (memcpy_s(ack, PROXY_ACK_SIZE, &tmpSeq, sizeof(int32_t)) != EOK) {
463         TRANS_LOGE(TRANS_SDK, "memcpy seq err");
464         return;
465     }
466     info.sequence = seq;
467     if (TransProxyPackAndSendData(channelId, ack, PROXY_ACK_SIZE, &info, TRANS_SESSION_ACK) != SOFTBUS_OK) {
468         TRANS_LOGE(TRANS_SDK, "send ack err, seq=%{public}d", seq);
469     }
470 }
471 
ClientTransProxyProcSendMsgAck(int32_t channelId,const char * data,int32_t len,int32_t dataHeadSeq)472 static int32_t ClientTransProxyProcSendMsgAck(int32_t channelId, const char *data, int32_t len, int32_t dataHeadSeq)
473 {
474     if (len != PROXY_ACK_SIZE) {
475         return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
476     }
477     if (data == NULL) {
478         return SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_DATA_NULL;
479     }
480     int32_t seq = *(int32_t *)data;
481     int32_t hostSeq = (int32_t)SoftBusNtoHl(*(uint32_t *)data);
482     TRANS_LOGI(TRANS_SDK, "channelId=%{public}d, dataHeadSeq=%{public}d, seq=%{public}d, hostSeq=%{public}d",
483         channelId, dataHeadSeq, seq, hostSeq);
484     int32_t ret = SetPendingPacket(channelId, seq, PENDING_TYPE_PROXY);
485     if (ret != SOFTBUS_OK) {
486         ret = SetPendingPacket(channelId, hostSeq, PENDING_TYPE_PROXY);
487         if (ret == SOFTBUS_OK) {
488             TRANS_LOGI(TRANS_SDK, "set pending packet by hostSeq=%{public}d success", hostSeq);
489         }
490     }
491     return ret;
492 }
493 
ClientTransProxyNotifySession(int32_t channelId,SessionPktType flags,int32_t seq,const char * data,uint32_t len)494 static int32_t ClientTransProxyNotifySession(
495     int32_t channelId, SessionPktType flags, int32_t seq, const char *data, uint32_t len)
496 {
497     switch (flags) {
498         case TRANS_SESSION_MESSAGE:
499             ClientTransProxySendSessionAck(channelId, seq);
500             return g_sessionCb.OnDataReceived(channelId, CHANNEL_TYPE_PROXY, data, len, flags);
501         case TRANS_SESSION_ACK:
502             return (int32_t)(ClientTransProxyProcSendMsgAck(channelId, data, len, seq));
503         case TRANS_SESSION_BYTES:
504         case TRANS_SESSION_FILE_FIRST_FRAME:
505         case TRANS_SESSION_FILE_ONGOINE_FRAME:
506         case TRANS_SESSION_FILE_LAST_FRAME:
507         case TRANS_SESSION_FILE_ONLYONE_FRAME:
508         case TRANS_SESSION_FILE_ALLFILE_SENT:
509         case TRANS_SESSION_FILE_CRC_CHECK_FRAME:
510         case TRANS_SESSION_FILE_RESULT_FRAME:
511         case TRANS_SESSION_FILE_ACK_REQUEST_SENT:
512         case TRANS_SESSION_FILE_ACK_RESPONSE_SENT:
513         case TRANS_SESSION_ASYNC_MESSAGE:
514             return g_sessionCb.OnDataReceived(channelId, CHANNEL_TYPE_PROXY, data, len, flags);
515         default:
516             TRANS_LOGE(TRANS_SDK, "invalid flags=%{public}d", flags);
517             return SOFTBUS_INVALID_PARAM;
518     }
519 }
520 
ClientTransProxyProcessSessionData(int32_t channelId,const PacketHead * dataHead,const char * data)521 static int32_t ClientTransProxyProcessSessionData(int32_t channelId, const PacketHead *dataHead, const char *data)
522 {
523     ClientProxyDataInfo dataInfo = { 0 };
524     uint32_t outLen = 0;
525 
526     if (dataHead->dataLen <= OVERHEAD_LEN) {
527         TRANS_LOGE(TRANS_SDK, "invalid data head dataLen=%{public}d", dataHead->dataLen);
528         return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
529     }
530 
531     outLen = dataHead->dataLen - OVERHEAD_LEN;
532     dataInfo.outData = (unsigned char *)SoftBusCalloc(outLen);
533     if (dataInfo.outData == NULL) {
534         TRANS_LOGE(TRANS_SDK, "malloc fail when process session out data.");
535         return SOFTBUS_MALLOC_ERR;
536     }
537     dataInfo.inData = (unsigned char *)data;
538     dataInfo.inLen = dataHead->dataLen;
539     dataInfo.outLen = outLen;
540 
541     int32_t ret = ClientTransProxyDecryptPacketData(channelId, dataHead->seq, &dataInfo);
542     if (ret != SOFTBUS_OK) {
543         TRANS_LOGE(TRANS_SDK, "decrypt err");
544         SoftBusFree(dataInfo.outData);
545         return SOFTBUS_DECRYPT_ERR;
546     }
547 
548     if (ClientTransProxySessionDataLenCheck(dataInfo.outLen, (SessionPktType)(dataHead->flags)) != SOFTBUS_OK) {
549         TRANS_LOGE(
550             TRANS_SDK, "data len is too large outlen=%{public}d, flags=%{public}d", dataInfo.outLen, dataHead->flags);
551         SoftBusFree(dataInfo.outData);
552         return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
553     }
554 
555     TRANS_LOGD(TRANS_SDK, "ProcessData debug: outlen=%{public}d", dataInfo.outLen);
556     if (ClientTransProxyNotifySession(channelId, (SessionPktType)dataHead->flags, dataHead->seq,
557                                       (const char *)dataInfo.outData, dataInfo.outLen) != SOFTBUS_OK) {
558         TRANS_LOGE(TRANS_SDK, "process data err");
559         SoftBusFree(dataInfo.outData);
560         return SOFTBUS_INVALID_DATA_HEAD;
561     }
562     SoftBusFree(dataInfo.outData);
563     return SOFTBUS_OK;
564 }
565 
ClientTransProxyNoSubPacketProc(int32_t channelId,const char * data,uint32_t len)566 static int32_t ClientTransProxyNoSubPacketProc(int32_t channelId, const char *data, uint32_t len)
567 {
568     PacketHead head;
569     if (memcpy_s(&head, sizeof(PacketHead), data, sizeof(PacketHead)) != EOK) {
570         TRANS_LOGE(TRANS_SDK, "memcpy packetHead failed");
571         return SOFTBUS_MEM_ERR;
572     }
573     ClientUnPackPacketHead(&head);
574     if ((uint32_t)head.magicNumber != MAGIC_NUMBER) {
575         TRANS_LOGE(TRANS_SDK, "invalid magicNumber=%{public}x, channelId=%{public}d, len=%{public}d",
576             head.magicNumber, channelId, len);
577         return SOFTBUS_INVALID_DATA_HEAD;
578     }
579     if (head.dataLen <= 0) {
580         TRANS_LOGE(TRANS_SDK, "invalid dataLen=%{public}d, channelId=%{public}d, len=%{public}d",
581             head.dataLen, channelId, len);
582         return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
583     }
584     TRANS_LOGD(TRANS_SDK, "NoSubPacketProc dataLen=%{public}d, inputLen=%{public}d", head.dataLen, len);
585     if (len <= sizeof(PacketHead) || (head.dataLen != (int32_t)(len - sizeof(PacketHead)))) {
586         TRANS_LOGE(TRANS_SDK, "dataLen error, channelId=%{public}d, len=%{public}d, dataLen=%{public}d",
587             channelId, len, head.dataLen);
588         return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
589     }
590     int32_t ret = ClientTransProxyProcessSessionData(channelId, &head, data + sizeof(PacketHead));
591     if (ret != SOFTBUS_OK) {
592         TRANS_LOGE(TRANS_SDK, "process data err, channelId=%{public}d, len=%{public}d", channelId, len);
593         return ret;
594     }
595     return SOFTBUS_OK;
596 }
597 
ClientTransProxyGetChannelSliceProcessor(int32_t channelId)598 static ChannelSliceProcessor *ClientTransProxyGetChannelSliceProcessor(int32_t channelId)
599 {
600     ChannelSliceProcessor *processor = NULL;
601     LIST_FOR_EACH_ENTRY(processor, &g_channelSliceProcessorList->list, ChannelSliceProcessor, head) {
602         if (processor->channelId == channelId) {
603             return processor;
604         }
605     }
606 
607     ChannelSliceProcessor *node = (ChannelSliceProcessor *)SoftBusCalloc(sizeof(ChannelSliceProcessor));
608     if (node == NULL) {
609         TRANS_LOGE(TRANS_SDK, "calloc err");
610         return NULL;
611     }
612     node->channelId = channelId;
613     ListInit(&(node->head));
614     ListAdd(&(g_channelSliceProcessorList->list), &(node->head));
615     g_channelSliceProcessorList->cnt++;
616     TRANS_LOGI(TRANS_SDK, "add new node, channelId=%{public}d", channelId);
617     return node;
618 }
619 
ClientTransProxyClearProcessor(SliceProcessor * processor)620 static void ClientTransProxyClearProcessor(SliceProcessor *processor)
621 {
622     if (processor->data != NULL) {
623         SoftBusFree(processor->data);
624         processor->data = NULL;
625     }
626     processor->active = false;
627     processor->bufLen = 0;
628     processor->dataLen = 0;
629     processor->expectedSeq = 0;
630     processor->sliceNumber = 0;
631     processor->timeout = 0;
632 }
633 
TransProxyDelSliceProcessorByChannelId(int32_t channelId)634 int32_t TransProxyDelSliceProcessorByChannelId(int32_t channelId)
635 {
636     ChannelSliceProcessor *node = NULL;
637     ChannelSliceProcessor *next = NULL;
638 
639     if (g_channelSliceProcessorList == NULL) {
640         TRANS_LOGE(TRANS_INIT, "not init");
641         return SOFTBUS_NO_INIT;
642     }
643     if (SoftBusMutexLock(&g_channelSliceProcessorList->lock) != SOFTBUS_OK) {
644         TRANS_LOGE(TRANS_SDK, "lock err");
645         return SOFTBUS_LOCK_ERR;
646     }
647     LIST_FOR_EACH_ENTRY_SAFE(node, next, &g_channelSliceProcessorList->list, ChannelSliceProcessor, head) {
648         if (node->channelId == channelId) {
649             for (int i = PROXY_CHANNEL_PRORITY_MESSAGE; i < PROXY_CHANNEL_PRORITY_BUTT; i++) {
650                 ClientTransProxyClearProcessor(&(node->processor[i]));
651             }
652             ListDelete(&(node->head));
653             TRANS_LOGI(TRANS_SDK, "delete channelId=%{public}d", channelId);
654             SoftBusFree(node);
655             g_channelSliceProcessorList->cnt--;
656             (void)SoftBusMutexUnlock(&g_channelSliceProcessorList->lock);
657             return SOFTBUS_OK;
658         }
659     }
660     (void)SoftBusMutexUnlock(&g_channelSliceProcessorList->lock);
661     return SOFTBUS_OK;
662 }
663 
ClientTransProxySliceProcessChkPkgIsValid(const SliceProcessor * processor,const SliceHead * head,const char * data,uint32_t len)664 static int32_t ClientTransProxySliceProcessChkPkgIsValid(
665     const SliceProcessor *processor, const SliceHead *head, const char *data, uint32_t len)
666 {
667     (void)data;
668     if (head->sliceNum != processor->sliceNumber || head->sliceSeq != processor->expectedSeq) {
669         TRANS_LOGE(TRANS_SDK, "unmatched normal slice received, head sliceNum=%{public}d, sliceSeq=%{public}d,\
670             processor sliceNumber=%{public}d, expectedSeq=%{public}d", head->sliceNum,
671             head->sliceSeq, processor->sliceNumber, processor->expectedSeq);
672         return SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_NO_INVALID;
673     }
674     if (processor->dataLen > processor->bufLen || (int32_t)len > processor->bufLen - processor->dataLen) {
675         TRANS_LOGE(TRANS_SDK, "data len invalid %{public}u, %{public}d", len, processor->dataLen);
676         return SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_EXCEED_LENGTH;
677     }
678     if (processor->data == NULL) {
679         TRANS_LOGE(TRANS_SDK, "data NULL");
680         return SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_DATA_NULL;
681     }
682     return SOFTBUS_OK;
683 }
684 
ClientGetActualDataLen(const SliceHead * head,uint32_t * actualDataLen)685 static int32_t ClientGetActualDataLen(const SliceHead *head, uint32_t *actualDataLen)
686 {
687     uint32_t maxDataLen =
688         (head->priority == PROXY_CHANNEL_PRORITY_MESSAGE) ? g_proxyMaxMessageBufSize : g_proxyMaxByteBufSize;
689     // The encrypted data length is longer than the actual data length
690     maxDataLen += SLICE_LEN;
691 
692     if ((head->sliceNum < 0) || ((uint32_t)head->sliceNum > (maxDataLen / SLICE_LEN))) {
693         TRANS_LOGE(TRANS_SDK, "invalid sliceNum=%{public}d", head->sliceNum);
694         return SOFTBUS_INVALID_DATA_HEAD;
695     }
696 
697     *actualDataLen = head->sliceNum * SLICE_LEN;
698     return SOFTBUS_OK;
699 }
700 
ClientTransProxyFirstSliceProcess(SliceProcessor * processor,const SliceHead * head,const char * data,uint32_t len)701 static int32_t ClientTransProxyFirstSliceProcess(
702     SliceProcessor *processor, const SliceHead *head, const char *data, uint32_t len)
703 {
704     ClientTransProxyClearProcessor(processor);
705 
706     uint32_t actualDataLen = 0;
707     int32_t ret = ClientGetActualDataLen(head, &actualDataLen);
708     if (ret != SOFTBUS_OK) {
709         return ret;
710     }
711     uint32_t maxLen = actualDataLen + sizeof(PacketHead) + OVERHEAD_LEN;
712     processor->data = (char *)SoftBusCalloc(maxLen);
713     if (processor->data == NULL) {
714         TRANS_LOGE(TRANS_SDK, "malloc fail when proc first slice package");
715         return SOFTBUS_MALLOC_ERR;
716     }
717     processor->bufLen = (int32_t)maxLen;
718     if (memcpy_s(processor->data, maxLen, data, len) != EOK) {
719         TRANS_LOGE(TRANS_SDK, "memcpy fail when proc first slice package");
720         SoftBusFree(processor->data);
721         processor->data = NULL;
722         return SOFTBUS_MEM_ERR;
723     }
724     processor->sliceNumber = head->sliceNum;
725     processor->expectedSeq = 1;
726     processor->dataLen = (int32_t)len;
727     processor->active = true;
728     processor->timeout = 0;
729 
730     TRANS_LOGI(TRANS_SDK, "FirstSliceProcess ok");
731     return SOFTBUS_OK;
732 }
733 
IsValidCheckoutProcess(int32_t channelId)734 static bool IsValidCheckoutProcess(int32_t channelId)
735 {
736     ChannelSliceProcessor *processor = NULL;
737     LIST_FOR_EACH_ENTRY(processor, &g_channelSliceProcessorList->list, ChannelSliceProcessor, head) {
738         if (processor->channelId == channelId) {
739             return true;
740         }
741     }
742 
743     TRANS_LOGE(TRANS_SDK, "Process not exist.");
744     return false;
745 }
746 
ClientTransProxyLastSliceProcess(SliceProcessor * processor,const SliceHead * head,const char * data,uint32_t len,int32_t channelId)747 static int32_t ClientTransProxyLastSliceProcess(
748     SliceProcessor *processor, const SliceHead *head, const char *data, uint32_t len, int32_t channelId)
749 {
750     int32_t ret = ClientTransProxySliceProcessChkPkgIsValid(processor, head, data, len);
751     if (ret != SOFTBUS_OK) {
752         return ret;
753     }
754     if (memcpy_s(processor->data + processor->dataLen, (uint32_t)(processor->bufLen - processor->dataLen), data, len) !=
755         EOK) {
756         TRANS_LOGE(TRANS_SDK, "memcpy fail when proc last slice");
757         return SOFTBUS_MEM_ERR;
758     }
759     processor->expectedSeq++;
760     processor->dataLen += (int32_t)len;
761 
762     ret = ClientTransProxyNoSubPacketProc(channelId, processor->data, (uint32_t)processor->dataLen);
763     if (ret != SOFTBUS_OK) {
764         TRANS_LOGE(TRANS_SDK, "process packets err");
765         return ret;
766     }
767 
768     if (IsValidCheckoutProcess(channelId)) {
769         ClientTransProxyClearProcessor(processor);
770     }
771 
772     TRANS_LOGI(TRANS_SDK, "LastSliceProcess ok");
773     return ret;
774 }
775 
ClientTransProxyNormalSliceProcess(SliceProcessor * processor,const SliceHead * head,const char * data,uint32_t len)776 static int32_t ClientTransProxyNormalSliceProcess(
777     SliceProcessor *processor, const SliceHead *head, const char *data, uint32_t len)
778 {
779     int32_t ret = ClientTransProxySliceProcessChkPkgIsValid(processor, head, data, len);
780     if (ret != SOFTBUS_OK) {
781         return ret;
782     }
783     if (memcpy_s(processor->data + processor->dataLen,
784         (uint32_t)(processor->bufLen - processor->dataLen), data, len) != EOK) {
785         TRANS_LOGE(TRANS_SDK, "memcpy fail when proc normal slice");
786         return SOFTBUS_MEM_ERR;
787     }
788     processor->expectedSeq++;
789     processor->dataLen += (int32_t)len;
790     processor->timeout = 0;
791     TRANS_LOGI(TRANS_SDK, "NormalSliceProcess ok");
792     return ret;
793 }
794 
ClientTransProxySubPacketProc(int32_t channelId,const SliceHead * head,const char * data,uint32_t len)795 static int ClientTransProxySubPacketProc(int32_t channelId, const SliceHead *head, const char *data, uint32_t len)
796 {
797     if (g_channelSliceProcessorList == NULL) {
798         TRANS_LOGE(TRANS_SDK, "TransProxySubPacketProc not init");
799         return SOFTBUS_NO_INIT;
800     }
801     if (SoftBusMutexLock(&g_channelSliceProcessorList->lock) != SOFTBUS_OK) {
802         TRANS_LOGE(TRANS_SDK, "lock err");
803         return SOFTBUS_LOCK_ERR;
804     }
805 
806     ChannelSliceProcessor *channelProcessor = ClientTransProxyGetChannelSliceProcessor(channelId);
807     if (channelProcessor == NULL) {
808         SoftBusMutexUnlock(&g_channelSliceProcessorList->lock);
809         return SOFTBUS_TRANS_GET_CLIENT_PROXY_NULL;
810     }
811 
812     int ret;
813     int32_t index = head->priority;
814     SliceProcessor *processor = &(channelProcessor->processor[index]);
815     if (head->sliceSeq == 0) {
816         ret = ClientTransProxyFirstSliceProcess(processor, head, data, len);
817     } else if (head->sliceNum == head->sliceSeq + 1) {
818         ret = ClientTransProxyLastSliceProcess(processor, head, data, len, channelId);
819     } else {
820         ret = ClientTransProxyNormalSliceProcess(processor, head, data, len);
821     }
822 
823     SoftBusMutexUnlock(&g_channelSliceProcessorList->lock);
824     if (ret != SOFTBUS_OK) {
825         ClientTransProxyClearProcessor(processor);
826     }
827     return ret;
828 }
829 
ClientTransProxySliceProc(int32_t channelId,const char * data,uint32_t len)830 static int32_t ClientTransProxySliceProc(int32_t channelId, const char *data, uint32_t len)
831 {
832     if (data == NULL || len <= sizeof(SliceHead)) {
833         TRANS_LOGE(TRANS_SDK, "data null or len error. len=%{public}d", len);
834         return SOFTBUS_INVALID_PARAM;
835     }
836 
837     SliceHead headSlice = *(SliceHead *)data;
838     ClientUnPackSliceHead(&headSlice);
839     if (ClientTransProxyCheckSliceHead(&headSlice) != SOFTBUS_OK) {
840         TRANS_LOGE(TRANS_SDK, "invalid slihead");
841         return SOFTBUS_TRANS_PROXY_INVALID_SLICE_HEAD;
842     }
843 
844     uint32_t dataLen = len - sizeof(SliceHead);
845     if (headSlice.sliceNum == 1) { // no sub packets
846         TRANS_LOGD(TRANS_SDK, "no sub packets proc, channelId=%{public}d", channelId);
847         return ClientTransProxyNoSubPacketProc(channelId, data + sizeof(SliceHead), dataLen);
848     } else {
849         TRANS_LOGI(TRANS_SDK, "sub packets proc sliceNum=%{public}d", headSlice.sliceNum);
850         return ClientTransProxySubPacketProc(channelId, &headSlice, data + sizeof(SliceHead), dataLen);
851     }
852 }
853 
ClientTransProxySliceTimerProc(void)854 static void ClientTransProxySliceTimerProc(void)
855 {
856 #define SLICE_PACKET_TIMEOUT 10 // 10s
857     ChannelSliceProcessor *removeNode = NULL;
858     ChannelSliceProcessor *nextNode = NULL;
859 
860     if (g_channelSliceProcessorList == NULL || g_channelSliceProcessorList->cnt == 0) {
861         return;
862     }
863     if (SoftBusMutexLock(&g_channelSliceProcessorList->lock) != SOFTBUS_OK) {
864         TRANS_LOGE(TRANS_SDK, "TransProxySliceTimerProc lock mutex fail!");
865         return;
866     }
867 
868     LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_channelSliceProcessorList->list, ChannelSliceProcessor, head) {
869         for (int i = PROXY_CHANNEL_PRORITY_MESSAGE; i < PROXY_CHANNEL_PRORITY_BUTT; i++) {
870             if (removeNode->processor[i].active == true) {
871                 removeNode->processor[i].timeout++;
872                 if (removeNode->processor[i].timeout >= SLICE_PACKET_TIMEOUT) {
873                     TRANS_LOGE(TRANS_SDK, "timeout=%{public}d", removeNode->processor[i].timeout);
874                     ClientTransProxyClearProcessor(&removeNode->processor[i]);
875                 }
876             }
877         }
878     }
879     (void)SoftBusMutexUnlock(&g_channelSliceProcessorList->lock);
880     return;
881 }
882 
ClientTransProxyOnDataReceived(int32_t channelId,const void * data,uint32_t len,SessionPktType type)883 int32_t ClientTransProxyOnDataReceived(int32_t channelId, const void *data, uint32_t len, SessionPktType type)
884 {
885     (void)type;
886     if (data == NULL) {
887         TRANS_LOGE(TRANS_SDK, "ClientTransProxyOnDataReceived data null. channelId=%{public}d", channelId);
888         return SOFTBUS_INVALID_PARAM;
889     }
890 
891     ProxyChannelInfoDetail info;
892     if (ClientTransProxyGetInfoByChannelId(channelId, &info) != SOFTBUS_OK) {
893         return SOFTBUS_TRANS_PROXY_INVALID_CHANNEL_ID;
894     }
895     if (!info.isEncrypted) {
896         return g_sessionCb.OnDataReceived(channelId, CHANNEL_TYPE_PROXY, data, len, TRANS_SESSION_BYTES);
897     }
898 
899     return ClientTransProxySliceProc(channelId, (char *)data, len);
900 }
901 
ClientTransProxyCloseChannel(int32_t channelId)902 void ClientTransProxyCloseChannel(int32_t channelId)
903 {
904     (void)ClientTransProxyDelChannelInfo(channelId);
905     (void)TransProxyDelSliceProcessorByChannelId(channelId);
906     TRANS_LOGI(TRANS_SDK, "TransCloseProxyChannel, channelId=%{public}d", channelId);
907     if (ServerIpcCloseChannel(NULL, channelId, CHANNEL_TYPE_PROXY) != SOFTBUS_OK) {
908         TRANS_LOGE(TRANS_SDK, "server close err. channelId=%{public}d", channelId);
909     }
910 }
911 
ClientTransProxyPackBytes(int32_t channelId,ClientProxyDataInfo * dataInfo,int seq,char * sessionKey,SessionPktType flag)912 static int32_t ClientTransProxyPackBytes(
913     int32_t channelId, ClientProxyDataInfo *dataInfo, int seq, char *sessionKey, SessionPktType flag)
914 {
915 #define MAGIC_NUMBER 0xBABEFACE
916     if (dataInfo == NULL) {
917         return SOFTBUS_INVALID_PARAM;
918     }
919     dataInfo->outLen = dataInfo->inLen + OVERHEAD_LEN + sizeof(PacketHead);
920     dataInfo->outData = (uint8_t *)SoftBusCalloc(dataInfo->outLen);
921     if (dataInfo->outData == NULL) {
922         TRANS_LOGE(TRANS_SDK, "calloc error");
923         return SOFTBUS_MEM_ERR;
924     }
925 
926     uint32_t outLen = 0;
927     AesGcmCipherKey cipherKey = { 0 };
928     cipherKey.keyLen = SESSION_KEY_LENGTH;
929     if (memcpy_s(cipherKey.key, SESSION_KEY_LENGTH, sessionKey, SESSION_KEY_LENGTH) != EOK) {
930         TRANS_LOGE(TRANS_SDK, "memcpy key error.");
931         SoftBusFree(dataInfo->outData);
932         return SOFTBUS_MEM_ERR;
933     }
934     char *outData = (char *)dataInfo->outData + sizeof(PacketHead);
935     int32_t ret = SoftBusEncryptDataWithSeq(&cipherKey, (const unsigned char *)dataInfo->inData,
936         dataInfo->inLen, (unsigned char *)outData, &outLen, seq);
937     (void)memset_s(cipherKey.key, SESSION_KEY_LENGTH, 0, SESSION_KEY_LENGTH);
938 
939     if (ret != SOFTBUS_OK || outLen != dataInfo->inLen + OVERHEAD_LEN) {
940         TRANS_LOGE(TRANS_SDK, "encrypt error, ret=%{public}d", ret);
941         outData = NULL;
942         SoftBusFree(dataInfo->outData);
943         TRANS_LOGE(TRANS_SDK, "ClientTransProxyEncryptWithSeq channelId=%{public}d", channelId);
944         return SOFTBUS_TRANS_PROXY_SESS_ENCRYPT_ERR;
945     }
946     PacketHead *pktHead = (PacketHead *)dataInfo->outData;
947     pktHead->magicNumber = MAGIC_NUMBER;
948     pktHead->seq = seq;
949     pktHead->flags = flag;
950     pktHead->dataLen = (int32_t)((int32_t)dataInfo->outLen - sizeof(PacketHead));
951     ClientPackPacketHead(pktHead);
952 
953     return SOFTBUS_OK;
954 }
955 
SessionPktTypeToProxyIndex(SessionPktType packetType)956 static int32_t SessionPktTypeToProxyIndex(SessionPktType packetType)
957 {
958     switch (packetType) {
959         case TRANS_SESSION_MESSAGE:
960         case TRANS_SESSION_ASYNC_MESSAGE:
961         case TRANS_SESSION_ACK:
962             return PROXY_CHANNEL_PRORITY_MESSAGE;
963         case TRANS_SESSION_BYTES:
964             return PROXY_CHANNEL_PRORITY_BYTES;
965         default:
966             return PROXY_CHANNEL_PRORITY_FILE;
967     }
968 }
969 
TransProxyPackAndSendData(int32_t channelId,const void * data,uint32_t len,ProxyChannelInfoDetail * info,SessionPktType pktType)970 int32_t TransProxyPackAndSendData(
971     int32_t channelId, const void *data, uint32_t len, ProxyChannelInfoDetail *info, SessionPktType pktType)
972 {
973     if (data == NULL || info == NULL) {
974         return SOFTBUS_INVALID_PARAM;
975     }
976     ClientProxyDataInfo dataInfo = { (uint8_t *)data, len, (uint8_t *)data, len };
977     int32_t ret = ClientTransProxyPackBytes(channelId, &dataInfo, info->sequence, info->sessionKey, pktType);
978     if (ret != SOFTBUS_OK) {
979         TRANS_LOGE(TRANS_SDK, "ClientTransProxyPackBytes error, channelId=%{public}d", channelId);
980         return ret;
981     }
982 
983     uint32_t sliceNum = (dataInfo.outLen + (uint32_t)(SLICE_LEN - 1)) / (uint32_t)SLICE_LEN;
984     for (uint32_t i = 0; i < sliceNum; i++) {
985         uint32_t dataLen = (i == (sliceNum - 1U)) ? (dataInfo.outLen - i * SLICE_LEN) : SLICE_LEN;
986         int32_t offset = (int32_t)(i * SLICE_LEN);
987 
988         uint8_t *sliceData = (uint8_t *)SoftBusCalloc(dataLen + sizeof(SliceHead));
989         if (sliceData == NULL) {
990             TRANS_LOGE(TRANS_SDK, "malloc slice data error, channelId=%{public}d", channelId);
991             SoftBusFree(dataInfo.outData);
992             return SOFTBUS_MALLOC_ERR;
993         }
994         SliceHead *slicehead = (SliceHead *)sliceData;
995         slicehead->priority = SessionPktTypeToProxyIndex(pktType);
996         if (sliceNum > INT32_MAX) {
997             TRANS_LOGE(TRANS_FILE, "Data overflow");
998             SoftBusFree(sliceData);
999             SoftBusFree(dataInfo.outData);
1000             return SOFTBUS_INVALID_NUM;
1001         }
1002         slicehead->sliceNum = (int32_t)sliceNum;
1003         slicehead->sliceSeq = (int32_t)i;
1004         ClientPackSliceHead(slicehead);
1005         if (memcpy_s(sliceData + sizeof(SliceHead), dataLen, dataInfo.outData + offset, dataLen) != EOK) {
1006             TRANS_LOGE(TRANS_SDK, "memcpy_s error, channelId=%{public}d", channelId);
1007             SoftBusFree(sliceData);
1008             SoftBusFree(dataInfo.outData);
1009             return SOFTBUS_MEM_ERR;
1010         }
1011 
1012         int ret = ServerIpcSendMessage(channelId, CHANNEL_TYPE_PROXY, sliceData, dataLen + sizeof(SliceHead), pktType);
1013         if (ret != SOFTBUS_OK) {
1014             TRANS_LOGE(TRANS_SDK, "ServerIpcSendMessage error, channelId=%{public}d, ret=%{public}d", channelId, ret);
1015             SoftBusFree(sliceData);
1016             SoftBusFree(dataInfo.outData);
1017             return ret;
1018         }
1019 
1020         SoftBusFree(sliceData);
1021     }
1022     SoftBusFree(dataInfo.outData);
1023 
1024     TRANS_LOGI(TRANS_SDK, "TransProxyPackAndSendData success, channelId=%{public}d", channelId);
1025     return SOFTBUS_OK;
1026 }
1027 
TransProxyChannelSendBytes(int32_t channelId,const void * data,uint32_t len)1028 int32_t TransProxyChannelSendBytes(int32_t channelId, const void *data, uint32_t len)
1029 {
1030     ProxyChannelInfoDetail info;
1031     int32_t ret = ClientTransProxyGetInfoByChannelId(channelId, &info);
1032     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SDK, "get info fail!");
1033 
1034     if (!info.isEncrypted) {
1035         ret = ServerIpcSendMessage(channelId, CHANNEL_TYPE_PROXY, data, len, TRANS_SESSION_BYTES);
1036         TRANS_LOGI(TRANS_SDK, "send bytes: channelId=%{public}d, ret=%{public}d", channelId, ret);
1037         return ret;
1038     }
1039 
1040     return TransProxyPackAndSendData(channelId, data, len, &info, TRANS_SESSION_BYTES);
1041 }
1042 
TransProxyChannelSendMessage(int32_t channelId,const void * data,uint32_t len)1043 int32_t TransProxyChannelSendMessage(int32_t channelId, const void *data, uint32_t len)
1044 {
1045     ProxyChannelInfoDetail info;
1046     int32_t ret = ClientTransProxyGetInfoByChannelId(channelId, &info);
1047     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SDK, "get info fail!");
1048 
1049     if (!info.isEncrypted) {
1050         // auth channel only can send bytes
1051         ret = ServerIpcSendMessage(channelId, CHANNEL_TYPE_PROXY, data, len, TRANS_SESSION_BYTES);
1052         TRANS_LOGI(TRANS_SDK, "send msg: channelId=%{public}d, ret=%{public}d", channelId, ret);
1053         return ret;
1054     }
1055 
1056     ret = AddPendingPacket(channelId, info.sequence, PENDING_TYPE_PROXY);
1057     if (ret != SOFTBUS_OK) {
1058         TRANS_LOGE(TRANS_SDK, "add pending packet failed, channelId=%{public}d.", channelId);
1059         return ret;
1060     }
1061     ret = TransProxyPackAndSendData(channelId, data, len, &info, TRANS_SESSION_MESSAGE);
1062     if (ret != SOFTBUS_OK) {
1063         DelPendingPacketbyChannelId(channelId, info.sequence, PENDING_TYPE_PROXY);
1064         return ret;
1065     }
1066     TRANS_LOGI(TRANS_SDK, "send msg: channelId=%{public}d, seq=%{public}d", channelId, info.sequence);
1067     return ProcPendingPacket(channelId, info.sequence, PENDING_TYPE_PROXY);
1068 }
1069 
ClientTransProxyOnChannelBind(int32_t channelId,int32_t channelType)1070 int32_t ClientTransProxyOnChannelBind(int32_t channelId, int32_t channelType)
1071 {
1072     if (g_sessionCb.OnChannelBind == NULL) {
1073         TRANS_LOGE(TRANS_SDK, "OnChannelBind is null, channelId=%{public}d.", channelId);
1074         return SOFTBUS_INVALID_PARAM;
1075     }
1076     int32_t ret = g_sessionCb.OnChannelBind(channelId, channelType);
1077     if (ret == SOFTBUS_NOT_NEED_UPDATE) {
1078         return SOFTBUS_OK;
1079     }
1080     if (ret != SOFTBUS_OK) {
1081         TRANS_LOGE(TRANS_SDK, "notify OnChannelBind openfail channelId=%{public}d.", channelId);
1082         return ret;
1083     }
1084 
1085     return SOFTBUS_OK;
1086 }
1087