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