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 "softbus_proxychannel_session.h"
17
18 #include <securec.h>
19
20 #include "softbus_adapter_crypto.h"
21 #include "softbus_adapter_mem.h"
22 #include "softbus_adapter_socket.h"
23 #include "softbus_adapter_thread.h"
24 #include "softbus_errcode.h"
25 #include "softbus_log.h"
26 #include "softbus_property.h"
27 #include "softbus_proxychannel_callback.h"
28 #include "softbus_proxychannel_manager.h"
29 #include "softbus_proxychannel_message.h"
30 #include "softbus_proxychannel_transceiver.h"
31 #include "softbus_socket.h"
32 #include "softbus_transmission_interface.h"
33 #include "softbus_utils.h"
34 #include "trans_pending_pkt.h"
35 #include "softbus_datahead_transform.h"
36
37 #define MSG_SLICE_HEAD_LEN (sizeof(SliceHead) + sizeof(ProxyMessageHead))
38 #define PROXY_ACK_SIZE 4
39 #define TIME_OUT 10
40 #define USECTONSEC 1000
41 #define PACK_HEAD_LEN (sizeof(PacketHead))
42 #define DATA_HEAD_SIZE (4 * 1024) // donot knoe bytes 1024 or message (4 * 1024)
43
44 typedef struct {
45 int32_t priority;
46 int32_t sliceNum;
47 int32_t sliceSeq;
48 int32_t reserved;
49 } SliceHead;
50
51 typedef struct {
52 int32_t magicNumber;
53 int32_t seq;
54 int32_t flags;
55 int32_t dataLen;
56 } PacketHead;
57
58 static SoftBusList *g_channelSliceProcessorList = NULL;
59 int32_t TransProxyTransDataSendMsg(int32_t channelId, const char *payLoad, int payLoadLen, ProxyPacketType flag);
60
PackSliceHead(SliceHead * data)61 void PackSliceHead(SliceHead *data)
62 {
63 data->priority = (int32_t)SoftBusHtoLl((uint32_t)data->priority);
64 data->sliceNum = (int32_t)SoftBusHtoLl((uint32_t)data->sliceNum);
65 data->sliceSeq = (int32_t)SoftBusHtoLl((uint32_t)data->sliceSeq);
66 data->reserved = (int32_t)SoftBusHtoLl((uint32_t)data->reserved);
67 }
68
UnPackSliceHead(SliceHead * data)69 void UnPackSliceHead(SliceHead *data)
70 {
71 data->priority = (int32_t)SoftBusLtoHl((uint32_t)data->priority);
72 data->sliceNum = (int32_t)SoftBusLtoHl((uint32_t)data->sliceNum);
73 data->sliceSeq = (int32_t)SoftBusLtoHl((uint32_t)data->sliceSeq);
74 data->reserved = (int32_t)SoftBusLtoHl((uint32_t)data->reserved);
75 }
76
PackPacketHead(PacketHead * data)77 void PackPacketHead(PacketHead *data)
78 {
79 data->magicNumber = (int32_t)SoftBusHtoLl((uint32_t)data->magicNumber);
80 data->seq = (int32_t)SoftBusHtoLl((uint32_t)data->seq);
81 data->flags = (int32_t)SoftBusHtoLl((uint32_t)data->flags);
82 data->dataLen = (int32_t)SoftBusHtoLl((uint32_t)data->dataLen);
83 }
84
UnPackPacketHead(PacketHead * data)85 void UnPackPacketHead(PacketHead *data)
86 {
87 data->magicNumber = (int32_t)SoftBusLtoHl((uint32_t)data->magicNumber);
88 data->seq = (int32_t)SoftBusLtoHl((uint32_t)data->seq);
89 data->flags = (int32_t)SoftBusLtoHl((uint32_t)data->flags);
90 data->dataLen = (int32_t)SoftBusLtoHl((uint32_t)data->dataLen);
91 }
92
NotifyClientMsgReceived(const char * pkgName,int32_t channelId,const char * data,uint32_t len,SessionPktType type)93 int32_t NotifyClientMsgReceived(const char *pkgName, int32_t channelId, const char *data, uint32_t len,
94 SessionPktType type)
95 {
96 int32_t ret = TransProxyOnMsgReceived(pkgName, channelId, data, len, type);
97 if (ret != SOFTBUS_OK) {
98 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "notify err[%d]", ret);
99 }
100 return ret;
101 }
102
ProxyTypeToProxyIndex(ProxyPacketType packetType)103 int32_t ProxyTypeToProxyIndex(ProxyPacketType packetType)
104 {
105 switch (packetType) {
106 case PROXY_FLAG_MESSAGE:
107 case PROXY_FLAG_ASYNC_MESSAGE:
108 case PROXY_FLAG_ACK:
109 return PROXY_CHANNEL_PRORITY_MESSAGE;
110 case PROXY_FLAG_BYTES:
111 return PROXY_CHANNEL_PRORITY_BYTES;
112 default:
113 return PROXY_CHANNEL_PRORITY_FILE;
114 }
115 }
116
SessionTypeToPacketType(SessionPktType sessionType)117 ProxyPacketType SessionTypeToPacketType(SessionPktType sessionType)
118 {
119 switch (sessionType) {
120 case TRANS_SESSION_BYTES:
121 return PROXY_FLAG_BYTES;
122 case TRANS_SESSION_MESSAGE:
123 return PROXY_FLAG_MESSAGE;
124 case TRANS_SESSION_FILE_FIRST_FRAME:
125 return PROXY_FILE_FIRST_FRAME;
126 case TRANS_SESSION_FILE_ONGOINE_FRAME:
127 return PROXY_FILE_ONGOINE_FRAME;
128 case TRANS_SESSION_FILE_LAST_FRAME:
129 return PROXY_FILE_LAST_FRAME;
130 case TRANS_SESSION_FILE_ONLYONE_FRAME:
131 return PROXY_FILE_ONLYONE_FRAME;
132 case TRANS_SESSION_FILE_ALLFILE_SENT:
133 return PROXY_FILE_ALLFILE_SENT;
134 case TRANS_SESSION_FILE_CRC_CHECK_FRAME:
135 return PROXY_FILE_CRC_CHECK_FRAME;
136 case TRANS_SESSION_FILE_RESULT_FRAME:
137 return PROXY_FILE_RESULT_FRAME;
138 case TRANS_SESSION_FILE_ACK_REQUEST_SENT:
139 return PROXY_FILE_ACK_REQUEST_SENT;
140 case TRANS_SESSION_FILE_ACK_RESPONSE_SENT:
141 return PROXY_FILE_ACK_RESPONSE_SENT;
142 default:
143 return PROXY_FLAG_BYTES;
144 }
145 }
146
ProxyTypeToConnPri(ProxyPacketType proxyType)147 SendPriority ProxyTypeToConnPri(ProxyPacketType proxyType)
148 {
149 switch (proxyType) {
150 case PROXY_FLAG_BYTES:
151 return CONN_MIDDLE;
152 case PROXY_FLAG_MESSAGE:
153 case PROXY_FLAG_ASYNC_MESSAGE:
154 case PROXY_FLAG_ACK:
155 return CONN_HIGH;
156 default:
157 return CONN_DEFAULT;
158 }
159 }
160
TransProxyEncryptPacketData(int32_t channelId,int32_t seq,ProxyDataInfo * dataInfo)161 static int32_t TransProxyEncryptPacketData(int32_t channelId, int32_t seq, ProxyDataInfo *dataInfo)
162 {
163 char sessionKey[SESSION_KEY_LENGTH] = {0};
164 AesGcmCipherKey cipherKey = {0};
165 uint32_t checkLen;
166
167 if (TransProxyGetSessionKeyByChanId(channelId, sessionKey, sizeof(sessionKey)) != SOFTBUS_OK) {
168 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get channelId(%d) session key err", channelId);
169 return SOFTBUS_ERR;
170 }
171
172 checkLen = dataInfo->inLen + OVERHEAD_LEN;
173 cipherKey.keyLen = SESSION_KEY_LENGTH;
174 if (memcpy_s(cipherKey.key, SESSION_KEY_LENGTH, sessionKey, SESSION_KEY_LENGTH) != EOK) {
175 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "memcpy_s key error.");
176 return SOFTBUS_ERR;
177 }
178 (void)memset_s(sessionKey, sizeof(sessionKey), 0, sizeof(sessionKey));
179 int32_t ret = SoftBusEncryptDataWithSeq(&cipherKey, dataInfo->inData, dataInfo->inLen,
180 dataInfo->outData, &(dataInfo->outLen), seq);
181 (void)memset_s(&cipherKey, sizeof(AesGcmCipherKey), 0, sizeof(AesGcmCipherKey));
182 if (ret != SOFTBUS_OK || dataInfo->outLen != checkLen) {
183 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Trans Proxy encrypt error. %d ", ret);
184 return SOFTBUS_ENCRYPT_ERR;
185 }
186 return SOFTBUS_OK;
187 }
188
TransProxyDecryptPacketData(int32_t channelId,int32_t seq,ProxyDataInfo * dataInfo)189 static int32_t TransProxyDecryptPacketData(int32_t channelId, int32_t seq, ProxyDataInfo *dataInfo)
190 {
191 char sessionKey[SESSION_KEY_LENGTH] = {0};
192 AesGcmCipherKey cipherKey = {0};
193 int32_t ret = SOFTBUS_ERR;
194
195 if (TransProxyGetSessionKeyByChanId(channelId, sessionKey, sizeof(sessionKey)) != SOFTBUS_OK) {
196 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "DecryptPacket get chan fail channid %d.", channelId);
197 return SOFTBUS_ERR;
198 }
199 cipherKey.keyLen = SESSION_KEY_LENGTH; // 256 bit encryption
200 if (memcpy_s(cipherKey.key, SESSION_KEY_LENGTH, sessionKey, SESSION_KEY_LENGTH) != EOK) {
201 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "memcpy key error.");
202 return SOFTBUS_ERR;
203 }
204 (void)memset_s(sessionKey, sizeof(sessionKey), 0, sizeof(sessionKey));
205 ret = SoftBusDecryptDataWithSeq(&cipherKey, dataInfo->inData, dataInfo->inLen,
206 dataInfo->outData, &(dataInfo->outLen), seq);
207 (void)memset_s(&cipherKey, sizeof(AesGcmCipherKey), 0, sizeof(AesGcmCipherKey));
208 if (ret != SOFTBUS_OK) {
209 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "trans proxy Decrypt Data fail. %d ", ret);
210 return SOFTBUS_ERR;
211 }
212 return SOFTBUS_OK;
213 }
214
TransProxyGetPktSeqId(int32_t channelId,const ProxyDataInfo * dataInfo,ProxyPacketType flag)215 static int32_t TransProxyGetPktSeqId(int32_t channelId, const ProxyDataInfo *dataInfo, ProxyPacketType flag)
216 {
217 int32_t seq = 0;
218
219 if (flag == PROXY_FLAG_ACK) {
220 if (memcpy_s(&seq, sizeof(seq), dataInfo->inData, dataInfo->inLen) == EOK) {
221 return seq;
222 }
223 }
224 return TransProxyGetNewChanSeq(channelId);
225 }
226
TransProxyPackBytes(int32_t channelId,ProxyDataInfo * dataInfo,ProxyPacketType flag,int32_t * outseq)227 static int32_t TransProxyPackBytes(int32_t channelId, ProxyDataInfo *dataInfo, ProxyPacketType flag, int32_t *outseq)
228 {
229 #define MAGIC_NUMBER 0xBABEFACE
230 uint32_t outBufLen;
231 uint8_t *outBuf = NULL;
232 PacketHead *pktHead = NULL;
233 ProxyDataInfo enDataInfo = {0};
234 int32_t seq;
235
236 if (dataInfo == NULL) {
237 return SOFTBUS_ERR;
238 }
239 outBufLen = dataInfo->inLen + OVERHEAD_LEN + sizeof(PacketHead);
240 outBuf = SoftBusCalloc(outBufLen);
241 if (outBuf == NULL) {
242 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "calloc error");
243 return SOFTBUS_MEM_ERR;
244 }
245 seq = TransProxyGetPktSeqId(channelId, dataInfo, flag);
246 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "trans proxy send packet seq %d flag %d", seq, flag);
247 enDataInfo.outData = outBuf + sizeof(PacketHead);
248 enDataInfo.outLen = outBufLen - sizeof(PacketHead);
249
250 enDataInfo.inData = dataInfo->inData;
251 enDataInfo.inLen = dataInfo->inLen;
252 if (TransProxyEncryptPacketData(channelId, seq, &enDataInfo) != SOFTBUS_OK) {
253 SoftBusFree(outBuf);
254 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "tran pack encrypt data fail. channid %d", channelId);
255 return SOFTBUS_TRANS_PROXY_SESS_ENCRYPT_ERR;
256 }
257 pktHead = (PacketHead*)outBuf;
258 pktHead->magicNumber = MAGIC_NUMBER;
259 pktHead->seq = seq;
260 pktHead->flags = flag;
261 pktHead->dataLen = (int32_t)enDataInfo.outLen;
262 PackPacketHead(pktHead);
263 *outseq = seq;
264 dataInfo->outData = outBuf;
265 dataInfo->outLen = outBufLen;
266 return SOFTBUS_OK;
267 }
268
TransProxyProcSendMsgAck(int32_t channelId,const char * data,int32_t len)269 static int32_t TransProxyProcSendMsgAck(int32_t channelId, const char *data, int32_t len)
270 {
271 int32_t seq;
272
273 if (len != PROXY_ACK_SIZE) {
274 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
275 }
276 if (data == NULL) {
277 return SOFTBUS_ERR;
278 }
279 seq = *(int32_t *)data;
280 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "TransProxyProcSendMsgAck. chanid %d,seq :%d", channelId, seq);
281 return SetPendingPacket(channelId, seq, PENDING_TYPE_PROXY);
282 }
283
TransProxyTransDataSendSyncMsg(int32_t channelId,const char * payLoad,int payLoadLen,ProxyPacketType flag,int32_t seq)284 static int32_t TransProxyTransDataSendSyncMsg(int32_t channelId, const char *payLoad, int payLoadLen,
285 ProxyPacketType flag, int32_t seq)
286 {
287 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "send syncmsg chanid[%d] seq[%d] dataLen[%d] type[%d]",
288 channelId, seq, payLoadLen, flag);
289 int32_t ret = TransProxyTransDataSendMsg(channelId, payLoad, payLoadLen, flag);
290 if (ret != SOFTBUS_OK) {
291 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxyTransDataSendSyncMsg err,ret :%d", ret);
292 return ret;
293 }
294 ret = ProcPendingPacket(channelId, seq, PENDING_TYPE_PROXY);
295 if (ret != SOFTBUS_OK) {
296 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "proxy send sync msg fail.[%d]", ret);
297 }
298 return ret;
299 }
300
TransProxyPostPacketData(int32_t channelId,const unsigned char * data,uint32_t len,ProxyPacketType flags)301 int32_t TransProxyPostPacketData(int32_t channelId, const unsigned char *data, uint32_t len, ProxyPacketType flags)
302 {
303 ProxyDataInfo packDataInfo = {0};
304 int32_t ret = SOFTBUS_ERR;
305 int32_t seq = 0;
306
307 if (data == NULL) {
308 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid para");
309 return SOFTBUS_INVALID_PARAM;
310 }
311
312 packDataInfo.inData = (unsigned char *)data;
313 packDataInfo.inLen = len;
314 ProxyChannelInfo *chanInfo = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
315 if (chanInfo == NULL) {
316 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "malloc in TransProxyPostPacketData.id[%d]", channelId);
317 return SOFTBUS_MALLOC_ERR;
318 }
319 if (TransProxyGetSendMsgChanInfo(channelId, chanInfo) != SOFTBUS_OK) {
320 SoftBusFree(chanInfo);
321 return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND;
322 }
323 AppType appType = chanInfo->appInfo.appType;
324 SoftBusFree(chanInfo);
325 if (appType != APP_TYPE_AUTH) {
326 ret = TransProxyPackBytes(channelId, &packDataInfo, flags, &seq);
327 if (ret != SOFTBUS_OK) {
328 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "PackBytes err");
329 return ret;
330 }
331 } else {
332 packDataInfo.outData = (uint8_t *)data;
333 packDataInfo.outLen = len;
334 if (flags == PROXY_FLAG_MESSAGE) {
335 flags = PROXY_FLAG_BYTES;
336 }
337 }
338 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "InLen[%d] seq[%d] outLen[%d] flags[%d]",
339 len, seq, packDataInfo.outLen, flags);
340 if (flags == PROXY_FLAG_MESSAGE) {
341 ret = TransProxyTransDataSendSyncMsg(channelId, (char *)packDataInfo.outData,
342 (int32_t)packDataInfo.outLen, flags, seq);
343 } else {
344 ret = TransProxyTransDataSendMsg(channelId, (char *)packDataInfo.outData, (int32_t)packDataInfo.outLen, flags);
345 }
346 if (appType != APP_TYPE_AUTH) {
347 SoftBusFree(packDataInfo.outData);
348 }
349 return ret;
350 }
351
TransProxyPostSessionData(int32_t channelId,const unsigned char * data,uint32_t len,SessionPktType flags)352 int32_t TransProxyPostSessionData(int32_t channelId, const unsigned char *data, uint32_t len, SessionPktType flags)
353 {
354 ProxyPacketType type = SessionTypeToPacketType(flags);
355 return TransProxyPostPacketData(channelId, data, len, type);
356 }
TransProxyGetBufLen(void)357 static int32_t TransProxyGetBufLen(void)
358 {
359 #define MAX_SEND_LENGTH 1024
360 return MAX_SEND_LENGTH;
361 }
362
TransProxyPackAppNormalMsg(const ProxyMessageHead * msg,const SliceHead * sliceHead,const char * payLoad,int32_t datalen,int32_t * outlen)363 static char *TransProxyPackAppNormalMsg(const ProxyMessageHead *msg, const SliceHead *sliceHead, const char *payLoad,
364 int32_t datalen, int32_t *outlen)
365 {
366 char *buf = NULL;
367 uint32_t dstLen;
368 ProxyMessageHead proxyMessageHead;
369 SliceHead sliceHeadTemp;
370 uint32_t connHeadLen = ConnGetHeadSize();
371 uint32_t bufLen = PROXY_CHANNEL_HEAD_LEN + connHeadLen + (uint32_t)datalen;
372 if (sliceHead != NULL) {
373 bufLen += sizeof(SliceHead);
374 }
375 buf = (char*)SoftBusCalloc(bufLen);
376 if (buf == NULL) {
377 return NULL;
378 }
379 if (memcpy_s(&proxyMessageHead, sizeof(ProxyMessageHead), msg, sizeof(ProxyMessageHead)) != EOK) {
380 SoftBusFree(buf);
381 return NULL;
382 }
383 PackProxyMessageHead(&proxyMessageHead);
384 if (memcpy_s(buf + connHeadLen, bufLen - connHeadLen, &proxyMessageHead, sizeof(ProxyMessageHead)) != EOK) {
385 SoftBusFree(buf);
386 return NULL;
387 }
388 if (sliceHead != NULL) {
389 dstLen = bufLen - connHeadLen - sizeof(ProxyMessageHead);
390 if (memcpy_s(&sliceHeadTemp, sizeof(SliceHead), sliceHead, sizeof(SliceHead)) != EOK) {
391 SoftBusFree(buf);
392 return NULL;
393 }
394 PackSliceHead(&sliceHeadTemp);
395 if (memcpy_s(buf + connHeadLen + sizeof(ProxyMessageHead), dstLen, &sliceHeadTemp, sizeof(SliceHead)) != EOK) {
396 SoftBusFree(buf);
397 return NULL;
398 }
399 dstLen = bufLen - connHeadLen - MSG_SLICE_HEAD_LEN;
400 if (memcpy_s(buf + connHeadLen + MSG_SLICE_HEAD_LEN, dstLen, payLoad, datalen) != EOK) {
401 SoftBusFree(buf);
402 return NULL;
403 }
404 } else {
405 dstLen = bufLen - connHeadLen - sizeof(ProxyMessageHead);
406 if (memcpy_s(buf + connHeadLen + sizeof(ProxyMessageHead), dstLen, payLoad, datalen) != EOK) {
407 SoftBusFree(buf);
408 return NULL;
409 }
410 }
411
412 *outlen = (int32_t)bufLen;
413 return buf;
414 }
415
TransProxyTransAuthMsg(const ProxyChannelInfo * info,const char * payLoad,int payLoadLen,ProxyPacketType flag)416 static int32_t TransProxyTransAuthMsg(const ProxyChannelInfo *info, const char *payLoad, int payLoadLen,
417 ProxyPacketType flag)
418 {
419 ProxyMessageHead msgHead = {0};
420 msgHead.type = (PROXYCHANNEL_MSG_TYPE_NORMAL & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
421 msgHead.myId = info->myId;
422 msgHead.peerId = info->peerId;
423 int bufLen = 0;
424 char *buf = TransProxyPackAppNormalMsg(&msgHead, NULL, payLoad, payLoadLen, &bufLen);
425 if (buf == NULL) {
426 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy pack msg error");
427 return SOFTBUS_TRANS_PROXY_PACKMSG_ERR;
428 }
429 int32_t ret = TransProxyTransSendMsg(info->connId, (uint8_t *)buf, (uint32_t)bufLen,
430 ProxyTypeToConnPri(flag), info->appInfo.myData.pid);
431 if (ret == SOFTBUS_CONNECTION_ERR_SENDQUEUE_FULL) {
432 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy send queue full!!");
433 return SOFTBUS_CONNECTION_ERR_SENDQUEUE_FULL;
434 }
435 if (ret != SOFTBUS_OK) {
436 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy send msg error");
437 return SOFTBUS_TRANS_PROXY_SENDMSG_ERR;
438 }
439 return SOFTBUS_OK;
440 }
441
TransProxyTransAppNormalMsg(const ProxyChannelInfo * info,const char * payLoad,int payLoadLen,ProxyPacketType flag)442 static int32_t TransProxyTransAppNormalMsg(const ProxyChannelInfo *info, const char *payLoad, int payLoadLen,
443 ProxyPacketType flag)
444 {
445 int32_t dataLen;
446 int32_t offset;
447 int32_t singleLen;
448 int32_t sliceNum;
449
450 singleLen = TransProxyGetBufLen();
451 if (singleLen <= 0) {
452 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "getBuflen msg error");
453 return SOFTBUS_ERR;
454 }
455 sliceNum = (payLoadLen + singleLen - 1) / singleLen;
456 ProxyMessageHead msgHead = {0};
457 msgHead.type = (PROXYCHANNEL_MSG_TYPE_NORMAL & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
458 msgHead.myId = info->myId;
459 msgHead.peerId = info->peerId;
460 for (int i = 0; i < sliceNum; i++) {
461 char *buf = NULL;
462 int bufLen = 0;
463 SliceHead slicehead = {0};
464 slicehead.priority = ProxyTypeToProxyIndex(flag);
465 slicehead.sliceNum = sliceNum;
466 slicehead.sliceSeq = i;
467 if (sliceNum > 1) {
468 dataLen = (i == (sliceNum - 1)) ? (payLoadLen - i * MAX_SEND_LENGTH) : MAX_SEND_LENGTH;
469 offset = i * MAX_SEND_LENGTH;
470 } else {
471 dataLen = payLoadLen;
472 offset = 0;
473 }
474
475 buf = TransProxyPackAppNormalMsg(&msgHead, &slicehead, payLoad + offset, dataLen, &bufLen);
476 if (buf == NULL) {
477 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack msg error");
478 return SOFTBUS_TRANS_PROXY_PACKMSG_ERR;
479 }
480 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "slice: i:%d", i);
481 int32_t ret = TransProxyTransSendMsg(info->connId, (uint8_t *)buf, (uint32_t)bufLen,
482 ProxyTypeToConnPri(flag), info->appInfo.myData.pid);
483 if (ret == SOFTBUS_CONNECTION_ERR_SENDQUEUE_FULL) {
484 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "normal proxy send queue full!!");
485 return SOFTBUS_CONNECTION_ERR_SENDQUEUE_FULL;
486 } else if (ret != SOFTBUS_OK) {
487 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "normal proxy send msg error");
488 return SOFTBUS_TRANS_PROXY_SENDMSG_ERR;
489 }
490 }
491 return SOFTBUS_OK;
492 }
493
TransProxyTransDataSendMsg(int32_t channelId,const char * payLoad,int payLoadLen,ProxyPacketType flag)494 int32_t TransProxyTransDataSendMsg(int32_t channelId, const char *payLoad, int payLoadLen, ProxyPacketType flag)
495 {
496 int ret = SOFTBUS_ERR;
497 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
498 if (info == NULL) {
499 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "malloc fail when trans proxy trans data");
500 return SOFTBUS_MALLOC_ERR;
501 }
502 if (TransProxyGetSendMsgChanInfo(channelId, info) != SOFTBUS_OK) {
503 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get channelId err %d", channelId);
504 ret = SOFTBUS_TRANS_PROXY_SEND_CHANNELID_INVALID;
505 goto EXIT;
506 }
507
508 if ((info->status != PROXY_CHANNEL_STATUS_COMPLETED && info->status != PROXY_CHANNEL_STATUS_KEEPLIVEING)) {
509 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "status is err %d", info->status);
510 ret = SOFTBUS_TRANS_PROXY_CHANNLE_STATUS_INVALID;
511 goto EXIT;
512 }
513 if (info->appInfo.appType == APP_TYPE_AUTH) {
514 ret = TransProxyTransAuthMsg(info, payLoad, payLoadLen, flag);
515 } else {
516 ret = TransProxyTransAppNormalMsg(info, payLoad, payLoadLen, flag);
517 }
518 if (ret != SOFTBUS_OK) {
519 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack msg error");
520 goto EXIT;
521 }
522 EXIT:
523 SoftBusFree(info);
524 return ret;
525 }
526
TransProxySendSessionAck(int32_t channelId,int32_t seq)527 static void TransProxySendSessionAck(int32_t channelId, int32_t seq)
528 {
529 #define PROXY_ACK_SIZE 4
530 unsigned char ack[PROXY_ACK_SIZE] = {0};
531 if (memcpy_s(ack, PROXY_ACK_SIZE, &seq, sizeof(int32_t)) != EOK) {
532 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "memcpy seq err");
533 }
534 if (TransProxyPostPacketData(channelId, ack, PROXY_ACK_SIZE, PROXY_FLAG_ACK) != SOFTBUS_OK) {
535 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "send ack err, seq = %d", seq);
536 }
537 }
538
PacketTypeToSessionType(ProxyPacketType pktType)539 static SessionPktType PacketTypeToSessionType(ProxyPacketType pktType)
540 {
541 switch (pktType) {
542 case PROXY_FLAG_BYTES:
543 return TRANS_SESSION_BYTES;
544 case PROXY_FLAG_MESSAGE:
545 return TRANS_SESSION_MESSAGE;
546 case PROXY_FILE_FIRST_FRAME:
547 return TRANS_SESSION_FILE_FIRST_FRAME;
548 case PROXY_FILE_ONGOINE_FRAME:
549 return TRANS_SESSION_FILE_ONGOINE_FRAME;
550 case PROXY_FILE_LAST_FRAME:
551 return TRANS_SESSION_FILE_LAST_FRAME;
552 case PROXY_FILE_ONLYONE_FRAME:
553 return TRANS_SESSION_FILE_ONLYONE_FRAME;
554 case PROXY_FILE_ALLFILE_SENT:
555 return TRANS_SESSION_FILE_ALLFILE_SENT;
556 case PROXY_FILE_CRC_CHECK_FRAME:
557 return TRANS_SESSION_FILE_CRC_CHECK_FRAME;
558 case PROXY_FILE_RESULT_FRAME:
559 return TRANS_SESSION_FILE_RESULT_FRAME;
560 case PROXY_FILE_ACK_REQUEST_SENT:
561 return TRANS_SESSION_FILE_ACK_REQUEST_SENT;
562 case PROXY_FILE_ACK_RESPONSE_SENT:
563 return TRANS_SESSION_FILE_ACK_RESPONSE_SENT;
564 default:
565 return TRANS_SESSION_BYTES;
566 }
567 }
568
TransProxyNotifySession(const char * pkgName,int32_t channelId,ProxyPacketType flags,int32_t seq,const char * data,uint32_t len)569 int32_t TransProxyNotifySession(const char *pkgName, int32_t channelId, ProxyPacketType flags, int32_t seq,
570 const char *data, uint32_t len)
571 {
572 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "flags:%d", flags);
573 switch (flags) {
574 case PROXY_FLAG_BYTES:
575 return NotifyClientMsgReceived(pkgName, channelId, data, len, TRANS_SESSION_BYTES);
576 case PROXY_FLAG_MESSAGE:
577 TransProxySendSessionAck(channelId, seq);
578 return NotifyClientMsgReceived(pkgName, channelId, data, len, TRANS_SESSION_MESSAGE);
579 case PROXY_FLAG_ASYNC_MESSAGE:
580 return NotifyClientMsgReceived(pkgName, channelId, data, len, TRANS_SESSION_MESSAGE);
581 case PROXY_FLAG_ACK:
582 return TransProxyProcSendMsgAck(channelId, data, (int32_t)len);
583 case PROXY_FILE_FIRST_FRAME:
584 case PROXY_FILE_ONGOINE_FRAME:
585 case PROXY_FILE_LAST_FRAME:
586 case PROXY_FILE_ONLYONE_FRAME:
587 case PROXY_FILE_ALLFILE_SENT:
588 case PROXY_FILE_CRC_CHECK_FRAME:
589 case PROXY_FILE_RESULT_FRAME:
590 case PROXY_FILE_ACK_REQUEST_SENT:
591 case PROXY_FILE_ACK_RESPONSE_SENT:
592 return NotifyClientMsgReceived(pkgName, channelId, data, len, PacketTypeToSessionType(flags));
593 default:
594 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid flags(%d)", flags);
595 return SOFTBUS_INVALID_PARAM;
596 }
597 }
598
TransProxySessionDataLenCheck(uint32_t dataLen,ProxyPacketType type)599 int32_t TransProxySessionDataLenCheck(uint32_t dataLen, ProxyPacketType type)
600 {
601 #define PROXY_MAX_BYTES_LEN (4 * 1024 * 1024)
602 #define PROXY_MAX_MESSAGE_LEN (1 * 1024)
603 switch (type) {
604 case PROXY_FLAG_MESSAGE:
605 case PROXY_FLAG_ASYNC_MESSAGE: {
606 if (dataLen > PROXY_MAX_MESSAGE_LEN) {
607 return SOFTBUS_ERR;
608 }
609 break;
610 }
611 case PROXY_FLAG_BYTES: {
612 if (dataLen > PROXY_MAX_BYTES_LEN) {
613 return SOFTBUS_ERR;
614 }
615 break;
616 }
617 default: {
618 return SOFTBUS_OK;
619 }
620 }
621 return SOFTBUS_OK;
622 }
623
TransProxyProcessSessionData(const char * pkgName,int32_t channelId,const PacketHead * dataHead,const char * data)624 static int32_t TransProxyProcessSessionData(const char *pkgName, int32_t channelId,
625 const PacketHead *dataHead, const char *data)
626 {
627 ProxyDataInfo dataInfo = {0};
628 uint32_t outLen = 0;
629 int32_t ret = SOFTBUS_ERR;
630
631 if (dataHead->dataLen <= OVERHEAD_LEN) {
632 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid data head len[%d]", dataHead->dataLen);
633 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
634 }
635
636 outLen = dataHead->dataLen - OVERHEAD_LEN;
637 dataInfo.outData = (unsigned char *)SoftBusCalloc(outLen);
638 if (dataInfo.outData == NULL) {
639 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "malloc fail when process session out data.");
640 return SOFTBUS_MALLOC_ERR;
641 }
642 dataInfo.inData = (unsigned char *)data;
643 dataInfo.inLen = dataHead->dataLen;
644 dataInfo.outLen = outLen;
645
646 ret = TransProxyDecryptPacketData(channelId, dataHead->seq, &dataInfo);
647 if (ret != SOFTBUS_OK) {
648 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "decrypt err");
649 SoftBusFree(dataInfo.outData);
650 return SOFTBUS_DECRYPT_ERR;
651 }
652
653 if (TransProxySessionDataLenCheck(dataInfo.outLen, (ProxyPacketType)(dataHead->flags)) != SOFTBUS_OK) {
654 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "data len is too large %d type %d",
655 dataInfo.outLen, dataHead->flags);
656 SoftBusFree(dataInfo.outData);
657 return SOFTBUS_ERR;
658 }
659
660 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "ProcessData debug: len %d \n", dataInfo.outLen);
661 if (TransProxyNotifySession(pkgName, channelId, (ProxyPacketType)dataHead->flags, dataHead->seq,
662 (const char *)dataInfo.outData, dataInfo.outLen) != SOFTBUS_OK) {
663 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "process data err");
664 SoftBusFree(dataInfo.outData);
665 return SOFTBUS_ERR;
666 }
667 SoftBusFree(dataInfo.outData);
668 return SOFTBUS_OK;
669 }
670
TransProxyNoSubPacketProc(const char * pkgName,int32_t channelId,const char * data,uint32_t len)671 static int32_t TransProxyNoSubPacketProc(const char *pkgName, int32_t channelId, const char *data, uint32_t len)
672 {
673 PacketHead *head = (PacketHead*)data;
674 if (head == NULL) {
675 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param data.", __func__);
676 return SOFTBUS_ERR;
677 }
678 UnPackPacketHead(head);
679 if ((uint32_t)head->magicNumber != MAGIC_NUMBER) {
680 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid magicNumber %x", head->magicNumber);
681 return SOFTBUS_ERR;
682 }
683 if (head->dataLen <= 0) {
684 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid dataLen %d", head->dataLen);
685 return SOFTBUS_ERR;
686 }
687 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "NoSubPacketProc dataLen[%d] inputLen[%d]", head->dataLen, len);
688 if (head->dataLen + sizeof(PacketHead) != len) {
689 return SOFTBUS_ERR;
690 }
691 int32_t ret = TransProxyProcessSessionData(pkgName, channelId, head, data + sizeof(PacketHead));
692 if (ret != SOFTBUS_OK) {
693 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "process data err");
694 return SOFTBUS_ERR;
695 }
696 return SOFTBUS_OK;
697 }
698
TransProxyCheckSliceHead(const SliceHead * head)699 static int32_t TransProxyCheckSliceHead(const SliceHead *head)
700 {
701 if (head == NULL) {
702 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s]invalid param.", __func__);
703 return SOFTBUS_ERR;
704 }
705 if (head->priority < 0 || head->priority >= PROXY_CHANNEL_PRORITY_BUTT) {
706 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid index %d", head->priority);
707 return SOFTBUS_ERR;
708 }
709
710 if (head->sliceNum != 1 && head->sliceSeq >= head->sliceNum) {
711 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "sliceNum %d sliceSeq %d", head->sliceNum, head->sliceSeq);
712 return SOFTBUS_ERR;
713 }
714
715 return SOFTBUS_OK;
716 }
717
TransProxyGetChannelSliceProcessor(int32_t channelId)718 static ChannelSliceProcessor *TransProxyGetChannelSliceProcessor(int32_t channelId)
719 {
720 ChannelSliceProcessor *processor = NULL;
721 LIST_FOR_EACH_ENTRY(processor, &g_channelSliceProcessorList->list, ChannelSliceProcessor, head) {
722 if (processor->channelId == channelId) {
723 return processor;
724 }
725 }
726
727 ChannelSliceProcessor *node = (ChannelSliceProcessor *)SoftBusCalloc(sizeof(ChannelSliceProcessor));
728 if (node == NULL) {
729 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "calloc err");
730 return NULL;
731 }
732 node->channelId = channelId;
733 ListInit(&(node->head));
734 ListAdd(&(g_channelSliceProcessorList->list), &(node->head));
735 g_channelSliceProcessorList->cnt++;
736 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "add new node, channelId = %d", channelId);
737 return node;
738 }
739
TransProxyClearProcessor(SliceProcessor * processor)740 static void TransProxyClearProcessor(SliceProcessor *processor)
741 {
742 if (processor->data != NULL) {
743 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "slice processor data not null");
744 SoftBusFree(processor->data);
745 processor->data = NULL;
746 }
747 processor->active = false;
748 processor->bufLen = 0;
749 processor->dataLen = 0;
750 processor->expectedSeq = 0;
751 processor->sliceNumber = 0;
752 processor->timeout = 0;
753 }
754
TransProxyFirstSliceProcess(SliceProcessor * processor,const SliceHead * head,const char * data,uint32_t len)755 static int32_t TransProxyFirstSliceProcess(SliceProcessor *processor, const SliceHead *head,
756 const char *data, uint32_t len)
757 {
758 TransProxyClearProcessor(processor);
759
760 uint32_t maxDataLen = (head->priority == PROXY_CHANNEL_PRORITY_MESSAGE) ?
761 PROXY_MESSAGE_LENGTH_MAX : PROXY_BYTES_LENGTH_MAX;
762 uint32_t maxLen = maxDataLen + DATA_HEAD_SIZE + OVERHEAD_LEN;
763 processor->data = (char *)SoftBusCalloc(maxLen);
764 if (processor->data == NULL) {
765 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "malloc fail when proc first slice package");
766 return SOFTBUS_MALLOC_ERR;
767 }
768 processor->bufLen = (int32_t)maxLen;
769 if (memcpy_s(processor->data, maxLen, data, len) != EOK) {
770 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "memcpy fail hen proc first slice package");
771 SoftBusFree(processor->data);
772 processor->data = NULL;
773 return SOFTBUS_SLICE_ERROR;
774 }
775 processor->sliceNumber = head->sliceNum;
776 processor->expectedSeq = 1;
777 processor->dataLen = (int32_t)len;
778 processor->active = true;
779 processor->timeout = 0;
780
781 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "FirstSliceProcess ok");
782 return SOFTBUS_OK;
783 }
784
TransProxySliceProcessChkPkgIsValid(const SliceProcessor * processor,const SliceHead * head,const char * data,uint32_t len)785 static int32_t TransProxySliceProcessChkPkgIsValid(const SliceProcessor *processor, const SliceHead *head,
786 const char *data, uint32_t len)
787 {
788 (void)data;
789 if (head->sliceNum != processor->sliceNumber ||
790 head->sliceSeq != processor->expectedSeq) {
791 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "unmatched normal slice received");
792 return SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_NO_INVALID;
793 }
794 if ((int32_t)len + processor->dataLen > processor->bufLen) {
795 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "data len invalid");
796 return SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_EXCEED_LENGTH;
797 }
798 if (processor->data == NULL) {
799 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "data NULL");
800 return SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_DATA_NULL;
801 }
802 return SOFTBUS_OK;
803 }
804
TransProxyNormalSliceProcess(SliceProcessor * processor,const SliceHead * head,const char * data,uint32_t len)805 static int32_t TransProxyNormalSliceProcess(SliceProcessor *processor, const SliceHead *head,
806 const char *data, uint32_t len)
807 {
808 int32_t ret = TransProxySliceProcessChkPkgIsValid(processor, head, data, len);
809 if (ret != SOFTBUS_OK) {
810 return ret;
811 }
812 if (memcpy_s(processor->data + processor->dataLen,
813 (uint32_t)(processor->bufLen - processor->dataLen), data, len) != EOK) {
814 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "memcpy fail when proc normal slice");
815 return SOFTBUS_MEM_ERR;
816 }
817 processor->expectedSeq++;
818 processor->dataLen += (int32_t)len;
819 processor->timeout = 0;
820 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "NormalSliceProcess ok");
821 return ret;
822 }
823
TransProxyLastSliceProcess(SliceProcessor * processor,const SliceHead * head,const char * data,uint32_t len,const char * pkgName,int32_t channelId)824 static int32_t TransProxyLastSliceProcess(SliceProcessor *processor, const SliceHead *head,
825 const char *data, uint32_t len, const char *pkgName, int32_t channelId)
826 {
827 int32_t ret = TransProxySliceProcessChkPkgIsValid(processor, head, data, len);
828 if (ret != SOFTBUS_OK) {
829 return ret;
830 }
831 if (memcpy_s(processor->data + processor->dataLen,
832 (uint32_t)(processor->bufLen - processor->dataLen), data, len) != EOK) {
833 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "memcpy fail when proc last slice");
834 return SOFTBUS_MEM_ERR;
835 }
836 processor->expectedSeq++;
837 processor->dataLen += (int32_t)len;
838
839 ret = TransProxyNoSubPacketProc(pkgName, channelId, processor->data, (uint32_t)processor->dataLen);
840 if (ret != SOFTBUS_OK) {
841 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "process packets err");
842 return ret;
843 }
844 TransProxyClearProcessor(processor);
845 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "LastSliceProcess ok");
846 return ret;
847 }
848
TransProxySubPacketProc(const char * pkgName,int32_t channelId,const SliceHead * head,const char * data,uint32_t len)849 static int TransProxySubPacketProc(const char *pkgName, int32_t channelId, const SliceHead *head,
850 const char *data, uint32_t len)
851 {
852 if (data == NULL || len == 0) {
853 return SOFTBUS_INVALID_PARAM;
854 }
855 if (g_channelSliceProcessorList == NULL) {
856 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxySubPacketProc not init");
857 return SOFTBUS_NO_INIT;
858 }
859 if (SoftBusMutexLock(&g_channelSliceProcessorList->lock) != 0) {
860 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock err");
861 return SOFTBUS_ERR;
862 }
863
864 ChannelSliceProcessor *channelProcessor = TransProxyGetChannelSliceProcessor(channelId);
865 if (channelProcessor == NULL) {
866 SoftBusMutexUnlock(&g_channelSliceProcessorList->lock);
867 return SOFTBUS_ERR;
868 }
869
870 int ret;
871 int32_t index = head->priority;
872 SliceProcessor *processor = &(channelProcessor->processor[index]);
873 if (head->sliceSeq == 0) {
874 ret = TransProxyFirstSliceProcess(processor, head, data, len);
875 } else if (head->sliceNum == head->sliceSeq + 1) {
876 ret = TransProxyLastSliceProcess(processor, head, data, len, pkgName, channelId);
877 } else {
878 ret = TransProxyNormalSliceProcess(processor, head, data, len);
879 }
880
881 SoftBusMutexUnlock(&g_channelSliceProcessorList->lock);
882 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "Proxy SubPacket Proc end");
883 if (ret != SOFTBUS_OK) {
884 TransProxyClearProcessor(processor);
885 }
886 return ret;
887 }
888 #define SLICE_HEAD_LEN (sizeof(PacketHead) + sizeof(SliceHead))
TransOnNormalMsgReceived(const char * pkgName,int32_t channelId,const char * data,uint32_t len)889 int32_t TransOnNormalMsgReceived(const char *pkgName, int32_t channelId, const char *data, uint32_t len)
890 {
891 SliceHead *headSlice = NULL;
892 uint32_t dataLen;
893
894 if (data == NULL || len <= SLICE_HEAD_LEN) {
895 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "data null or len %d error", len);
896 return SOFTBUS_ERR;
897 }
898 headSlice = (SliceHead *)data;
899 UnPackSliceHead(headSlice);
900 if (TransProxyCheckSliceHead(headSlice)) {
901 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid slihead");
902 return SOFTBUS_TRANS_PROXY_INVALID_SLICE_HEAD;
903 }
904
905 dataLen = len - sizeof(SliceHead);
906 if (headSlice->sliceNum == 1) { // no sub packets
907 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "no sub packets proc");
908 return TransProxyNoSubPacketProc(pkgName, channelId, data + sizeof(SliceHead), dataLen);
909 } else {
910 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "sub packets proc slicecount:%d", headSlice->sliceNum);
911 return TransProxySubPacketProc(pkgName, channelId, headSlice, data + sizeof(SliceHead), dataLen);
912 }
913 }
914
TransOnAuthMsgReceived(const char * pkgName,int32_t channelId,const char * data,uint32_t len)915 int32_t TransOnAuthMsgReceived(const char *pkgName, int32_t channelId, const char *data, uint32_t len)
916 {
917 if (data == NULL) {
918 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "data null.");
919 return SOFTBUS_ERR;
920 }
921 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "AuthReceived inputLen[%d]", len);
922
923 ProxyPacketType type = PROXY_FLAG_BYTES;
924 if (TransProxyAuthSessionDataLenCheck(len, type) != SOFTBUS_OK) {
925 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "data len is too large %d type %d", len, type);
926 return SOFTBUS_ERR;
927 }
928
929 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "Auth ProcessData debug: len %d \n", len);
930 if (TransProxyNotifySession(pkgName, channelId, type, 0, (const char *)data, len) != SOFTBUS_OK) {
931 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Auth process data err");
932 return SOFTBUS_ERR;
933 }
934 return SOFTBUS_OK;
935 }
936
TransProxyDelSliceProcessorByChannelId(int32_t channelId)937 int32_t TransProxyDelSliceProcessorByChannelId(int32_t channelId)
938 {
939 ChannelSliceProcessor *node = NULL;
940 ChannelSliceProcessor *next = NULL;
941
942 if (g_channelSliceProcessorList == NULL) {
943 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
944 return SOFTBUS_NO_INIT;
945 }
946 if (SoftBusMutexLock(&g_channelSliceProcessorList->lock) != 0) {
947 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock err");
948 return SOFTBUS_ERR;
949 }
950 LIST_FOR_EACH_ENTRY_SAFE(node, next, &g_channelSliceProcessorList->list, ChannelSliceProcessor, head) {
951 if (node->channelId == channelId) {
952 for (int i = PROXY_CHANNEL_PRORITY_MESSAGE; i < PROXY_CHANNEL_PRORITY_BUTT; i++) {
953 TransProxyClearProcessor(&(node->processor[i]));
954 }
955 ListDelete(&(node->head));
956 SoftBusFree(node);
957 g_channelSliceProcessorList->cnt--;
958 (void)SoftBusMutexUnlock(&g_channelSliceProcessorList->lock);
959 return SOFTBUS_OK;
960 }
961 }
962 (void)SoftBusMutexUnlock(&g_channelSliceProcessorList->lock);
963 return SOFTBUS_OK;
964 }
965
TransProxySliceTimerProc(void)966 static void TransProxySliceTimerProc(void)
967 {
968 #define SLICE_PACKET_TIMEOUT 10 // 10s
969 ChannelSliceProcessor *removeNode = NULL;
970 ChannelSliceProcessor *nextNode = NULL;
971
972 if (g_channelSliceProcessorList == 0 || g_channelSliceProcessorList->cnt == 0) {
973 return;
974 }
975
976 if (SoftBusMutexLock(&g_channelSliceProcessorList->lock) != 0) {
977 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxySliceTimerProc lock mutex fail!");
978 return;
979 }
980
981 LIST_FOR_EACH_ENTRY_SAFE(removeNode, nextNode, &g_channelSliceProcessorList->list, ChannelSliceProcessor, head) {
982 for (int i = PROXY_CHANNEL_PRORITY_MESSAGE; i < PROXY_CHANNEL_PRORITY_BUTT; i++) {
983 if (removeNode->processor[i].active == true) {
984 removeNode->processor[i].timeout++;
985 if (removeNode->processor[i].timeout >= SLICE_PACKET_TIMEOUT) {
986 TransProxyClearProcessor(&removeNode->processor[i]);
987 }
988 }
989 }
990 }
991 (void)SoftBusMutexUnlock(&g_channelSliceProcessorList->lock);
992 return;
993 }
994
TransSliceManagerInit(void)995 int32_t TransSliceManagerInit(void)
996 {
997 g_channelSliceProcessorList = CreateSoftBusList();
998 if (g_channelSliceProcessorList == NULL) {
999 return SOFTBUS_ERR;
1000 }
1001 if (RegisterTimeoutCallback(SOFTBUS_PROXYSLICE_TIMER_FUN, TransProxySliceTimerProc) != SOFTBUS_OK) {
1002 DestroySoftBusList(g_channelSliceProcessorList);
1003 return SOFTBUS_ERR;
1004 }
1005 return SOFTBUS_OK;
1006 }
1007
TransSliceManagerDeInit(void)1008 void TransSliceManagerDeInit(void)
1009 {
1010 if (g_channelSliceProcessorList) {
1011 DestroySoftBusList(g_channelSliceProcessorList);
1012 }
1013 return;
1014 }
1015