1 /*
2 * Copyright (c) 2021-2025 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_message.h"
17
18 #include <securec.h>
19 #include <stdatomic.h>
20
21 #include "auth_apply_key_process.h"
22 #include "auth_interface.h"
23 #include "auth_session_key_struct.h"
24 #include "bus_center_manager.h"
25 #include "g_enhance_trans_func.h"
26 #include "g_enhance_trans_func_pack.h"
27 #include "legacy/softbus_hisysevt_transreporter.h"
28 #include "lnn_ohos_account_adapter.h"
29 #include "softbus_access_token_adapter.h"
30 #include "softbus_adapter_crypto.h"
31 #include "softbus_adapter_mem.h"
32 #include "softbus_adapter_socket.h"
33 #include "softbus_datahead_transform.h"
34 #include "softbus_def.h"
35 #include "softbus_error_code.h"
36 #include "softbus_json_utils.h"
37 #include "softbus_message_open_channel.h"
38 #include "softbus_proxychannel_control.h"
39 #include "softbus_proxychannel_listener.h"
40 #include "softbus_proxychannel_manager.h"
41 #include "softbus_proxychannel_transceiver.h"
42 #include "softbus_utils.h"
43 #include "trans_channel_common.h"
44 #include "trans_channel_manager.h"
45 #include "trans_event.h"
46 #include "trans_log.h"
47 #include "trans_proxy_process_data.h"
48 #include "trans_session_account_adapter.h"
49 #include "trans_uk_manager.h"
50
51 static _Atomic int32_t g_proxyPktHeadSeq = 2048;
52
53 #define PROXY_CHANNEL_CLIENT 0
54 #define PROXY_CHANNEL_SERVER 1
55 #define CHAT_MODE_SINGLE 0x01
56
TransParseMessageHeadType(char * data,int32_t len,ProxyMessage * msg)57 int32_t TransParseMessageHeadType(char *data, int32_t len, ProxyMessage *msg)
58 {
59 if (data == NULL || msg == NULL || len <= sizeof(uint8_t)) {
60 TRANS_LOGE(TRANS_CTRL, "invalid param");
61 return SOFTBUS_INVALID_PARAM;
62 }
63 char *ptr = data;
64 uint8_t firstByte = *ptr;
65 int8_t version = (firstByte >> VERSION_SHIFT) & FOUR_BIT_MASK;
66 msg->msgHead.type = firstByte & FOUR_BIT_MASK;
67 if (version != VERSION || msg->msgHead.type >= PROXYCHANNEL_MSG_TYPE_MAX) {
68 TRANS_LOGE(TRANS_CTRL, "parseMessage: unsupported message, version=%{public}d, type=%{public}d",
69 version, msg->msgHead.type);
70 return SOFTBUS_TRANS_INVALID_MESSAGE_TYPE;
71 }
72 return SOFTBUS_OK;
73 }
74
TransPagingParseHandshakeMessageHead(char * data,int32_t len,ProxyMessage * msg,uint8_t * accountHash,uint8_t * udidHash)75 static int32_t TransPagingParseHandshakeMessageHead(char *data, int32_t len, ProxyMessage *msg,
76 uint8_t *accountHash, uint8_t *udidHash)
77 {
78 char *ptr = data;
79 ptr += sizeof(int8_t);
80 msg->msgHead.peerId = (int16_t)SoftBusBEtoLEs(*(uint16_t *)ptr);
81 ptr += sizeof(uint16_t);
82 if (memcpy_s(accountHash, D2D_SHORT_ACCOUNT_HASH_LEN, ptr, D2D_SHORT_ACCOUNT_HASH_LEN) != EOK) {
83 TRANS_LOGE(TRANS_CTRL, "memcpy accountHash failed");
84 return SOFTBUS_MEM_ERR;
85 }
86 ptr += D2D_SHORT_ACCOUNT_HASH_LEN;
87 if (memcpy_s(udidHash, D2D_SHORT_UDID_HASH_LEN, ptr, D2D_SHORT_UDID_HASH_LEN) != EOK) {
88 TRANS_LOGE(TRANS_CTRL, "memcpy udidHash failed");
89 return SOFTBUS_MEM_ERR;
90 }
91 msg->data = data + PAGING_CHANNEL_HANDSHAKE_HEAD_LEN;
92 msg->dataLen = len - PAGING_CHANNEL_HANDSHAKE_HEAD_LEN;
93 return SOFTBUS_OK;
94 }
95
TransPagingParseMessageHead(char * data,int32_t len,ProxyMessage * msg)96 static void TransPagingParseMessageHead(char *data, int32_t len, ProxyMessage *msg)
97 {
98 char *ptr = data;
99 ptr += sizeof(int8_t);
100 msg->msgHead.myId = (int16_t)SoftBusBEtoLEs(*(uint16_t *)ptr);
101 msg->data = data + PAGING_CHANNEL_HEAD_LEN;
102 msg->dataLen = len - PAGING_CHANNEL_HEAD_LEN;
103 }
104
TransProxyParseMessageHead(char * data,int32_t len,ProxyMessage * msg)105 static int32_t TransProxyParseMessageHead(char *data, int32_t len, ProxyMessage *msg)
106 {
107 char *ptr = data;
108 ptr += sizeof(int8_t);
109
110 msg->msgHead.cipher = *ptr;
111 ptr += sizeof(int8_t);
112 msg->msgHead.peerId = (int16_t)SoftBusBEtoLEs(*(uint16_t *)ptr);
113 ptr += sizeof(uint16_t);
114 msg->msgHead.myId = (int16_t)SoftBusBEtoLEs(*(uint16_t *)ptr);
115 ptr += sizeof(uint16_t);
116 msg->msgHead.reserved = (int16_t)SoftBusBEtoLEs(*(uint16_t *)ptr);
117 msg->data = data + sizeof(ProxyMessageHead);
118 msg->dataLen = len - sizeof(ProxyMessageHead);
119
120 return SOFTBUS_OK;
121 }
122
TransProxyPackMessageHead(ProxyMessageHead * msgHead,uint8_t * buf,uint32_t size)123 static void TransProxyPackMessageHead(ProxyMessageHead *msgHead, uint8_t *buf, uint32_t size)
124 {
125 if (size < PROXY_CHANNEL_HEAD_LEN) {
126 TRANS_LOGE(TRANS_CTRL, "proxy head not enough");
127 return;
128 }
129 uint32_t offset = 0;
130 *buf = msgHead->type;
131 offset += sizeof(uint8_t);
132 *(buf + offset) = msgHead->cipher;
133 offset += sizeof(uint8_t);
134 *(uint16_t *)(buf + offset) = SoftBusLEtoBEs((uint16_t)msgHead->myId);
135 offset += sizeof(uint16_t);
136 *(uint16_t *)(buf + offset) = SoftBusLEtoBEs((uint16_t)msgHead->peerId);
137 offset += sizeof(uint16_t);
138 *(uint16_t *)(buf + offset) = SoftBusLEtoBEs((uint16_t)msgHead->reserved);
139 }
140
GetRemoteUdidByBtMac(const char * peerMac,char * udid,int32_t len)141 static int32_t GetRemoteUdidByBtMac(const char *peerMac, char *udid, int32_t len)
142 {
143 char networkId[NETWORK_ID_BUF_LEN] = {0};
144 char *tmpMac = NULL;
145 Anonymize(peerMac, &tmpMac);
146 int32_t ret = LnnGetNetworkIdByBtMac(peerMac, networkId, sizeof(networkId));
147 if (ret != SOFTBUS_OK) {
148 TRANS_LOGE(TRANS_CTRL, "LnnGetNetworkIdByBtMac fail, peerMac=%{public}s", AnonymizeWrapper(tmpMac));
149 AnonymizeFree(tmpMac);
150 return ret;
151 }
152 ret = LnnGetRemoteStrInfo(networkId, STRING_KEY_DEV_UDID, udid, len);
153 if (ret != SOFTBUS_OK) {
154 TRANS_LOGE(TRANS_CTRL, "LnnGetRemoteStrInfo UDID fail, peerMac=%{public}s", AnonymizeWrapper(tmpMac));
155 }
156 AnonymizeFree(tmpMac);
157 return ret;
158 }
159
GetRemoteBtMacByUdidHash(const uint8_t * udidHash,uint32_t udidHashLen,char * brMac,int32_t len)160 static int32_t GetRemoteBtMacByUdidHash(const uint8_t *udidHash, uint32_t udidHashLen, char *brMac, int32_t len)
161 {
162 char networkId[NETWORK_ID_BUF_LEN] = {0};
163 int32_t ret = LnnGetNetworkIdByUdidHash(udidHash, udidHashLen, networkId, sizeof(networkId), true);
164 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "LnnGetNetworkIdByUdidHash fail");
165
166 ret = LnnGetRemoteStrInfo(networkId, STRING_KEY_BT_MAC, brMac, len);
167 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "GetRemoteBtMac fail");
168
169 return SOFTBUS_OK;
170 }
171
SelectAuthType(AuthConnInfo * connInfo,ConnectionInfo * info)172 static int32_t SelectAuthType(AuthConnInfo *connInfo, ConnectionInfo *info)
173 {
174 switch (info->type) {
175 case CONNECT_TCP:
176 connInfo->type = AUTH_LINK_TYPE_WIFI;
177 if (strcpy_s(connInfo->info.ipInfo.ip, IP_LEN, info->socketInfo.addr) != EOK) {
178 TRANS_LOGE(TRANS_CTRL, "strcpy_s ip fail.");
179 return SOFTBUS_STRCPY_ERR;
180 }
181 break;
182 case CONNECT_BR:
183 connInfo->type = AUTH_LINK_TYPE_BR;
184 if (strcpy_s(connInfo->info.brInfo.brMac, BT_MAC_LEN, info->brInfo.brMac) != EOK) {
185 TRANS_LOGE(TRANS_CTRL, "strcpy_s brMac fail.");
186 return SOFTBUS_STRCPY_ERR;
187 }
188 break;
189 case CONNECT_BLE:
190 connInfo->type = AUTH_LINK_TYPE_BLE;
191 if (strcpy_s(connInfo->info.bleInfo.bleMac, BT_MAC_LEN, info->bleInfo.bleMac) != EOK) {
192 TRANS_LOGE(TRANS_CTRL, "strcpy_s brMac fail.");
193 return SOFTBUS_STRCPY_ERR;
194 }
195 if (memcpy_s(connInfo->info.bleInfo.deviceIdHash, UDID_HASH_LEN,
196 info->bleInfo.deviceIdHash, UDID_HASH_LEN) != EOK) {
197 TRANS_LOGE(TRANS_CTRL, "memcpy_s brMac fail.");
198 return SOFTBUS_MEM_ERR;
199 }
200 connInfo->info.bleInfo.protocol = info->bleInfo.protocol;
201 connInfo->info.bleInfo.psm = (int32_t)info->bleInfo.psm;
202 break;
203 case CONNECT_SLE:
204 connInfo->type = AUTH_LINK_TYPE_SLE;
205 if (memcpy_s(connInfo->info.sleInfo.sleMac, BT_MAC_LEN, info->sleInfo.address, BT_MAC_LEN) != EOK) {
206 TRANS_LOGE(TRANS_CTRL, "memcpy_s sle address fail.");
207 return SOFTBUS_MEM_ERR;
208 }
209 if (memcpy_s(connInfo->info.sleInfo.networkId, NETWORK_ID_BUF_LEN,
210 info->sleInfo.networkId, NETWORK_ID_BUF_LEN) != EOK) {
211 TRANS_LOGE(TRANS_CTRL, "memcpy_s networkId fail.");
212 return SOFTBUS_MEM_ERR;
213 }
214 connInfo->info.sleInfo.protocol = info->sleInfo.protocol;
215 break;
216 default:
217 TRANS_LOGE(TRANS_CTRL, "unexpected conn type=%{public}d.", info->type);
218 return SOFTBUS_TRANS_UNEXPECTED_CONN_TYPE;
219 }
220 return SOFTBUS_OK;
221 }
222
TransProxyGetAuthConnInfo(uint32_t connId,AuthConnInfo * connInfo)223 static int32_t TransProxyGetAuthConnInfo(uint32_t connId, AuthConnInfo *connInfo)
224 {
225 ConnectionInfo info = { 0 };
226 int32_t ret = ConnGetConnectionInfo(connId, &info);
227 TRANS_CHECK_AND_RETURN_RET_LOGE(
228 ret == SOFTBUS_OK, ret, TRANS_CTRL, "ConnGetConnectionInfo fail, connId=%{public}u", connId);
229 ret = SelectAuthType(connInfo, &info);
230 return ret;
231 }
232
ConvertBrConnInfo2BleConnInfo(AuthConnInfo * connInfo)233 static int32_t ConvertBrConnInfo2BleConnInfo(AuthConnInfo *connInfo)
234 {
235 char udid[UDID_BUF_LEN] = {0};
236 int32_t ret = GetRemoteUdidByBtMac(connInfo->info.brInfo.brMac, udid, UDID_BUF_LEN);
237 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "get udid by btmac fail");
238
239 ret = SoftBusGenerateStrHash((unsigned char *)udid, strlen(udid), connInfo->info.bleInfo.deviceIdHash);
240 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "generate udid hash fail");
241
242 connInfo->type = AUTH_LINK_TYPE_BLE;
243 return SOFTBUS_OK;
244 }
245
ConvertBleConnInfo2BrConnInfo(AuthConnInfo * connInfo)246 static int32_t ConvertBleConnInfo2BrConnInfo(AuthConnInfo *connInfo)
247 {
248 char brMac[BT_MAC_LEN] = {0};
249 int32_t ret = GetRemoteBtMacByUdidHash(connInfo->info.bleInfo.deviceIdHash, UDID_HASH_LEN, brMac, BT_MAC_LEN);
250 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "get btmac by udid fail");
251
252 if (strcpy_s(connInfo->info.brInfo.brMac, BT_MAC_LEN, brMac) != EOK) {
253 TRANS_LOGE(TRANS_CTRL, "copy br mac fail");
254 return SOFTBUS_STRCPY_ERR;
255 }
256 connInfo->type = AUTH_LINK_TYPE_BR;
257 return SOFTBUS_OK;
258 }
259
ConvertSleConnInfo2BleConnInfo(AuthConnInfo * connInfo)260 static int32_t ConvertSleConnInfo2BleConnInfo(AuthConnInfo *connInfo)
261 {
262 char udid[UDID_BUF_LEN] = {0};
263 int32_t ret = LnnGetRemoteStrInfo(connInfo->info.sleInfo.networkId, STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN);
264 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "get udid fail");
265
266 ret = SoftBusGenerateStrHash((unsigned char *)udid, strlen(udid), connInfo->info.bleInfo.deviceIdHash);
267 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "generate udid hash fail");
268
269 connInfo->type = AUTH_LINK_TYPE_BLE;
270 return SOFTBUS_OK;
271 }
272
GetAuthIdByHandshakeMsg(uint32_t connId,uint8_t cipher,AuthHandle * authHandle,int32_t index)273 static int32_t GetAuthIdByHandshakeMsg(uint32_t connId, uint8_t cipher, AuthHandle *authHandle, int32_t index)
274 {
275 AuthConnInfo connInfo;
276 int32_t ret = TransProxyGetAuthConnInfo(connId, &connInfo);
277 TRANS_CHECK_AND_RETURN_RET_LOGE(
278 ret == SOFTBUS_OK, ret, TRANS_CTRL, "get connInfo fail connId=%{public}d", connId);
279 bool isBle = ((cipher & USE_BLE_CIPHER) != 0);
280 if (isBle && connInfo.type == AUTH_LINK_TYPE_BR) {
281 ret = ConvertBrConnInfo2BleConnInfo(&connInfo);
282 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
283 TRANS_CTRL, "ConvertBrConnInfo2BleConnInfo fail, connInfoType=%{public}d", connInfo.type);
284 } else if (!isBle && connInfo.type == AUTH_LINK_TYPE_BLE) {
285 ret = ConvertBleConnInfo2BrConnInfo(&connInfo);
286 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
287 TRANS_CTRL, "ConvertBleConnInfo2BrConnInfo fail, connInfoType=%{public}d", connInfo.type);
288 } else if (isBle && connInfo.type == AUTH_LINK_TYPE_SLE) {
289 ret = ConvertSleConnInfo2BleConnInfo(&connInfo);
290 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
291 TRANS_CTRL, "ConvertSleConnInfo2BleConnInfo fail, connInfoType=%{public}d", connInfo.type);
292 }
293 bool isAuthServer = !((cipher & AUTH_SERVER_SIDE) != 0);
294 authHandle->type = connInfo.type;
295 authHandle->authId = AuthGetIdByConnInfo(&connInfo, isAuthServer, false);
296 if (authHandle->authId == AUTH_INVALID_ID) {
297 if (AuthGetAuthHandleByIndex(&connInfo, isAuthServer, index, authHandle) != SOFTBUS_OK &&
298 AuthGetAuthHandleByIndex(&connInfo, !isAuthServer, index, authHandle) != SOFTBUS_OK) {
299 TRANS_LOGE(TRANS_CTRL, "get auth handle fail");
300 return SOFTBUS_NOT_FIND;
301 }
302 }
303 return SOFTBUS_OK;
304 }
305
GetAuthIdReDecrypt(AuthHandle * authHandle,ProxyMessage * msg,uint8_t * decData,uint32_t * decDataLen)306 static int32_t GetAuthIdReDecrypt(AuthHandle *authHandle, ProxyMessage *msg, uint8_t *decData, uint32_t *decDataLen)
307 {
308 AuthConnInfo connInfo;
309 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
310 int32_t ret = TransProxyGetAuthConnInfo(msg->connId, &connInfo);
311 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
312 TRANS_CTRL, "get connInfo fail connId=%{public}d", msg->connId);
313 int32_t index = (int32_t)SoftBusLtoHl(*(uint32_t *)msg->data);
314 if (AuthGetAuthHandleByIndex(&connInfo, false, index, authHandle) != SOFTBUS_OK &&
315 AuthGetAuthHandleByIndex(&connInfo, true, index, authHandle) != SOFTBUS_OK) {
316 TRANS_LOGE(TRANS_CTRL, "get auth handle fail");
317 return SOFTBUS_NOT_FIND;
318 }
319 return AuthDecrypt(authHandle, (uint8_t *)msg->data, (uint32_t)msg->dataLen, decData, decDataLen);
320 }
321
GetBrMacFromConnInfo(uint32_t connId,char * peerBrMac,uint32_t len)322 int32_t GetBrMacFromConnInfo(uint32_t connId, char *peerBrMac, uint32_t len)
323 {
324 AuthConnInfo connInfo;
325
326 if (peerBrMac == NULL || len <= 0 || len > BT_MAC_LEN) {
327 return SOFTBUS_INVALID_PARAM;
328 }
329 int32_t ret = TransProxyGetAuthConnInfo(connId, &connInfo);
330 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
331 TRANS_CTRL, "get connInfo fail connId=%{public}d", connId);
332
333 if (strcpy_s(peerBrMac, len, connInfo.info.brInfo.brMac) != EOK) {
334 TRANS_LOGE(TRANS_CTRL, "copy brMac fail.");
335 return SOFTBUS_STRCPY_ERR;
336 }
337 return SOFTBUS_OK;
338 }
339
TransProxyParseMessageNoDecrypt(ProxyMessage * msg)340 static int32_t TransProxyParseMessageNoDecrypt(ProxyMessage *msg)
341 {
342 if (msg->dataLen > (PROXY_BYTES_LENGTH_MAX + OVERHEAD_LEN)) {
343 TRANS_LOGE(TRANS_CTRL, "The data length of the ProxyMessage is abnormal!");
344 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
345 }
346 uint8_t *allocData = (uint8_t *)SoftBusCalloc((uint32_t)msg->dataLen);
347 if (allocData == NULL) {
348 TRANS_LOGE(TRANS_CTRL, "malloc data fail");
349 return SOFTBUS_MALLOC_ERR;
350 }
351 if (memcpy_s(allocData, msg->dataLen, msg->data, msg->dataLen) != EOK) {
352 TRANS_LOGE(TRANS_CTRL, "memcpy data fail");
353 SoftBusFree(allocData);
354 return SOFTBUS_MEM_ERR;
355 }
356 msg->data = (char *)allocData;
357 return SOFTBUS_OK;
358 }
359
TransUnPackPagingExtraData(cJSON * root,void * extraData)360 static bool TransUnPackPagingExtraData(cJSON *root, void *extraData)
361 {
362 char extraDataStr[EXTRA_DATA_STR_MAX_LEN] = {0};
363 if (!GetJsonObjectStringItem(root, JSON_KEY_PAGING_EXT_DATA, extraDataStr, EXTRA_DATA_STR_MAX_LEN)) {
364 return false;
365 }
366 if (ConvertHexStringToBytes((unsigned char *)extraData, EXTRA_DATA_MAX_LEN,
367 extraDataStr, EXTRA_DATA_STR_MAX_LEN - 1) != SOFTBUS_OK) {
368 TRANS_LOGE(TRANS_CTRL, "extraData tostring fail");
369 return false;
370 }
371 return true;
372 }
373
TransPagingUnPackHandshakeMsg(const ProxyMessage * msg,AppInfo * appInfo)374 static int32_t TransPagingUnPackHandshakeMsg(const ProxyMessage *msg, AppInfo *appInfo)
375 {
376 cJSON *root = cJSON_ParseWithLength(msg->data, msg->dataLen);
377 TRANS_CHECK_AND_RETURN_RET_LOGE(root != NULL, SOFTBUS_PARSE_JSON_ERR, TRANS_CTRL, "parse json failed.");
378 uint32_t dataLen = 0;
379 if (!GetJsonObjectStringItem(root, JSON_KEY_CALLER_ACCOUNT_ID, appInfo->peerData.callerAccountId,
380 ACCOUNT_UID_LEN_MAX) ||
381 !GetJsonObjectStringItem(root, JSON_KEY_CALLEE_ACCOUNT_ID, appInfo->peerData.calleeAccountId,
382 ACCOUNT_UID_LEN_MAX) ||
383 !GetJsonObjectNumberItem(root, JSON_KEY_PAGING_DATA_LEN, (int32_t *)&dataLen) ||
384 !GetJsonObjectNumberItem(root, JSON_KEY_PAGING_BUSINESS_FLAG, (int32_t *)&appInfo->peerData.businessFlag) ||
385 !GetJsonObjectNumberItem(root, JSON_KEY_BUSINESS_TYPE, (int32_t *)&appInfo->businessType) ||
386 !GetJsonObjectStringItem(root, JSON_KEY_DEVICE_ID, appInfo->peerData.deviceId, SHORT_DEVICE_LEN)) {
387 TRANS_LOGE(TRANS_CTRL, "failed to get handshake msg APP_TYPE_NORMAL");
388 cJSON_Delete(root);
389 return SOFTBUS_PARSE_JSON_ERR;
390 }
391 if (dataLen > 0 && dataLen <= EXTRA_DATA_MAX_LEN) {
392 appInfo->peerData.dataLen = dataLen;
393 if (!TransUnPackPagingExtraData(root, appInfo->peerData.extraData)) {
394 TRANS_LOGE(TRANS_CTRL, "unpack extraData failed!");
395 cJSON_Delete(root);
396 return SOFTBUS_PARSE_JSON_ERR;
397 }
398 } else {
399 appInfo->peerData.dataLen = 0;
400 }
401 cJSON_Delete(root);
402 return SOFTBUS_OK;
403 }
404
TransPagingUnPackHandshakeAckMsg(const ProxyMessage * msg,AppInfo * appInfo)405 static int32_t TransPagingUnPackHandshakeAckMsg(const ProxyMessage *msg, AppInfo *appInfo)
406 {
407 cJSON *root = cJSON_ParseWithLength(msg->data, msg->dataLen);
408 TRANS_CHECK_AND_RETURN_RET_LOGE(root != NULL, SOFTBUS_PARSE_JSON_ERR, TRANS_CTRL, "parse json failed.");
409 char sessionKey[ORIGIN_LEN_16_BASE64_LENGTH] = { 0 };
410 char nonce[ORIGIN_LEN_16_BASE64_LENGTH] = { 0 };
411 uint32_t dataLen = 0;
412 // deviceId len is 8 bit
413 if (!GetJsonObjectNumberItem(root, JSON_KEY_PAGING_SINK_CHANNEL_ID, (int32_t *)&appInfo->peerData.channelId) ||
414 !GetJsonObjectStringItem(root, JSON_KEY_SESSION_KEY, sessionKey, ORIGIN_LEN_16_BASE64_LENGTH) ||
415 !GetJsonObjectStringItem(root, JSON_KEY_PAGING_NONCE, nonce, ORIGIN_LEN_16_BASE64_LENGTH) ||
416 !GetJsonObjectStringItem(root, JSON_KEY_DEVICE_ID, appInfo->peerData.deviceId, SHORT_DEVICE_LEN) ||
417 !GetJsonObjectNumberItem(root, JSON_KEY_DEVICETYPE_ID, (int32_t *)&appInfo->peerData.devTypeId) ||
418 !GetJsonObjectNumberItem(root, JSON_KEY_PAGING_DATA_LEN, (int32_t *)&dataLen)) {
419 TRANS_LOGE(TRANS_CTRL, "failed to get handshake msg APP_TYPE_NORMAL");
420 cJSON_Delete(root);
421 return SOFTBUS_PARSE_JSON_ERR;
422 }
423 if (dataLen > 0 && dataLen <= EXTRA_DATA_MAX_LEN) {
424 appInfo->peerData.dataLen = dataLen;
425 if (!TransUnPackPagingExtraData(root, appInfo->peerData.extraData)) {
426 TRANS_LOGE(TRANS_CTRL, "unpack extraData failed!");
427 cJSON_Delete(root);
428 return SOFTBUS_PARSE_JSON_ERR;
429 }
430 } else {
431 appInfo->peerData.dataLen = 0;
432 }
433 size_t len = 0;
434 if (strlen(sessionKey) != 0) {
435 int32_t ret = SoftBusBase64Decode((uint8_t *)appInfo->pagingSessionkey,
436 sizeof(appInfo->pagingSessionkey), &len, (uint8_t *)sessionKey, strlen(sessionKey));
437 if (len != sizeof(appInfo->pagingSessionkey) || ret != SOFTBUS_OK) {
438 TRANS_LOGE(TRANS_CTRL, "decode session key fail ret=%{public}d, len=%{public}zu", ret, len);
439 cJSON_Delete(root);
440 return SOFTBUS_DECRYPT_ERR;
441 }
442 }
443 len = 0;
444 if (strlen(nonce) != 0) {
445 int32_t ret = SoftBusBase64Decode((uint8_t *)appInfo->pagingNonce, sizeof(appInfo->pagingNonce),
446 &len, (uint8_t *)nonce, strlen(nonce));
447 if (len != sizeof(appInfo->pagingNonce) || ret != SOFTBUS_OK) {
448 TRANS_LOGE(TRANS_CTRL, "decode nonce fail ret=%{public}d, len=%{public}zu", ret, len);
449 cJSON_Delete(root);
450 return SOFTBUS_DECRYPT_ERR;
451 }
452 }
453 cJSON_Delete(root);
454 return SOFTBUS_OK;
455 }
456
ReportPagingProcessHandshakeAckExtra(const ProxyChannelInfo * chan,int32_t retCode)457 static void ReportPagingProcessHandshakeAckExtra(const ProxyChannelInfo *chan, int32_t retCode)
458 {
459 TransEventExtra extra = {
460 .channelId = chan->myId,
461 .peerChannelId = chan->peerId,
462 .connectionId = (int32_t)chan->connId,
463 .costTime = GetSoftbusRecordTimeMillis() - chan->appInfo.timeStart,
464 .errcode = retCode
465 };
466 extra.result = (retCode == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED;
467 TRANS_EVENT(EVENT_SCENE_PAGING_CONNECT, EVENT_STAGE_PAGING_SOURCE_HANDSHAKE_END, extra);
468 }
469
TransPagingProcessHandshakeAckMsg(const ProxyMessage * msg)470 static void TransPagingProcessHandshakeAckMsg(const ProxyMessage *msg)
471 {
472 TRANS_CHECK_AND_RETURN_LOGE(msg != NULL, TRANS_CTRL, "invalid param");
473 ProxyChannelInfo chan = {
474 .myId = msg->msgHead.myId,
475 .appInfo.myData.channelId = (uint64_t)msg->msgHead.myId,
476 };
477 int32_t errCode = SOFTBUS_OK;
478 if (TransPagingHandshakeUnPackErrMsg(&chan, msg, &errCode) == SOFTBUS_OK) {
479 TransProxyProcessErrMsg(&chan, errCode);
480 ReportPagingProcessHandshakeAckExtra(&chan, errCode);
481 return;
482 }
483 int32_t ret = TransPagingUnPackHandshakeAckMsg(msg, &chan.appInfo);
484 if (ret != SOFTBUS_OK) {
485 TransProxyProcessErrMsg(&chan, SOFTBUS_TRANS_UNPACK_REPLY_FAILED);
486 ReportPagingProcessHandshakeAckExtra(&chan, ret);
487 return;
488 }
489 chan.peerId = chan.appInfo.peerData.channelId;
490 TRANS_LOGI(TRANS_CTRL, "recv paging Handshake ack, myChannelId=%{public}d, peerChannelId=%{public}d",
491 chan.myId, chan.peerId);
492 ret = TransPagingUpdatePagingChannelInfo(&chan);
493 if (ret != SOFTBUS_OK) {
494 TRANS_LOGE(TRANS_CTRL, "failed to update channel info, ret=%{public}d", ret);
495 TransProxyProcessErrMsg(&chan, ret);
496 ReportPagingProcessHandshakeAckExtra(&chan, ret);
497 return;
498 }
499 ReportPagingProcessHandshakeAckExtra(&chan, errCode);
500 (void)OnProxyChannelOpened(chan.channelId, &(chan.appInfo), PROXY_CHANNEL_CLIENT);
501 }
502
TransPagingProcessBadKeyMsg(const ProxyMessage * msg)503 static void TransPagingProcessBadKeyMsg(const ProxyMessage *msg)
504 {
505 TRANS_LOGW(TRANS_CTRL, "recv bad key, channelId=%{public}d", msg->msgHead.myId);
506 TransPagingBadKeyRetry(msg->msgHead.myId);
507 }
508
TransPagingUnPackResetMsg(const ProxyMessage * msg,int32_t * peerId)509 static int32_t TransPagingUnPackResetMsg(const ProxyMessage *msg, int32_t *peerId)
510 {
511 cJSON *root = NULL;
512 root = cJSON_ParseWithLength(msg->data, msg->dataLen);
513 if (root == NULL) {
514 TRANS_LOGE(TRANS_CTRL, "parse json failed.");
515 return SOFTBUS_PARSE_JSON_ERR;
516 }
517
518 if (!GetJsonObjectNumberItem(root, JSON_KEY_PAGING_SINK_CHANNEL_ID, peerId)) {
519 TRANS_LOGE(TRANS_CTRL, "fail to get json item");
520 cJSON_Delete(root);
521 return SOFTBUS_PARSE_JSON_ERR;
522 }
523 cJSON_Delete(root);
524 return SOFTBUS_OK;
525 }
526
TransPagingProcessResetMsg(const ProxyMessage * msg)527 static void TransPagingProcessResetMsg(const ProxyMessage *msg)
528 {
529 ProxyChannelInfo *info = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
530 if (info == NULL) {
531 TRANS_LOGE(TRANS_CTRL, "ProxyProcessResetMsg calloc failed.");
532 return;
533 }
534 TRANS_LOGI(TRANS_CTRL, "recv reset myChannelId=%{public}d", msg->msgHead.myId);
535 if (TransPagingUnPackResetMsg(msg, (int32_t *)&info->peerId) != SOFTBUS_OK) {
536 TRANS_LOGE(TRANS_CTRL, "unpack reset msg failed");
537 SoftBusFree(info);
538 return;
539 }
540 info->myId = msg->msgHead.myId;
541 info->channelId = msg->msgHead.myId;
542 info->appInfo.myData.channelId = msg->msgHead.myId;
543 if (TransProxyGetAppInfoById(info->myId, &(info->appInfo)) != SOFTBUS_OK) {
544 TRANS_LOGE(TRANS_CTRL, "fail to get peer data info");
545 SoftBusFree(info);
546 return;
547 }
548 if (TransDecConnRefByConnId(msg->connId, false) == SOFTBUS_OK) {
549 TRANS_LOGI(TRANS_CTRL, "recv reset dis connect, connId=%{public}u", msg->connId);
550 (void)ConnDisconnectDevice(msg->connId);
551 }
552 if (TransPagingResetChan(info) != SOFTBUS_OK) {
553 TRANS_LOGE(TRANS_CTRL, "reset chan fail mychannelId=%{public}d, peerChannelId=%{public}d", info->myId,
554 info->peerId);
555 goto EXIT;
556 }
557 OnProxyChannelClosed(info->channelId, &(info->appInfo));
558 EXIT:
559 (void)memset_s(info->appInfo.sessionKey, sizeof(info->appInfo.sessionKey), 0, sizeof(info->appInfo.sessionKey));
560 SoftBusFree(info);
561 return;
562 }
563
TransProxyFillPagingLocalInfo(ProxyChannelInfo * chan)564 static int32_t TransProxyFillPagingLocalInfo(ProxyChannelInfo *chan)
565 {
566 if (strcpy_s(chan->appInfo.myData.callerAccountId, sizeof(chan->appInfo.myData.callerAccountId),
567 chan->appInfo.peerData.calleeAccountId) != EOK ||
568 strcpy_s(chan->appInfo.myData.calleeAccountId, sizeof(chan->appInfo.myData.calleeAccountId),
569 chan->appInfo.peerData.callerAccountId) != EOK) {
570 TRANS_LOGE(TRANS_CTRL, "fill local account id failed.");
571 return SOFTBUS_STRCPY_ERR;
572 }
573 char localUdid[UDID_BUF_LEN] = { 0 };
574 int32_t ret = LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, localUdid, UDID_BUF_LEN);
575 if (ret != SOFTBUS_OK) {
576 TRANS_LOGE(TRANS_CTRL, "get local udid fail");
577 return ret;
578 }
579 uint8_t udidHash[SHA_256_HASH_LEN] = { 0 };
580 ret = SoftBusGenerateStrHash((unsigned char *)localUdid, strlen(localUdid), (unsigned char *)udidHash);
581 if (ret != SOFTBUS_OK) {
582 TRANS_LOGE(TRANS_CTRL, "generate udid hash fail");
583 return ret;
584 }
585 uint8_t callerHash[SHA_256_HASH_LEN] = { 0 };
586 if (ConvertHexStringToBytes((unsigned char *)callerHash, SHA_256_HASH_LEN,
587 chan->appInfo.myData.callerAccountId, strlen(chan->appInfo.myData.callerAccountId)) != SOFTBUS_OK) {
588 TRANS_LOGE(TRANS_CTRL, "account hash str to bytes failed");
589 return SOFTBUS_TRANS_HEX_STR_TO_BYTES_FAIL;
590 }
591 if (memcpy_s(chan->appInfo.myData.shortAccountHash, sizeof(chan->appInfo.myData.shortAccountHash),
592 callerHash, D2D_SHORT_ACCOUNT_HASH_LEN) != EOK ||
593 memcpy_s(chan->appInfo.myData.shortUdidHash, sizeof(chan->appInfo.myData.shortUdidHash),
594 udidHash, D2D_SHORT_UDID_HASH_LEN) != EOK) {
595 TRANS_LOGE(TRANS_CTRL, "cpy accounthash or deviceidhash failed");
596 return SOFTBUS_MEM_ERR;
597 }
598 return SOFTBUS_OK;
599 }
600
TransProxyFillPagingChannelInfo(const ProxyMessage * msg,ProxyChannelInfo * chan,uint8_t * accountHash,uint8_t * udidHash,const char * authAccountHash)601 static int32_t TransProxyFillPagingChannelInfo(const ProxyMessage *msg, ProxyChannelInfo *chan,
602 uint8_t *accountHash, uint8_t *udidHash, const char *authAccountHash)
603 {
604 int32_t ret = TransPagingUnPackHandshakeMsg(msg, &chan->appInfo);
605 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "Paging unpack failed.");
606 TRANS_CHECK_AND_RETURN_RET_LOGE(strcmp(chan->appInfo.peerData.callerAccountId, authAccountHash) == 0,
607 SOFTBUS_INVALID_PARAM, TRANS_CTRL, "account is invalid.");
608 ret = SoftBusGenerateSessionKey(chan->appInfo.pagingSessionkey, SHORT_SESSION_KEY_LENGTH);
609 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "Generate SessionKey failed.");
610 ret = SoftBusGenerateRandomArray((unsigned char *)chan->appInfo.pagingNonce, PAGING_NONCE_LEN);
611 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "Generate nonce failed.");
612 ret = LnnGetLocalStrInfo(STRING_KEY_UUID, chan->appInfo.myData.deviceId, sizeof(chan->appInfo.myData.deviceId));
613 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "get local device info failed.");
614 char socketName[SESSION_NAME_SIZE_MAX] = { 0 };
615 ret = AddNumberToSocketName(chan->appInfo.peerData.businessFlag, PAGING_SOCKET_NAME_PREFIX,
616 sizeof(PAGING_SOCKET_NAME_PREFIX), socketName);
617 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "businessFlag to socketName failed.");
618 if (strcpy_s(chan->appInfo.peerData.sessionName, SESSION_NAME_SIZE_MAX, socketName) != EOK ||
619 strcpy_s(chan->appInfo.myData.sessionName, SESSION_NAME_SIZE_MAX, socketName) != EOK) {
620 TRANS_LOGE(TRANS_CTRL, "copy socket name failed.");
621 return SOFTBUS_STRCPY_ERR;
622 }
623 if (memcpy_s(chan->appInfo.peerData.shortAccountHash, D2D_SHORT_ACCOUNT_HASH_LEN,
624 accountHash, D2D_SHORT_ACCOUNT_HASH_LEN) != EOK ||
625 memcpy_s(chan->appInfo.peerData.shortUdidHash, D2D_SHORT_UDID_HASH_LEN,
626 udidHash, D2D_SHORT_UDID_HASH_LEN) != EOK) {
627 TRANS_LOGE(TRANS_CTRL, "copy accoubt name failed.");
628 return SOFTBUS_MEM_ERR;
629 }
630 chan->appInfo.myData.businessFlag = chan->appInfo.peerData.businessFlag;
631 int16_t newChanId = (int16_t)(GenerateChannelId(false));
632 chan->myId = newChanId;
633 chan->peerId = msg->msgHead.peerId;
634 chan->channelId = newChanId;
635 chan->appInfo.myData.channelId = newChanId;
636 chan->connId = msg->connId;
637 chan->appInfo.peerData.channelId = msg->msgHead.peerId;
638 chan->isD2D = true;
639 chan->isServer = true;
640 chan->appInfo.isD2D = true;
641 chan->status = PROXY_CHANNEL_STATUS_COMPLETED;
642 chan->appInfo.channelType = CHANNEL_TYPE_PROXY;
643 chan->appInfo.appType = APP_TYPE_NORMAL;
644 return TransProxyFillPagingLocalInfo(chan);
645 }
646
TransProxyPagingChannelOpened(ProxyChannelInfo * chan)647 static int32_t TransProxyPagingChannelOpened(ProxyChannelInfo *chan)
648 {
649 int32_t pid = 0;
650 uint32_t len = 0;
651 char data[EXTRA_DATA_MAX_LEN] = { 0 };
652 int32_t ret = TransPagingGetPidAndDataByFlgPacked(!chan->isServer, chan->appInfo.myData.businessFlag, &pid,
653 data, &len);
654 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK && pid > 0, ret, TRANS_CTRL, "get pid failed.");
655 ret = TransPagingUpdatePidAndData(chan->channelId, pid, data, len);
656 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "update pid failed.");
657 chan->appInfo.myData.pid = pid;
658 ret = OnProxyChannelOpened(chan->channelId, &(chan->appInfo), PROXY_CHANNEL_SERVER);
659 if (ret != SOFTBUS_OK) {
660 TRANS_LOGE(TRANS_CTRL, "Trans send on channel opened requeset fail. ret=%{public}d", ret);
661 TransPagingAckHandshake(chan, ret);
662 TransProxyDelChanByChanId(chan->channelId);
663 return ret;
664 }
665 return SOFTBUS_OK;
666 }
667
TransProxyPagingCheckListen(ProxyChannelInfo * chan)668 static int32_t TransProxyPagingCheckListen(ProxyChannelInfo *chan)
669 {
670 int32_t ret = SOFTBUS_OK;
671 if (TransHasAndUpdatePagingListenPacked(chan)) {
672 TRANS_LOGE(TRANS_CTRL, "has listen start callback, businessFlag=%{public}u",
673 chan->appInfo.peerData.businessFlag);
674 ret = TransProxyPagingChannelOpened(chan);
675 if (ret != SOFTBUS_OK) {
676 TRANS_LOGE(TRANS_CTRL, "paging on opened failed, businessFlag=%{public}u",
677 chan->appInfo.peerData.businessFlag);
678 return ret;
679 }
680 return SOFTBUS_OK;
681 }
682 ret = TransCheckPagingListenState(chan->appInfo.peerData.businessFlag);
683 if (ret != SOFTBUS_OK) {
684 TRANS_LOGE(TRANS_CTRL, "CheckPagingListenState failed, businessFlag=%{public}u",
685 chan->appInfo.peerData.businessFlag);
686 return ret;
687 }
688 ret = TransReversePullUpPacked(CHAT_MODE_SINGLE, chan->appInfo.peerData.businessFlag, chan->appInfo.myData.pkgName);
689 if (ret != SOFTBUS_OK) {
690 TRANS_LOGE(TRANS_CTRL, "TransReversePullUp failed, businessFlag=%{public}u",
691 chan->appInfo.peerData.businessFlag);
692 return ret;
693 }
694 return SOFTBUS_OK;
695 }
696
ReportPagingProcessHandshakeExtra(const ProxyChannelInfo * chan)697 static void ReportPagingProcessHandshakeExtra(const ProxyChannelInfo *chan)
698 {
699 TransEventExtra extra = {
700 .channelId = chan->channelId,
701 .peerChannelId = chan->peerId,
702 .connectionId = (int32_t)chan->connId,
703 .result = EVENT_STAGE_RESULT_OK,
704 .peerUdid = chan->appInfo.peerUdid,
705 .callerAccountId = chan->appInfo.myData.callerAccountId,
706 .calleeAccountId = chan->appInfo.myData.calleeAccountId,
707 .socketName = chan->appInfo.myData.sessionName,
708 .businessFlag = chan->appInfo.peerData.businessFlag
709 };
710 TRANS_EVENT(EVENT_SCENE_PAGING_CONNECT, EVENT_STAGE_PAGING_SINK_HANDSHAKE_START, extra);
711 }
712
TransPagingProcessHandshakeMsg(const ProxyMessage * msg,uint8_t * accountHash,uint8_t * udidHash,const char * authAccountHash)713 void TransPagingProcessHandshakeMsg(
714 const ProxyMessage *msg, uint8_t *accountHash, uint8_t *udidHash, const char *authAccountHash)
715 {
716 TRANS_CHECK_AND_RETURN_LOGE(msg != NULL, TRANS_CTRL, "invalid param");
717 TRANS_LOGI(TRANS_CTRL, "recv paging Handshake, peerChannelId=%{public}d", msg->msgHead.peerId);
718 ProxyChannelInfo *chan = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
719 TRANS_CHECK_AND_RETURN_LOGE(chan != NULL, TRANS_CTRL, "proxy handshake calloc failed.");
720 int32_t ret = TransProxyFillPagingChannelInfo(msg, chan, accountHash, udidHash, authAccountHash);
721 if (ret != SOFTBUS_OK) {
722 TRANS_CHECK_AND_RETURN_LOGE(chan != NULL, TRANS_CTRL,
723 "unpack handshake failed, peerChannelId=%{public}d",
724 msg->msgHead.peerId);
725 TransPagingAckHandshake(chan, SOFTBUS_TRANS_PAGING_FILL_CHANNEL_FAIL);
726 ReleaseProxyChannelId(chan->channelId);
727 SoftBusFree(chan);
728 return;
729 }
730 chan->appInfo.timeStart = GetSoftbusRecordTimeMillis();
731 ReportPagingProcessHandshakeExtra(chan);
732 ret = TransGetPkgnameByBusinessFlagPacked(chan->appInfo.peerData.businessFlag,
733 (char *)&(chan->appInfo.myData.pkgName), sizeof(chan->appInfo.myData.pkgName));
734 if (ret != SOFTBUS_OK) {
735 TRANS_LOGE(TRANS_CTRL, "get pkg name failed, businessFlag=%{public}u, ret=%{public}d",
736 chan->appInfo.peerData.businessFlag, ret);
737 TransPagingAckHandshake(chan, SOFTBUS_TRANS_PAGING_GET_PKGNAME_FAIL);
738 ReleaseProxyChannelId(chan->channelId);
739 SoftBusFree(chan);
740 return;
741 }
742 ret = TransProxyCreatePagingChanInfo(chan);
743 if (ret != SOFTBUS_OK) {
744 TRANS_LOGE(TRANS_CTRL, "create channel failed, businessFlag=%{public}u", chan->appInfo.peerData.businessFlag);
745 TransPagingAckHandshake(chan, SOFTBUS_TRANS_PAGING_SAVE_CHANNEL);
746 ReleaseProxyChannelId(chan->channelId);
747 SoftBusFree(chan);
748 return;
749 }
750 TransCreateConnByConnId(chan->connId, false);
751 ProxyChannelInfo channel = { 0 };
752 if (memcpy_s(&channel, sizeof(ProxyChannelInfo), chan, sizeof(ProxyChannelInfo)) != EOK) {
753 TRANS_LOGE(TRANS_CTRL, "memcpy failed");
754 TransPagingAckHandshake(chan, SOFTBUS_MEM_ERR);
755 TransProxyDelChanByChanId(chan->channelId);
756 return;
757 }
758 ret = TransProxyPagingCheckListen(&channel);
759 if (ret != SOFTBUS_OK) {
760 TRANS_LOGE(TRANS_CTRL, "check listen failed, businessFlag=%{public}u", channel.appInfo.peerData.businessFlag);
761 TransPagingAckHandshake(&channel, ret);
762 TransProxyDelChanByChanId(channel.channelId);
763 }
764 }
765
TransWaitListenResult(uint32_t businessFlag,int32_t reason)766 void TransWaitListenResult(uint32_t businessFlag, int32_t reason)
767 {
768 int32_t ret = reason;
769 if (ret != SOFTBUS_OK) {
770 goto EXIT_ERR;
771 }
772 ProxyChannelInfo chan;
773 (void)memset_s(&chan, sizeof(ProxyChannelInfo), 0, sizeof(ProxyChannelInfo));
774 ret = TransProxyGetChannelByFlag(businessFlag, &chan, false);
775 if (ret != SOFTBUS_OK) {
776 goto EXIT_ERR;
777 }
778 if (!TransHasAndUpdatePagingListenPacked(&chan)) {
779 ret = SOFTBUS_TRANS_PAGING_LIST_NOT_INIT;
780 goto EXIT_ERR;
781 }
782 ret = TransProxyPagingChannelOpened(&chan);
783 TRANS_LOGI(TRANS_CTRL, "TransProxyPagingChannelOpened, businessFlag=%{public}u, ret=%{public}d",
784 chan.appInfo.peerData.businessFlag, ret);
785 if (ret != SOFTBUS_OK) {
786 goto EXIT_ERR;
787 }
788 return;
789 EXIT_ERR:
790 TransPagingAckHandshake(&chan, ret);
791 ReleaseProxyChannelId(chan.channelId);
792 }
793
PagingParseMsgGetAuthKey(uint8_t * accountHash,uint8_t * udidHash,AesGcmCipherKey * cipherKey,char * authAccountHash)794 static int32_t PagingParseMsgGetAuthKey(
795 uint8_t *accountHash, uint8_t *udidHash, AesGcmCipherKey *cipherKey, char *authAccountHash)
796 {
797 RequestBusinessInfo businessInfo;
798 (void)memset_s(&businessInfo, sizeof(RequestBusinessInfo), 0, sizeof(RequestBusinessInfo));
799 businessInfo.type = BUSINESS_TYPE_D2D;
800 if (ConvertBytesToHexString(businessInfo.udidHash, D2D_UDID_HASH_STR_LEN,
801 udidHash, D2D_SHORT_UDID_HASH_LEN) != SOFTBUS_OK ||
802 ConvertBytesToHexString(businessInfo.accountHash, D2D_ACCOUNT_HASH_STR_LEN,
803 accountHash, D2D_SHORT_ACCOUNT_HASH_LEN) != SOFTBUS_OK) {
804 TRANS_LOGE(TRANS_CTRL, "convert udidhash or account hex string fail");
805 return SOFTBUS_NETWORK_BYTES_TO_HEX_STR_ERR;
806 }
807 uint8_t applyKey[SESSION_KEY_LENGTH] = { 0 };
808 int32_t ret = AuthFindApplyKey(&businessInfo, applyKey, authAccountHash, SHA_256_HEX_HASH_LEN);
809 if (ret != SOFTBUS_OK) {
810 TRANS_LOGE(TRANS_CTRL, "get auth key fail");
811 return ret;
812 }
813 if (memcpy_s(cipherKey->key, SESSION_KEY_LENGTH, applyKey, SESSION_KEY_LENGTH)) {
814 TRANS_LOGE(TRANS_CTRL, "memcpy auth key fail");
815 return SOFTBUS_MEM_ERR;
816 }
817 return SOFTBUS_OK;
818 }
819
TransPagingParseHeadAndGetHash(char * data,int32_t len,ProxyMessage * msg,uint8_t * accountHash,uint8_t * udidHash)820 static int32_t TransPagingParseHeadAndGetHash(
821 char *data, int32_t len, ProxyMessage *msg, uint8_t *accountHash, uint8_t *udidHash)
822 {
823 if (msg->msgHead.type == PROXYCHANNEL_MSG_TYPE_PAGING_HANDSHAKE) {
824 return TransPagingParseHandshakeMessageHead(data, len, msg, accountHash, udidHash);
825 }
826 TransPagingParseMessageHead(data, len, msg);
827 ProxyChannelInfo chan;
828 (void)memset_s(&chan, sizeof(ProxyChannelInfo), 0, sizeof(ProxyChannelInfo));
829 int32_t ret = TransProxyGetChanByChanId(msg->msgHead.myId, &chan);
830 if (ret != SOFTBUS_OK) {
831 return ret;
832 }
833 if (memcpy_s(accountHash, D2D_SHORT_ACCOUNT_HASH_LEN, chan.appInfo.peerData.shortAccountHash,
834 D2D_SHORT_ACCOUNT_HASH_LEN) != EOK ||
835 memcpy_s(udidHash, D2D_SHORT_UDID_HASH_LEN, chan.appInfo.peerData.shortUdidHash,
836 D2D_SHORT_UDID_HASH_LEN) != EOK) {
837 return SOFTBUS_MEM_ERR;
838 }
839 return SOFTBUS_OK;
840 }
841
TransPagingPackMessageHead(PagingMessageHead * msgHead,uint8_t * buf,uint8_t * accountHash,uint8_t * udidHash,bool needHash)842 static int32_t TransPagingPackMessageHead(PagingMessageHead *msgHead, uint8_t *buf,
843 uint8_t *accountHash, uint8_t *udidHash, bool needHash)
844 {
845 uint32_t offset = 0;
846 *buf = msgHead->type;
847 offset += sizeof(uint8_t);
848 *(uint16_t *)(buf + offset) = SoftBusLEtoBEs((uint16_t)msgHead->channelId);
849 if (!needHash) {
850 return SOFTBUS_OK;
851 }
852 offset += sizeof(uint16_t);
853 if (memcpy_s(buf + offset, D2D_SHORT_ACCOUNT_HASH_LEN, accountHash, D2D_SHORT_ACCOUNT_HASH_LEN) != EOK) {
854 TRANS_LOGE(TRANS_CTRL, "copy short account hash fail");
855 return SOFTBUS_MEM_ERR;
856 }
857 offset += D2D_SHORT_ACCOUNT_HASH_LEN;
858 if (memcpy_s(buf + offset, D2D_SHORT_ACCOUNT_HASH_LEN, udidHash, D2D_SHORT_ACCOUNT_HASH_LEN) != EOK) {
859 TRANS_LOGE(TRANS_CTRL, "copy short udid hash fail");
860 return SOFTBUS_MEM_ERR;
861 }
862 return SOFTBUS_OK;
863 }
864
TransPagingSendBadKeyMsg(ProxyMessage * msg,uint8_t * accountHash,uint8_t * udidHash)865 static void TransPagingSendBadKeyMsg(ProxyMessage *msg, uint8_t *accountHash, uint8_t *udidHash)
866 {
867 ProxyDataInfo dataInfo;
868 dataInfo.inData = (uint8_t *)msg->data;
869 dataInfo.inLen = (uint32_t)msg->dataLen;
870 dataInfo.outData = NULL;
871 dataInfo.outLen = 0;
872 msg->msgHead.type = (PROXYCHANNEL_MSG_TYPE_PAGING_BADKEY & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
873 uint32_t connHeadLen = ConnGetHeadSize();
874 uint32_t size = PAGING_CHANNEL_HEAD_LEN + connHeadLen + dataInfo.inLen;
875 uint8_t *buf = (uint8_t *)SoftBusCalloc(size);
876 if (buf == NULL) {
877 TRANS_LOGE(TRANS_CTRL, "malloc proxy buf fail, peerChannelId=%{public}d", msg->msgHead.peerId);
878 return;
879 }
880 PagingMessageHead head = {
881 .type = msg->msgHead.type,
882 .channelId = msg->msgHead.peerId,
883 };
884 TransPagingPackMessageHead(&head, buf + connHeadLen, accountHash, udidHash, false);
885 if (memcpy_s(buf + connHeadLen + PAGING_CHANNEL_HEAD_LEN,
886 size - connHeadLen - PAGING_CHANNEL_HEAD_LEN, dataInfo.inData, dataInfo.inLen) != EOK) {
887 TRANS_LOGE(TRANS_CTRL, "bad key message memcpy fail.");
888 SoftBusFree(buf);
889 return;
890 }
891 dataInfo.outData = buf;
892 dataInfo.outLen = size;
893 int32_t ret = TransProxyTransSendMsg(msg->connId, dataInfo.outData, dataInfo.outLen, CONN_HIGH, 0);
894 TRANS_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, TRANS_MSG, "send bad key buf fail");
895 return;
896 }
897
TransPagingParseMessage(char * data,int32_t len,ProxyMessage * msg)898 int32_t TransPagingParseMessage(char *data, int32_t len, ProxyMessage *msg)
899 {
900 TRANS_CHECK_AND_RETURN_RET_LOGE((msg->msgHead.type == PROXYCHANNEL_MSG_TYPE_PAGING_HANDSHAKE &&
901 len > PAGING_CHANNEL_HANDSHAKE_HEAD_LEN) ||
902 (msg->msgHead.type != PROXYCHANNEL_MSG_TYPE_PAGING_HANDSHAKE && len > PAGING_CHANNEL_HEAD_LEN),
903 SOFTBUS_INVALID_PARAM, TRANS_CTRL, "parseMessage: invalid message len, len=%{public}d", len);
904 uint8_t accountHash[D2D_SHORT_ACCOUNT_HASH_LEN] = { 0 };
905 uint8_t udidHash[D2D_SHORT_UDID_HASH_LEN] = { 0 };
906 int32_t ret = TransPagingParseHeadAndGetHash(data, len, msg, accountHash, udidHash);
907 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "parse msg head fail");
908
909 AesGcmCipherKey cipherKey = { 0 };
910 cipherKey.keyLen = SESSION_KEY_LENGTH;
911 char authAccountHash[SHA_256_HEX_HASH_LEN] = { 0 };
912 ret = PagingParseMsgGetAuthKey(accountHash, udidHash, &cipherKey, authAccountHash);
913 if (ret != SOFTBUS_OK) {
914 TRANS_LOGE(TRANS_CTRL, "parse msg get auth key fail");
915 if (msg->msgHead.type == PROXYCHANNEL_MSG_TYPE_PAGING_HANDSHAKE) {
916 TRANS_LOGE(TRANS_CTRL, "send bad key by handshake");
917 TransPagingSendBadKeyMsg(msg, accountHash, udidHash);
918 }
919 return ret;
920 }
921 uint32_t decDataLen = (uint32_t)msg->dataLen - OVERHEAD_LEN;
922 uint8_t *decData = (uint8_t *)SoftBusCalloc(decDataLen);
923 TRANS_CHECK_AND_RETURN_RET_LOGE(decData != NULL, SOFTBUS_MALLOC_ERR, TRANS_CTRL, "calloc fail.");
924 if (SoftBusDecryptData(&cipherKey, (uint8_t *)msg->data, (uint32_t)msg->dataLen,
925 decData, &decDataLen) != SOFTBUS_OK) {
926 TRANS_LOGE(TRANS_CTRL, "parse msg decrypt fail");
927 SoftBusFree(decData);
928 return SOFTBUS_DECRYPT_ERR;
929 }
930 msg->data = (char *)decData;
931 msg->dataLen = (int32_t)decDataLen;
932 switch (msg->msgHead.type) {
933 case PROXYCHANNEL_MSG_TYPE_PAGING_HANDSHAKE:
934 TransPagingProcessHandshakeMsg(msg, accountHash, udidHash, authAccountHash);
935 break;
936 case PROXYCHANNEL_MSG_TYPE_PAGING_HANDSHAKE_ACK:
937 TransPagingProcessHandshakeAckMsg(msg);
938 break;
939 case PROXYCHANNEL_MSG_TYPE_PAGING_BADKEY:
940 TransPagingProcessBadKeyMsg(msg);
941 break;
942 case PROXYCHANNEL_MSG_TYPE_PAGING_RESET:
943 TransPagingProcessResetMsg(msg);
944 break;
945 }
946 SoftBusFree(msg->data);
947 return SOFTBUS_OK;
948 }
949
TransProxyParseMessage(char * data,int32_t len,ProxyMessage * msg,AuthHandle * auth)950 int32_t TransProxyParseMessage(char *data, int32_t len, ProxyMessage *msg, AuthHandle *auth)
951 {
952 TRANS_CHECK_AND_RETURN_RET_LOGE(len > PROXY_CHANNEL_HEAD_LEN,
953 SOFTBUS_INVALID_PARAM, TRANS_CTRL, "parseMessage: invalid message len, len=%{public}d", len);
954 int32_t ret = TransProxyParseMessageHead(data, len, msg);
955 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "TransProxyParseMessageHead fail!");
956 if ((msg->msgHead.cipher & ENCRYPTED) != 0) {
957 if ((uint32_t)msg->dataLen < (sizeof(uint32_t) + OVERHEAD_LEN) ||
958 (uint32_t)msg->dataLen > (PROXY_BYTES_LENGTH_MAX + OVERHEAD_LEN + sizeof(uint32_t))) {
959 TRANS_LOGE(TRANS_CTRL, "The data length of the ProxyMessage is abnormal!");
960 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
961 }
962 if (msg->msgHead.type == PROXYCHANNEL_MSG_TYPE_HANDSHAKE) {
963 TRANS_LOGD(TRANS_CTRL, "prxoy recv handshake cipher=0x%{public}02x", msg->msgHead.cipher);
964 ret = GetAuthIdByHandshakeMsg(
965 msg->connId, msg->msgHead.cipher, auth, (int32_t)SoftBusLtoHl(*(uint32_t *)msg->data));
966 } else {
967 ret = TransProxyGetAuthId(msg->msgHead.myId, auth);
968 }
969 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK && auth->authId != AUTH_INVALID_ID, SOFTBUS_AUTH_NOT_FOUND,
970 TRANS_CTRL, "get authId fail, connId=%{public}d, myChannelId=%{public}d, type=%{public}d", msg->connId,
971 msg->msgHead.myId, msg->msgHead.type);
972 msg->authHandle = (*auth);
973 uint32_t decDataLen = AuthGetDecryptSize((uint32_t)msg->dataLen);
974 uint8_t *decData = (uint8_t *)SoftBusCalloc(decDataLen);
975 TRANS_CHECK_AND_RETURN_RET_LOGE(decData != NULL, SOFTBUS_MALLOC_ERR, TRANS_CTRL, "calloc fail.");
976 msg->keyIndex = (int32_t)SoftBusLtoHl(*(uint32_t *)msg->data);
977 if (AuthDecrypt(auth, (uint8_t *)msg->data, (uint32_t)msg->dataLen, decData, &decDataLen) != SOFTBUS_OK &&
978 GetAuthIdReDecrypt(auth, msg, decData, &decDataLen) != SOFTBUS_OK) {
979 TRANS_LOGE(TRANS_CTRL, "parse msg decrypt fail");
980 SoftBusFree(decData);
981 return SOFTBUS_DECRYPT_ERR;
982 }
983 msg->data = (char *)decData;
984 msg->dataLen = (int32_t)decDataLen;
985 } else {
986 ret = TransProxyParseMessageNoDecrypt(msg);
987 TRANS_CHECK_AND_RETURN_RET_LOGE(
988 ret == SOFTBUS_OK, ret, TRANS_CTRL, "trans not need decrypt msg fail, ret=%{public}d", ret);
989 }
990 return SOFTBUS_OK;
991 }
992
PackPlaintextMessage(ProxyMessageHead * msg,ProxyDataInfo * dataInfo)993 int32_t PackPlaintextMessage(ProxyMessageHead *msg, ProxyDataInfo *dataInfo)
994 {
995 if (msg == NULL || dataInfo == NULL) {
996 TRANS_LOGE(TRANS_CTRL, "invalid param.");
997 return SOFTBUS_INVALID_PARAM;
998 }
999 uint32_t connHeadLen = ConnGetHeadSize();
1000 uint32_t size = PROXY_CHANNEL_HEAD_LEN + connHeadLen + dataInfo->inLen;
1001 uint8_t *buf = (uint8_t *)SoftBusCalloc(size);
1002 if (buf == NULL) {
1003 TRANS_LOGE(TRANS_CTRL, "malloc proxy buf fail, myChannelId=%{public}d", msg->myId);
1004 return SOFTBUS_MALLOC_ERR;
1005 }
1006 TransProxyPackMessageHead(msg, buf + connHeadLen, PROXY_CHANNEL_HEAD_LEN);
1007 if (memcpy_s(buf + connHeadLen + PROXY_CHANNEL_HEAD_LEN, size - connHeadLen - PROXY_CHANNEL_HEAD_LEN,
1008 dataInfo->inData, dataInfo->inLen) != EOK) {
1009 TRANS_LOGE(TRANS_CTRL, "plaint ext message memcpy fail.");
1010 SoftBusFree(buf);
1011 return SOFTBUS_MEM_ERR;
1012 }
1013 dataInfo->outData = buf;
1014 dataInfo->outLen = size;
1015 return SOFTBUS_OK;
1016 }
1017
PackEncryptedMessage(ProxyMessageHead * msg,AuthHandle authHandle,ProxyDataInfo * dataInfo)1018 static int32_t PackEncryptedMessage(ProxyMessageHead *msg, AuthHandle authHandle, ProxyDataInfo *dataInfo)
1019 {
1020 if (authHandle.authId == AUTH_INVALID_ID) {
1021 TRANS_LOGE(TRANS_CTRL, "invalid authId, myChannelId=%{public}d", msg->myId);
1022 return SOFTBUS_INVALID_PARAM;
1023 }
1024 uint32_t size = ConnGetHeadSize() + PROXY_CHANNEL_HEAD_LEN + AuthGetEncryptSize(authHandle.authId, dataInfo->inLen);
1025 uint8_t *buf = (uint8_t *)SoftBusCalloc(size);
1026 if (buf == NULL) {
1027 TRANS_LOGE(TRANS_CTRL, "malloc enc buf fail, myChannelId=%{public}d", msg->myId);
1028 return SOFTBUS_MALLOC_ERR;
1029 }
1030 TransProxyPackMessageHead(msg, buf + ConnGetHeadSize(), PROXY_CHANNEL_HEAD_LEN);
1031 uint8_t *encData = buf + ConnGetHeadSize() + PROXY_CHANNEL_HEAD_LEN;
1032 uint32_t encDataLen = size - ConnGetHeadSize() - PROXY_CHANNEL_HEAD_LEN;
1033 if (AuthEncrypt(&authHandle, dataInfo->inData, dataInfo->inLen, encData, &encDataLen) != SOFTBUS_OK) {
1034 SoftBusFree(buf);
1035 TRANS_LOGE(TRANS_CTRL, "pack msg encrypt fail, myChannelId=%{public}d", msg->myId);
1036 return SOFTBUS_ENCRYPT_ERR;
1037 }
1038 dataInfo->outData = buf;
1039 dataInfo->outLen = size;
1040 return SOFTBUS_OK;
1041 }
1042
TransPagingPackMessage(PagingProxyMessage * msg,ProxyDataInfo * dataInfo,ProxyChannelInfo * chan,bool needHash)1043 int32_t TransPagingPackMessage(PagingProxyMessage *msg, ProxyDataInfo *dataInfo, ProxyChannelInfo *chan, bool needHash)
1044 {
1045 if (msg == NULL || dataInfo == NULL || chan == NULL) {
1046 TRANS_LOGE(TRANS_CTRL, "invalid param");
1047 return SOFTBUS_INVALID_PARAM;
1048 }
1049 uint32_t headLen = needHash ? PAGING_CHANNEL_HANDSHAKE_HEAD_LEN : PAGING_CHANNEL_HEAD_LEN;
1050 uint32_t size = ConnGetHeadSize() + headLen + dataInfo->inLen + OVERHEAD_LEN;
1051 uint8_t *buf = (uint8_t *)SoftBusCalloc(size);
1052 if (buf == NULL) {
1053 TRANS_LOGE(TRANS_CTRL, "malloc enc buf fail, channelId=%{public}d", msg->msgHead.channelId);
1054 return SOFTBUS_MALLOC_ERR;
1055 }
1056 TransPagingPackMessageHead(&msg->msgHead, buf + ConnGetHeadSize(), chan->appInfo.myData.shortAccountHash,
1057 chan->appInfo.myData.shortUdidHash, needHash);
1058 uint8_t *encData = buf + ConnGetHeadSize() + headLen;
1059 uint32_t encDataLen = size - ConnGetHeadSize() - headLen;
1060 AesGcmCipherKey cipherKey = { 0 };
1061 cipherKey.keyLen = SESSION_KEY_LENGTH;
1062 if (memcpy_s(cipherKey.key, SESSION_KEY_LENGTH, msg->authKey, SESSION_KEY_LENGTH) != EOK) {
1063 TRANS_LOGE(TRANS_CTRL, "set key fail");
1064 SoftBusFree(buf);
1065 return SOFTBUS_MEM_ERR;
1066 }
1067 int32_t ret = SoftBusEncryptData(&cipherKey, dataInfo->inData, dataInfo->inLen, encData, &encDataLen);
1068 if (ret != SOFTBUS_OK) {
1069 TRANS_LOGE(TRANS_CTRL, "encrypt buf fail, myChannelId=%{public}d", msg->msgHead.channelId);
1070 SoftBusFree(buf);
1071 return SOFTBUS_ENCRYPT_ERR;
1072 }
1073 dataInfo->outData = buf;
1074 dataInfo->outLen = size;
1075 return SOFTBUS_OK;
1076 }
1077
TransProxyPackMessage(ProxyMessageHead * msg,AuthHandle authHandle,ProxyDataInfo * dataInfo)1078 int32_t TransProxyPackMessage(
1079 ProxyMessageHead *msg, AuthHandle authHandle, ProxyDataInfo *dataInfo)
1080 {
1081 if (msg == NULL || dataInfo == NULL || dataInfo->inData == NULL || dataInfo->inLen == 0) {
1082 return SOFTBUS_INVALID_PARAM;
1083 }
1084
1085 int32_t ret;
1086 if ((msg->cipher & ENCRYPTED) == 0) {
1087 ret = PackPlaintextMessage(msg, dataInfo);
1088 } else {
1089 ret = PackEncryptedMessage(msg, authHandle, dataInfo);
1090 }
1091 if (ret != SOFTBUS_OK) {
1092 TRANS_LOGE(TRANS_CTRL, "pack proxy msg fail, myChannelId=%{public}d", msg->myId);
1093 return ret;
1094 }
1095 return SOFTBUS_OK;
1096 }
1097
PackHandshakeMsgForFastData(AppInfo * appInfo,cJSON * root)1098 static int32_t PackHandshakeMsgForFastData(AppInfo *appInfo, cJSON *root)
1099 {
1100 if (appInfo->fastTransDataSize > 0) {
1101 TRANS_LOGI(TRANS_CTRL, "have fast data need transport");
1102 if (!AddNumberToJsonObject(root, JSON_KEY_ROUTE_TYPE, appInfo->routeType)) {
1103 TRANS_LOGE(TRANS_CTRL, "add route type fail.");
1104 return SOFTBUS_PARSE_JSON_ERR;
1105 }
1106 uint8_t *encodeFastData = (uint8_t *)SoftBusMalloc(BASE64_FAST_DATA_LEN);
1107 if (encodeFastData == NULL) {
1108 TRANS_LOGE(TRANS_CTRL, "malloc encode fast data fail.");
1109 return SOFTBUS_MALLOC_ERR;
1110 }
1111 size_t fastDataSize = 0;
1112 uint32_t outLen;
1113 char *buf = TransProxyPackFastData(appInfo, &outLen);
1114 if (buf == NULL) {
1115 TRANS_LOGE(TRANS_CTRL, "failed to pack bytes.");
1116 SoftBusFree(encodeFastData);
1117 return SOFTBUS_TRANS_PACK_FAST_DATA_FAILED;
1118 }
1119 int32_t ret = SoftBusBase64Encode(encodeFastData, BASE64_FAST_DATA_LEN, &fastDataSize,
1120 (const unsigned char *)buf, outLen);
1121 if (ret != SOFTBUS_OK) {
1122 TRANS_LOGE(TRANS_CTRL, "mbedtls base64 encode failed.");
1123 SoftBusFree(encodeFastData);
1124 SoftBusFree(buf);
1125 return SOFTBUS_DECRYPT_ERR;
1126 }
1127 if (!AddStringToJsonObject(root, JSON_KEY_FIRST_DATA, (const char *)encodeFastData)) {
1128 TRANS_LOGE(TRANS_CTRL, "add first data failed.");
1129 SoftBusFree(encodeFastData);
1130 SoftBusFree(buf);
1131 return SOFTBUS_PARSE_JSON_ERR;
1132 }
1133 SoftBusFree(encodeFastData);
1134 SoftBusFree(buf);
1135 }
1136 if (!AddNumber16ToJsonObject(root, JSON_KEY_FIRST_DATA_SIZE, appInfo->fastTransDataSize)) {
1137 TRANS_LOGE(TRANS_CTRL, "add first data size failed.");
1138 return SOFTBUS_PARSE_JSON_ERR;
1139 }
1140 return SOFTBUS_OK;
1141 }
1142
PackHandshakeMsgForNormal(SessionKeyBase64 * sessionBase64,AppInfo * appInfo,cJSON * root)1143 static int32_t PackHandshakeMsgForNormal(SessionKeyBase64 *sessionBase64, AppInfo *appInfo, cJSON *root)
1144 {
1145 int32_t ret = SoftBusBase64Encode((unsigned char *)sessionBase64->sessionKeyBase64,
1146 sizeof(sessionBase64->sessionKeyBase64), &(sessionBase64->len),
1147 (unsigned char *)appInfo->sessionKey, sizeof(appInfo->sessionKey));
1148 if (ret != SOFTBUS_OK) {
1149 TRANS_LOGE(TRANS_CTRL, "mbedtls_base64_encode FAIL ret=%{public}d", ret);
1150 return ret;
1151 }
1152 TRANS_LOGI(TRANS_CTRL, "mbedtls_base64_encode len=%{public}zu", sessionBase64->len);
1153 if (!AddNumberToJsonObject(root, JSON_KEY_UID, appInfo->myData.uid) ||
1154 !AddNumberToJsonObject(root, JSON_KEY_PID, appInfo->myData.pid) ||
1155 !AddStringToJsonObject(root, JSON_KEY_GROUP_ID, appInfo->groupId) ||
1156 !AddStringToJsonObject(root, JSON_KEY_PKG_NAME, appInfo->myData.pkgName) ||
1157 !AddStringToJsonObject(root, JSON_KEY_SESSION_KEY, sessionBase64->sessionKeyBase64)) {
1158 return SOFTBUS_PARSE_JSON_ERR;
1159 }
1160 if (!AddNumberToJsonObject(root, JSON_KEY_ENCRYPT, appInfo->encrypt) ||
1161 !AddNumberToJsonObject(root, JSON_KEY_ALGORITHM, appInfo->algorithm) ||
1162 !AddNumberToJsonObject(root, JSON_KEY_CRC, appInfo->crc)) {
1163 return SOFTBUS_PARSE_JSON_ERR;
1164 }
1165 if (PackHandshakeMsgForFastData(appInfo, root) != SOFTBUS_OK) {
1166 TRANS_LOGE(TRANS_CTRL, "proxy channel pack fast data failed");
1167 return SOFTBUS_PARSE_JSON_ERR;
1168 }
1169 (void)AddNumberToJsonObject(root, JSON_KEY_USER_ID, appInfo->myData.userId);
1170 (void)AddStringToJsonObject(root, JSON_KEY_ACCOUNT_ID, appInfo->myData.accountId);
1171 (void)AddNumber64ToJsonObject(root, JSON_KEY_SOURCE_ACL_TOKEN_ID, (int64_t)appInfo->myData.tokenId);
1172 (void)AddStringToJsonObject(root, JSON_KEY_SOURCE_ACL_EXTRA_INFO, appInfo->extraAccessInfo);
1173 (void)AddNumberToJsonObject(root, JSON_KEY_BUSINESS_TYPE, appInfo->businessType);
1174 (void)AddNumberToJsonObject(root, JSON_KEY_TRANS_FLAGS, TRANS_FLAG_HAS_CHANNEL_AUTH);
1175 (void)AddNumberToJsonObject(root, JSON_KEY_MY_HANDLE_ID, appInfo->myHandleId);
1176 (void)AddNumberToJsonObject(root, JSON_KEY_PEER_HANDLE_ID, appInfo->peerHandleId);
1177 (void)AddNumber64ToJsonObject(root, JSON_KEY_CALLING_TOKEN_ID, (int64_t)appInfo->callingTokenId);
1178 return SOFTBUS_OK;
1179 }
1180
TransPagingPackHandshakeErrMsg(int32_t errCode,int32_t channelId)1181 char *TransPagingPackHandshakeErrMsg(int32_t errCode, int32_t channelId)
1182 {
1183 cJSON *root = NULL;
1184 char *buf = NULL;
1185
1186 root = cJSON_CreateObject();
1187 if (root == NULL) {
1188 TRANS_LOGE(TRANS_CTRL, "create json object failed.");
1189 return NULL;
1190 }
1191
1192 if (!AddNumberToJsonObject(root, ERR_CODE, errCode)) {
1193 cJSON_Delete(root);
1194 return NULL;
1195 }
1196 if (!AddNumberToJsonObject(root, JSON_KEY_PAGING_SINK_CHANNEL_ID, channelId)) {
1197 cJSON_Delete(root);
1198 return NULL;
1199 }
1200
1201 buf = cJSON_PrintUnformatted(root);
1202 cJSON_Delete(root);
1203 return buf;
1204 }
1205
TransProxyPackHandshakeErrMsg(int32_t errCode)1206 char *TransProxyPackHandshakeErrMsg(int32_t errCode)
1207 {
1208 cJSON *root = NULL;
1209 char *buf = NULL;
1210
1211 root = cJSON_CreateObject();
1212 if (root == NULL) {
1213 TRANS_LOGE(TRANS_CTRL, "create json object failed.");
1214 return NULL;
1215 }
1216
1217 if (!AddNumberToJsonObject(root, ERR_CODE, errCode)) {
1218 cJSON_Delete(root);
1219 return NULL;
1220 }
1221
1222 buf = cJSON_PrintUnformatted(root);
1223 cJSON_Delete(root);
1224 return buf;
1225 }
1226
TransProxyAddJsonObject(cJSON * root,ProxyChannelInfo * info)1227 static bool TransProxyAddJsonObject(cJSON *root, ProxyChannelInfo *info)
1228 {
1229 if (!AddNumberToJsonObject(root, JSON_KEY_TYPE, info->appInfo.appType) ||
1230 !AddStringToJsonObject(root, JSON_KEY_IDENTITY, info->identity) ||
1231 !AddStringToJsonObject(root, JSON_KEY_DEVICE_ID, info->appInfo.myData.deviceId) ||
1232 !AddStringToJsonObject(root, JSON_KEY_SRC_BUS_NAME, info->appInfo.myData.sessionName) ||
1233 !AddStringToJsonObject(root, JSON_KEY_DST_BUS_NAME, info->appInfo.peerData.sessionName) ||
1234 !AddNumberToJsonObject(root, API_VERSION, info->appInfo.myData.apiVersion) ||
1235 !AddNumberToJsonObject(root, JSON_KEY_MTU_SIZE, info->appInfo.myData.dataConfig)) {
1236 return false;
1237 }
1238 if (!AddNumberToJsonObject(root, TRANS_CAPABILITY, info->appInfo.channelCapability)) {
1239 return false;
1240 }
1241 return true;
1242 }
1243
TransPackPagingExtraData(cJSON * root,void * extraData)1244 static bool TransPackPagingExtraData(cJSON *root, void *extraData)
1245 {
1246 char extraDataStr[EXTRA_DATA_STR_MAX_LEN] = { 0 };
1247 if (ConvertBytesToHexString(extraDataStr, EXTRA_DATA_STR_MAX_LEN,
1248 (const unsigned char *)extraData, EXTRA_DATA_MAX_LEN) != SOFTBUS_OK) {
1249 TRANS_LOGE(TRANS_CTRL, "extraData tostring fail");
1250 return false;
1251 }
1252 return AddStringToJsonObject(root, JSON_KEY_PAGING_EXT_DATA, extraDataStr);
1253 }
1254
TransPagingPackHandshakeMsg(ProxyChannelInfo * info)1255 char *TransPagingPackHandshakeMsg(ProxyChannelInfo *info)
1256 {
1257 if (info == NULL) {
1258 TRANS_LOGE(TRANS_CTRL, "invalid param.");
1259 return NULL;
1260 }
1261
1262 cJSON *root = cJSON_CreateObject();
1263 if (root == NULL) {
1264 TRANS_LOGE(TRANS_CTRL, "create json object failed.");
1265 return NULL;
1266 }
1267 char *buf = NULL;
1268 AppInfo *appInfo = &(info->appInfo);
1269 char shortDeviceId[SHORT_DEVICE_LEN] = { 0 };
1270 if (memcpy_s(shortDeviceId, SHORT_DEVICE_LEN - 1, appInfo->myData.deviceId, SHORT_DEVICE_LEN - 1) != EOK) {
1271 TRANS_LOGE(TRANS_CTRL, "cpy deviceId failed");
1272 cJSON_Delete(root);
1273 return NULL;
1274 }
1275 if (!AddStringToJsonObject(root, JSON_KEY_CALLER_ACCOUNT_ID, appInfo->myData.callerAccountId) ||
1276 !AddStringToJsonObject(root, JSON_KEY_CALLEE_ACCOUNT_ID, appInfo->myData.calleeAccountId) ||
1277 !TransPackPagingExtraData(root, appInfo->myData.extraData) ||
1278 !AddNumberToJsonObject(root, JSON_KEY_PAGING_DATA_LEN, appInfo->myData.dataLen) ||
1279 !AddNumberToJsonObject(root, JSON_KEY_PAGING_BUSINESS_FLAG, appInfo->myData.businessFlag) ||
1280 !AddNumberToJsonObject(root, JSON_KEY_BUSINESS_TYPE, appInfo->businessType) ||
1281 !AddStringToJsonObject(root, JSON_KEY_DEVICE_ID, shortDeviceId)) {
1282 cJSON_Delete(root);
1283 return NULL;
1284 }
1285 buf = cJSON_PrintUnformatted(root);
1286 cJSON_Delete(root);
1287 return buf;
1288 }
1289
TransProxyPackHandshakeMsg(ProxyChannelInfo * info)1290 char *TransProxyPackHandshakeMsg(ProxyChannelInfo *info)
1291 {
1292 if (info == NULL) {
1293 TRANS_LOGE(TRANS_CTRL, "invalid param.");
1294 return NULL;
1295 }
1296
1297 cJSON *root = cJSON_CreateObject();
1298 if (root == NULL) {
1299 TRANS_LOGE(TRANS_CTRL, "create json object failed.");
1300 return NULL;
1301 }
1302 char *buf = NULL;
1303 AppInfo *appInfo = &(info->appInfo);
1304 SessionKeyBase64 sessionBase64;
1305 (void)memset_s(&sessionBase64, sizeof(SessionKeyBase64), 0, sizeof(SessionKeyBase64));
1306 if (!TransProxyAddJsonObject(root, info)) {
1307 goto EXIT;
1308 }
1309 (void)cJSON_AddTrueToObject(root, JSON_KEY_HAS_PRIORITY);
1310 if (appInfo->appType == APP_TYPE_NORMAL) {
1311 if (PackHandshakeMsgForNormal(&sessionBase64, appInfo, root) != SOFTBUS_OK) {
1312 goto EXIT;
1313 }
1314 } else if (appInfo->appType == APP_TYPE_AUTH) {
1315 if (strlen(appInfo->reqId) == 0 && GenerateRandomStr(appInfo->reqId, REQ_ID_SIZE_MAX) != SOFTBUS_OK) {
1316 goto EXIT;
1317 }
1318 if (!AddStringToJsonObject(root, JSON_KEY_REQUEST_ID, appInfo->reqId)) {
1319 goto EXIT;
1320 }
1321 if (!AddStringToJsonObject(root, JSON_KEY_PKG_NAME, appInfo->myData.pkgName)) {
1322 goto EXIT;
1323 }
1324 } else {
1325 int32_t ret = SoftBusBase64Encode((uint8_t *)sessionBase64.sessionKeyBase64,
1326 sizeof(sessionBase64.sessionKeyBase64), &(sessionBase64.len),
1327 (uint8_t *)appInfo->sessionKey, sizeof(appInfo->sessionKey));
1328 if (ret != SOFTBUS_OK) {
1329 TRANS_LOGE(TRANS_CTRL, "mbedtls_base64_encode FAIL ret=%{public}d", ret);
1330 goto EXIT;
1331 }
1332 if (!AddStringToJsonObject(root, JSON_KEY_SESSION_KEY, sessionBase64.sessionKeyBase64)) {
1333 goto EXIT;
1334 }
1335 }
1336 buf = cJSON_PrintUnformatted(root);
1337 EXIT:
1338 cJSON_Delete(root);
1339 return buf;
1340 }
1341
AddSinkSessionKeyToHandshakeAckMsg(cJSON * root,const AppInfo * appInfo)1342 static int32_t AddSinkSessionKeyToHandshakeAckMsg(cJSON *root, const AppInfo *appInfo)
1343 {
1344 (void)AddStringToJsonObject(root, JSON_KEY_SINK_ACL_ACCOUNT_ID, appInfo->myData.accountId);
1345 (void)AddNumberToJsonObject(root, JSON_KEY_SINK_ACL_USER_ID, appInfo->myData.userId);
1346 (void)AddNumber64ToJsonObject(root, JSON_KEY_SINK_ACL_TOKEN_ID, (int64_t)appInfo->myData.tokenId);
1347 return EncryptAndAddSinkSessionKey(root, appInfo);
1348 }
1349
TransPagingPackHandshakeAckMsg(ProxyChannelInfo * chan)1350 char *TransPagingPackHandshakeAckMsg(ProxyChannelInfo *chan)
1351 {
1352 TRANS_CHECK_AND_RETURN_RET_LOGE(chan != NULL, NULL, TRANS_CTRL, "invalid param.");
1353 AppInfo *appInfo = &(chan->appInfo);
1354 TRANS_CHECK_AND_RETURN_RET_LOGE(appInfo != NULL, NULL, TRANS_CTRL, "invalid param.");
1355 char shortDeviceId[SHORT_DEVICE_LEN] = { 0 };
1356 if (memcpy_s(shortDeviceId, SHORT_DEVICE_LEN - 1, appInfo->myData.deviceId, SHORT_DEVICE_LEN - 1) != EOK) {
1357 TRANS_LOGE(TRANS_CTRL, "cpy deviceid failed");
1358 return NULL;
1359 }
1360 int32_t localDevTypeId = 0;
1361 if (LnnGetLocalNumInfo(NUM_KEY_DEV_TYPE_ID, &localDevTypeId) != SOFTBUS_OK) {
1362 TRANS_LOGE(TRANS_CTRL, "get device type id failed");
1363 return NULL;
1364 }
1365 char sessionKeyBase64[ORIGIN_LEN_16_BASE64_LENGTH] = { 0 };
1366 size_t len = 0;
1367 int32_t ret = SoftBusBase64Encode((unsigned char *)sessionKeyBase64, sizeof(sessionKeyBase64),
1368 &(len), (unsigned char *)appInfo->pagingSessionkey, sizeof(appInfo->pagingSessionkey));
1369 if (ret != SOFTBUS_OK) {
1370 TRANS_LOGE(TRANS_CTRL, "base64 encode session key fail ret=%{public}d, encodeLen=%{public}zu",
1371 ret, len);
1372 return NULL;
1373 }
1374 char nonceBase64[ORIGIN_LEN_16_BASE64_LENGTH] = { 0 };
1375 len = 0;
1376 ret = SoftBusBase64Encode((unsigned char *)nonceBase64, sizeof(nonceBase64), &len,
1377 (unsigned char *)appInfo->pagingNonce, sizeof(appInfo->pagingNonce));
1378 if (ret != SOFTBUS_OK) {
1379 TRANS_LOGE(TRANS_CTRL, "base64 encode nonce fail ret=%{public}d, encodeLen=%{public}zu",
1380 ret, len);
1381 return NULL;
1382 }
1383 cJSON *root = cJSON_CreateObject();
1384 TRANS_CHECK_AND_RETURN_RET_LOGE(root != NULL, NULL, TRANS_CTRL, "create json object failed.");
1385 if (!AddNumberToJsonObject(root, JSON_KEY_PAGING_SINK_CHANNEL_ID, appInfo->myData.channelId) ||
1386 !AddStringToJsonObject(root, JSON_KEY_SESSION_KEY, sessionKeyBase64) ||
1387 !AddStringToJsonObject(root, JSON_KEY_PAGING_NONCE, nonceBase64) ||
1388 !AddStringToJsonObject(root, JSON_KEY_DEVICE_ID, shortDeviceId) ||
1389 !AddNumberToJsonObject(root, JSON_KEY_DEVICETYPE_ID, localDevTypeId) ||
1390 !TransPackPagingExtraData(root, appInfo->myData.extraData) ||
1391 !AddNumberToJsonObject(root, JSON_KEY_PAGING_DATA_LEN, appInfo->myData.dataLen)) {
1392 cJSON_Delete(root);
1393 return NULL;
1394 }
1395
1396 char *buf = cJSON_PrintUnformatted(root);
1397 cJSON_Delete(root);
1398 return buf;
1399 }
1400
TransProxyPackHandshakeAckMsg(ProxyChannelInfo * chan)1401 char *TransProxyPackHandshakeAckMsg(ProxyChannelInfo *chan)
1402 {
1403 TRANS_CHECK_AND_RETURN_RET_LOGE(chan != NULL, NULL, TRANS_CTRL, "invalid param.");
1404 AppInfo *appInfo = &(chan->appInfo);
1405 TRANS_CHECK_AND_RETURN_RET_LOGE(appInfo != NULL, NULL, TRANS_CTRL, "invalid param.");
1406 TRANS_CHECK_AND_RETURN_RET_LOGE(appInfo->appType != APP_TYPE_NOT_CARE, NULL, TRANS_CTRL, "invalid appType.");
1407
1408 cJSON *root = cJSON_CreateObject();
1409 TRANS_CHECK_AND_RETURN_RET_LOGE(root != NULL, NULL, TRANS_CTRL, "create json object failed.");
1410 if (!AddStringToJsonObject(root, JSON_KEY_IDENTITY, chan->identity) ||
1411 !AddStringToJsonObject(root, JSON_KEY_DEVICE_ID, appInfo->myData.deviceId) ||
1412 !AddNumberToJsonObject(root, TRANS_CAPABILITY, appInfo->channelCapability)) {
1413 cJSON_Delete(root);
1414 return NULL;
1415 }
1416 if (appInfo->peerData.dataConfig != 0) {
1417 if (!AddNumberToJsonObject(root, JSON_KEY_MTU_SIZE, appInfo->myData.dataConfig)) {
1418 cJSON_Delete(root);
1419 return NULL;
1420 }
1421 }
1422 (void)cJSON_AddTrueToObject(root, JSON_KEY_HAS_PRIORITY);
1423 if (appInfo->appType == APP_TYPE_NORMAL) {
1424 if (!AddNumberToJsonObject(root, JSON_KEY_UID, appInfo->myData.uid) ||
1425 !AddNumberToJsonObject(root, JSON_KEY_PID, appInfo->myData.pid) ||
1426 !AddStringToJsonObject(root, JSON_KEY_PKG_NAME, appInfo->myData.pkgName) ||
1427 !AddNumberToJsonObject(root, JSON_KEY_ENCRYPT, appInfo->encrypt) ||
1428 !AddNumberToJsonObject(root, JSON_KEY_ALGORITHM, appInfo->algorithm) ||
1429 !AddNumberToJsonObject(root, JSON_KEY_CRC, appInfo->crc) ||
1430 !AddNumber16ToJsonObject(root, JSON_KEY_FIRST_DATA_SIZE, appInfo->fastTransDataSize) ||
1431 !AddStringToJsonObject(root, JSON_KEY_SRC_BUS_NAME, appInfo->myData.sessionName) ||
1432 !AddStringToJsonObject(root, JSON_KEY_DST_BUS_NAME, appInfo->peerData.sessionName)) {
1433 cJSON_Delete(root);
1434 return NULL;
1435 }
1436 (void)AddNumberToJsonObject(root, JSON_KEY_MY_HANDLE_ID, appInfo->myHandleId);
1437 if (AddSinkSessionKeyToHandshakeAckMsg(root, &chan->appInfo) != SOFTBUS_OK) {
1438 cJSON_Delete(root);
1439 return NULL;
1440 }
1441 } else if (appInfo->appType == APP_TYPE_AUTH) {
1442 if (!AddStringToJsonObject(root, JSON_KEY_PKG_NAME, appInfo->myData.pkgName)) {
1443 cJSON_Delete(root);
1444 return NULL;
1445 }
1446 }
1447
1448 char *buf = cJSON_PrintUnformatted(root);
1449 cJSON_Delete(root);
1450 return buf;
1451 }
1452
TransProxyUnPackHandshakeErrMsg(const char * msg,int32_t * errCode,int32_t len)1453 int32_t TransProxyUnPackHandshakeErrMsg(const char *msg, int32_t *errCode, int32_t len)
1454 {
1455 if (errCode == NULL) {
1456 TRANS_LOGE(TRANS_CTRL, "invalid param errCode.");
1457 return SOFTBUS_INVALID_PARAM;
1458 }
1459
1460 cJSON *root = cJSON_ParseWithLength(msg, len);
1461 if (root == NULL) {
1462 TRANS_LOGE(TRANS_CTRL, "parse json failed.");
1463 return SOFTBUS_CREATE_JSON_ERR;
1464 }
1465
1466 if (!GetJsonObjectInt32Item(root, ERR_CODE, errCode)) {
1467 cJSON_Delete(root);
1468 return SOFTBUS_PARSE_JSON_ERR;
1469 }
1470 TRANS_LOGE(TRANS_CTRL, "remote device is faulty, errCode=%{public}d", *errCode);
1471
1472 cJSON_Delete(root);
1473 return SOFTBUS_OK;
1474 }
1475
TransProxyUnPackRestErrMsg(const char * msg,int32_t * errCode,int32_t len)1476 int32_t TransProxyUnPackRestErrMsg(const char *msg, int32_t *errCode, int32_t len)
1477 {
1478 if (errCode == NULL) {
1479 TRANS_LOGE(TRANS_CTRL, "invalid param errCode.");
1480 return SOFTBUS_INVALID_PARAM;
1481 }
1482
1483 cJSON *root = cJSON_ParseWithLength(msg, len);
1484 if (root == NULL) {
1485 TRANS_LOGE(TRANS_CTRL, "parse json failed.");
1486 return SOFTBUS_CREATE_JSON_ERR;
1487 }
1488
1489 if (!GetJsonObjectInt32Item(root, ERR_CODE, errCode) && !GetJsonObjectInt32Item(root, "ERROR_CODE", errCode)) {
1490 TRANS_LOGE(TRANS_CTRL, "get errCode failed.");
1491 cJSON_Delete(root);
1492 return SOFTBUS_PARSE_JSON_ERR;
1493 }
1494
1495 cJSON_Delete(root);
1496 return SOFTBUS_OK;
1497 }
1498
GetSinkSessionKeyFromHandshakeAckMsg(cJSON * root,AppInfo * appInfo)1499 static int32_t GetSinkSessionKeyFromHandshakeAckMsg(cJSON *root, AppInfo *appInfo)
1500 {
1501 (void)GetJsonObjectStringItem(
1502 root, JSON_KEY_SINK_ACL_ACCOUNT_ID, (appInfo->peerData.accountId), ACCOUNT_UID_LEN_MAX);
1503 if (!GetJsonObjectNumberItem(root, JSON_KEY_SINK_ACL_USER_ID, &appInfo->peerData.userId)) {
1504 appInfo->peerData.userId = INVALID_USER_ID;
1505 }
1506 (void)GetJsonObjectNumber64Item(root, JSON_KEY_SINK_ACL_TOKEN_ID, (int64_t *)&appInfo->peerData.tokenId);
1507 return DecryptAndAddSinkSessionKey(root, appInfo);
1508 }
1509
GetNoramlInfoFromHandshakeAckMsg(cJSON * root,ProxyChannelInfo * chanInfo,uint16_t * fastDataSize)1510 static void GetNoramlInfoFromHandshakeAckMsg(cJSON *root, ProxyChannelInfo *chanInfo, uint16_t *fastDataSize)
1511 {
1512 if (!GetJsonObjectNumberItem(root, JSON_KEY_UID, &chanInfo->appInfo.peerData.uid) ||
1513 !GetJsonObjectNumberItem(root, JSON_KEY_PID, &chanInfo->appInfo.peerData.pid) ||
1514 !GetJsonObjectNumberItem(root, JSON_KEY_ENCRYPT, &chanInfo->appInfo.encrypt) ||
1515 !GetJsonObjectNumberItem(root, JSON_KEY_ALGORITHM, &chanInfo->appInfo.algorithm) ||
1516 !GetJsonObjectNumberItem(root, JSON_KEY_CRC, &chanInfo->appInfo.crc) ||
1517 !GetJsonObjectNumber16Item(root, JSON_KEY_FIRST_DATA_SIZE, fastDataSize) ||
1518 !GetJsonObjectStringItem(root, JSON_KEY_SRC_BUS_NAME, chanInfo->appInfo.peerData.sessionName,
1519 sizeof(chanInfo->appInfo.peerData.sessionName)) ||
1520 !GetJsonObjectStringItem(root, JSON_KEY_DST_BUS_NAME, chanInfo->appInfo.myData.sessionName,
1521 sizeof(chanInfo->appInfo.myData.sessionName))) {
1522 TRANS_LOGW(TRANS_CTRL, "unpack handshake ack old version");
1523 }
1524 }
1525
TransProxyUnpackHandshakeAckMsg(const char * msg,ProxyChannelInfo * chanInfo,int32_t len,uint16_t * fastDataSize)1526 int32_t TransProxyUnpackHandshakeAckMsg(const char *msg, ProxyChannelInfo *chanInfo,
1527 int32_t len, uint16_t *fastDataSize)
1528 {
1529 TRANS_CHECK_AND_RETURN_RET_LOGE(msg != NULL && chanInfo != NULL && fastDataSize != NULL,
1530 SOFTBUS_INVALID_PARAM, TRANS_CTRL, "msg or chanInfo or fastDataSize is empty.");
1531
1532 TRANS_CHECK_AND_RETURN_RET_LOGE(&chanInfo->appInfo != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "appInfo is null");
1533
1534 cJSON *root = cJSON_ParseWithLength(msg, len);
1535 TRANS_CHECK_AND_RETURN_RET_LOGE(root != NULL, SOFTBUS_PARSE_JSON_ERR, TRANS_CTRL, "parse json failed.");
1536
1537 if (!GetJsonObjectStringItem(root, JSON_KEY_IDENTITY, chanInfo->identity, sizeof(chanInfo->identity)) ||
1538 !GetJsonObjectStringItem(root, JSON_KEY_DEVICE_ID, chanInfo->appInfo.peerData.deviceId,
1539 sizeof(chanInfo->appInfo.peerData.deviceId))) {
1540 TRANS_LOGE(TRANS_CTRL, "fail to get json item");
1541 cJSON_Delete(root);
1542 return SOFTBUS_PARSE_JSON_ERR;
1543 }
1544 if (!GetJsonObjectNumberItem(root, JSON_KEY_MTU_SIZE, (int32_t *)&(chanInfo->appInfo.peerData.dataConfig))) {
1545 TRANS_LOGD(TRANS_CTRL, "peer dataconfig is null.");
1546 }
1547 chanInfo->appInfo.encrypt = APP_INFO_FILE_FEATURES_SUPPORT;
1548 chanInfo->appInfo.algorithm = APP_INFO_ALGORITHM_AES_GCM_256;
1549 chanInfo->appInfo.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1550
1551 int32_t ret = TransProxyGetAppInfoType(chanInfo->myId, chanInfo->identity, &chanInfo->appInfo.appType);
1552 if (ret != SOFTBUS_OK) {
1553 TRANS_LOGE(TRANS_CTRL, "failed to get app type");
1554 cJSON_Delete(root);
1555 return SOFTBUS_TRANS_PROXY_ERROR_APP_TYPE;
1556 }
1557 if (chanInfo->appInfo.appType == APP_TYPE_NORMAL) {
1558 GetNoramlInfoFromHandshakeAckMsg(root, chanInfo, fastDataSize);
1559 if (!GetJsonObjectInt32Item(root, JSON_KEY_MY_HANDLE_ID, &chanInfo->appInfo.peerHandleId)) {
1560 chanInfo->appInfo.peerHandleId = -1;
1561 }
1562 }
1563
1564 if (!GetJsonObjectStringItem(root, JSON_KEY_PKG_NAME, chanInfo->appInfo.peerData.pkgName,
1565 sizeof(chanInfo->appInfo.peerData.pkgName))) {
1566 TRANS_LOGW(TRANS_CTRL, "no item to get pkg name");
1567 }
1568 if (!GetJsonObjectNumberItem(root, TRANS_CAPABILITY, (int32_t *)&(chanInfo->appInfo.channelCapability))) {
1569 chanInfo->appInfo.channelCapability = 0;
1570 }
1571 if (GetSinkSessionKeyFromHandshakeAckMsg(root, &(chanInfo->appInfo)) != SOFTBUS_OK) {
1572 cJSON_Delete(root);
1573 return SOFTBUS_PARSE_JSON_ERR;
1574 }
1575 cJSON_Delete(root);
1576 return SOFTBUS_OK;
1577 }
1578
UnpackPackHandshakeMsgForFastData(AppInfo * appInfo,cJSON * root)1579 static int32_t UnpackPackHandshakeMsgForFastData(AppInfo *appInfo, cJSON *root)
1580 {
1581 (void)LnnGetNetworkIdByUuid(appInfo->peerData.deviceId, appInfo->peerNetWorkId, NETWORK_ID_BUF_LEN);
1582 int32_t osType = 0;
1583 (void)GetOsTypeByNetworkId(appInfo->peerNetWorkId, &osType);
1584 if (osType == OH_OS_TYPE) {
1585 TRANS_LOGW(TRANS_CTRL, "no need get fastData osType=%{public}d", osType);
1586 return SOFTBUS_OK;
1587 }
1588 if (!GetJsonObjectNumber16Item(root, JSON_KEY_FIRST_DATA_SIZE, &(appInfo->fastTransDataSize))) {
1589 TRANS_LOGW(TRANS_CTRL, "Failed to get handshake msg fast data size");
1590 appInfo->fastTransDataSize = 0;
1591 }
1592 if (appInfo->fastTransDataSize > 0 && appInfo->fastTransDataSize <= MAX_FAST_DATA_LEN) {
1593 if (!GetJsonObjectNumberItem(root, JSON_KEY_ROUTE_TYPE, (int32_t*)&(appInfo->routeType))) {
1594 TRANS_LOGE(TRANS_CTRL, "Failed to get handshake msg route type");
1595 return SOFTBUS_PARSE_JSON_ERR;
1596 }
1597 uint8_t *encodeFastData = (uint8_t *)SoftBusMalloc(BASE64_FAST_DATA_LEN);
1598 if (encodeFastData == NULL) {
1599 TRANS_LOGE(TRANS_CTRL, "malloc encode fast data fail.");
1600 return SOFTBUS_MALLOC_ERR;
1601 }
1602 size_t fastDataSize = 0;
1603 if (!GetJsonObjectStringItem(root, JSON_KEY_FIRST_DATA, (char *)encodeFastData, BASE64_FAST_DATA_LEN)) {
1604 TRANS_LOGE(TRANS_CTRL, "failed to get fast data");
1605 SoftBusFree(encodeFastData);
1606 return SOFTBUS_PARSE_JSON_ERR;
1607 }
1608 appInfo->fastTransData = (uint8_t *)SoftBusCalloc(appInfo->fastTransDataSize + FAST_EXT_BYTE_SIZE);
1609 if (appInfo->fastTransData == NULL) {
1610 TRANS_LOGE(TRANS_CTRL, "malloc fast data fail.");
1611 SoftBusFree(encodeFastData);
1612 return SOFTBUS_MALLOC_ERR;
1613 }
1614
1615 int32_t ret = SoftBusBase64Decode((unsigned char *)appInfo->fastTransData, appInfo->fastTransDataSize +
1616 FAST_EXT_BYTE_SIZE, &fastDataSize, encodeFastData, strlen((char*)encodeFastData));
1617 if (ret != SOFTBUS_OK) {
1618 TRANS_LOGE(TRANS_CTRL, "mbedtls decode failed.");
1619 SoftBusFree((void *)appInfo->fastTransData);
1620 appInfo->fastTransData = NULL;
1621 SoftBusFree(encodeFastData);
1622 return SOFTBUS_DECRYPT_ERR;
1623 }
1624 SoftBusFree(encodeFastData);
1625 }
1626 return SOFTBUS_OK;
1627 }
1628
TransProxyUnpackNormalHandshakeMsg(cJSON * root,AppInfo * appInfo,char * sessionKey,int32_t keyLen)1629 static int32_t TransProxyUnpackNormalHandshakeMsg(cJSON *root, AppInfo *appInfo, char *sessionKey, int32_t keyLen)
1630 {
1631 (void)GetJsonObjectStringItem(root, JSON_KEY_SESSION_KEY, sessionKey, keyLen);
1632 if (!GetJsonObjectNumberItem(root, JSON_KEY_UID, &(appInfo->peerData.uid)) ||
1633 !GetJsonObjectNumberItem(root, JSON_KEY_PID, &(appInfo->peerData.pid)) ||
1634 !GetJsonObjectStringItem(root, JSON_KEY_PKG_NAME, appInfo->peerData.pkgName, PKG_NAME_SIZE_MAX)) {
1635 TRANS_LOGE(TRANS_CTRL, "Failed to get handshake msg APP_TYPE_NORMAL");
1636 return SOFTBUS_PARSE_JSON_ERR;
1637 }
1638 if (!GetJsonObjectNumberItem(root, JSON_KEY_ENCRYPT, &appInfo->encrypt) ||
1639 !GetJsonObjectNumberItem(root, JSON_KEY_ALGORITHM, &appInfo->algorithm) ||
1640 !GetJsonObjectNumberItem(root, JSON_KEY_CRC, &appInfo->crc)) {
1641 TRANS_LOGW(TRANS_CTRL, "unpack handshake old version");
1642 appInfo->encrypt = APP_INFO_FILE_FEATURES_SUPPORT;
1643 appInfo->algorithm = APP_INFO_ALGORITHM_AES_GCM_256;
1644 appInfo->crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1645 }
1646 if (!GetJsonObjectNumberItem(root, JSON_KEY_BUSINESS_TYPE, (int *)&appInfo->businessType)) {
1647 appInfo->businessType = BUSINESS_TYPE_NOT_CARE;
1648 }
1649
1650 GetJsonObjectStringItem(root, JSON_KEY_GROUP_ID, appInfo->groupId, sizeof(appInfo->groupId));
1651 if (!GetJsonObjectInt32Item(root, JSON_KEY_MY_HANDLE_ID, &(appInfo->peerHandleId)) ||
1652 !GetJsonObjectInt32Item(root, JSON_KEY_PEER_HANDLE_ID, &(appInfo->myHandleId))) {
1653 appInfo->myHandleId = -1;
1654 appInfo->peerHandleId = -1;
1655 }
1656 size_t len = 0;
1657 if (strlen(sessionKey) != 0) {
1658 int32_t ret = SoftBusBase64Decode((uint8_t *)appInfo->sessionKey, sizeof(appInfo->sessionKey), &len,
1659 (uint8_t *)sessionKey, strlen(sessionKey));
1660 if (len != sizeof(appInfo->sessionKey) || ret != SOFTBUS_OK) {
1661 TRANS_LOGE(TRANS_CTRL, "decode session fail ret=%{public}d", ret);
1662 return SOFTBUS_DECRYPT_ERR;
1663 }
1664 }
1665 if (UnpackPackHandshakeMsgForFastData(appInfo, root) != SOFTBUS_OK) {
1666 TRANS_LOGE(TRANS_CTRL, "unpack fast data failed");
1667 return SOFTBUS_TRANS_PROXY_UNPACK_FAST_DATA_FAILED;
1668 }
1669 if (!GetJsonObjectNumber64Item(root, JSON_KEY_CALLING_TOKEN_ID, (int64_t *)&appInfo->callingTokenId)) {
1670 appInfo->callingTokenId = TOKENID_NOT_SET;
1671 }
1672 (void)GetJsonObjectStringItem(root, JSON_KEY_ACCOUNT_ID, appInfo->peerData.accountId, ACCOUNT_UID_LEN_MAX);
1673 if (!GetJsonObjectNumberItem(root, JSON_KEY_USER_ID, &(appInfo->peerData.userId))) {
1674 appInfo->peerData.userId = INVALID_USER_ID;
1675 }
1676 (void)GetJsonObjectNumber64Item(root, JSON_KEY_SOURCE_ACL_TOKEN_ID, (int64_t *)&appInfo->peerData.tokenId);
1677 (void)GetJsonObjectStringItem(
1678 root, JSON_KEY_SOURCE_ACL_EXTRA_INFO, (appInfo->extraAccessInfo), EXTRA_ACCESS_INFO_LEN_MAX);
1679 return SOFTBUS_OK;
1680 }
1681
TransProxyUnpackAuthHandshakeMsg(cJSON * root,AppInfo * appInfo)1682 static int32_t TransProxyUnpackAuthHandshakeMsg(cJSON *root, AppInfo *appInfo)
1683 {
1684 if (!GetJsonObjectStringItem(root, JSON_KEY_REQUEST_ID, appInfo->reqId, REQ_ID_SIZE_MAX)) {
1685 TRANS_LOGE(TRANS_CTRL, "Failed to get handshake msg REQUEST_ID");
1686 return SOFTBUS_TRANS_PROXY_HANDSHAKE_GET_REQUEST_FAILED;
1687 }
1688 if (!GetJsonObjectStringItem(root, JSON_KEY_PKG_NAME,
1689 appInfo->peerData.pkgName, sizeof(appInfo->peerData.pkgName))) {
1690 TRANS_LOGE(TRANS_CTRL, "Failed to get handshake msg pkgName");
1691 return SOFTBUS_TRANS_PROXY_HANDSHAKE_GET_PKG_FAILED;
1692 }
1693 return SOFTBUS_OK;
1694 }
1695
TransProxyUnpackInnerHandshakeMsg(cJSON * root,AppInfo * appInfo,char * sessionKey,int32_t keyLen)1696 static int32_t TransProxyUnpackInnerHandshakeMsg(cJSON *root, AppInfo *appInfo, char *sessionKey, int32_t keyLen)
1697 {
1698 if (!GetJsonObjectStringItem(root, JSON_KEY_SESSION_KEY, sessionKey, keyLen)) {
1699 TRANS_LOGE(TRANS_CTRL, "Failed to get handshake msg");
1700 return SOFTBUS_TRANS_PROXY_HANDSHAKE_GET_SESSIONKEY_FAILED;
1701 }
1702 size_t len = 0;
1703 int32_t ret = SoftBusBase64Decode((uint8_t *)appInfo->sessionKey, sizeof(appInfo->sessionKey),
1704 &len, (uint8_t *)sessionKey, strlen(sessionKey));
1705 if (len != sizeof(appInfo->sessionKey) || ret != SOFTBUS_OK) {
1706 TRANS_LOGE(TRANS_CTRL, "decode session fail ret=%{public}d", ret);
1707 return SOFTBUS_DECRYPT_ERR;
1708 }
1709 return SOFTBUS_OK;
1710 }
1711
TransProxyGetJsonObject(cJSON * root,const char * msg,int32_t len,ProxyChannelInfo * chan)1712 static int32_t TransProxyGetJsonObject(cJSON *root, const char *msg, int32_t len, ProxyChannelInfo *chan)
1713 {
1714 if (!GetJsonObjectNumberItem(root, JSON_KEY_TYPE, (int32_t *)&(chan->appInfo.appType)) ||
1715 !GetJsonObjectStringItem(root, JSON_KEY_IDENTITY, chan->identity, sizeof(chan->identity)) ||
1716 !GetJsonObjectStringItem(root, JSON_KEY_DEVICE_ID, chan->appInfo.peerData.deviceId,
1717 sizeof(chan->appInfo.peerData.deviceId)) ||
1718 !GetJsonObjectStringItem(root, JSON_KEY_SRC_BUS_NAME, chan->appInfo.peerData.sessionName,
1719 sizeof(chan->appInfo.peerData.sessionName)) ||
1720 !GetJsonObjectStringItem(root, JSON_KEY_DST_BUS_NAME, chan->appInfo.myData.sessionName,
1721 sizeof(chan->appInfo.myData.sessionName))) {
1722 TRANS_LOGE(TRANS_CTRL, "Failed to get handshake msg");
1723 return SOFTBUS_PARSE_JSON_ERR;
1724 }
1725 if (!GetJsonObjectNumberItem(root, JSON_KEY_MTU_SIZE, (int32_t *)&(chan->appInfo.peerData.dataConfig))) {
1726 TRANS_LOGD(TRANS_CTRL, "peer dataconfig is null.");
1727 }
1728 if (!GetJsonObjectNumberItem(root, API_VERSION, (int32_t *)&(chan->appInfo.myData.apiVersion))) {
1729 TRANS_LOGD(TRANS_CTRL, "peer apiVersion is null.");
1730 }
1731 uint32_t remoteCapability = 0;
1732 (void)GetJsonObjectNumberItem(root, TRANS_CAPABILITY, (int32_t *)&remoteCapability);
1733 chan->appInfo.channelCapability = remoteCapability & TRANS_CHANNEL_CAPABILITY;
1734 return SOFTBUS_OK;
1735 }
1736
TransProxyUnpackHandshakeMsg(const char * msg,ProxyChannelInfo * chan,int32_t len)1737 int32_t TransProxyUnpackHandshakeMsg(const char *msg, ProxyChannelInfo *chan, int32_t len)
1738 {
1739 TRANS_CHECK_AND_RETURN_RET_LOGE(msg != NULL && chan != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "param invalid.");
1740 cJSON *root = cJSON_ParseWithLength(msg, len);
1741 TRANS_CHECK_AND_RETURN_RET_LOGE(root != NULL, SOFTBUS_PARSE_JSON_ERR, TRANS_CTRL, "parse json failed.");
1742 char sessionKey[BASE64KEY] = { 0 };
1743 AppInfo *appInfo = &(chan->appInfo);
1744 int32_t ret = TransProxyGetJsonObject(root, msg, len, chan);
1745 if (ret != SOFTBUS_OK) {
1746 goto ERR_EXIT;
1747 }
1748 if (appInfo->appType == APP_TYPE_NORMAL) {
1749 ret = TransProxyUnpackNormalHandshakeMsg(root, appInfo, sessionKey, BASE64KEY);
1750 if (ret != SOFTBUS_OK) {
1751 goto ERR_EXIT;
1752 }
1753 } else if (appInfo->appType == APP_TYPE_AUTH) {
1754 ret = TransProxyUnpackAuthHandshakeMsg(root, appInfo);
1755 if (ret != SOFTBUS_OK) {
1756 goto ERR_EXIT;
1757 }
1758 } else {
1759 ret = TransProxyUnpackInnerHandshakeMsg(root, appInfo, sessionKey, BASE64KEY);
1760 if (ret != SOFTBUS_OK) {
1761 goto ERR_EXIT;
1762 }
1763 }
1764 GetJsonObjectNumberItem(root, JSON_KEY_TRANS_FLAGS, &appInfo->transFlag);
1765 if (((uint32_t)appInfo->transFlag & TRANS_FLAG_HAS_CHANNEL_AUTH) != 0) {
1766 GetJsonObjectNumber64Item(root, JSON_KEY_AUTH_SEQ, &appInfo->authSeq);
1767 }
1768 cJSON_Delete(root);
1769 (void)memset_s(sessionKey, sizeof(sessionKey), 0, sizeof(sessionKey));
1770 return SOFTBUS_OK;
1771 ERR_EXIT:
1772 cJSON_Delete(root);
1773 (void)memset_s(sessionKey, sizeof(sessionKey), 0, sizeof(sessionKey));
1774 return ret;
1775 }
1776
TransProxyPagingPackChannelId(int16_t channelId)1777 char *TransProxyPagingPackChannelId(int16_t channelId)
1778 {
1779 if (channelId <= 0) {
1780 TRANS_LOGE(TRANS_CTRL, "channel id is invalid");
1781 return NULL;
1782 }
1783 cJSON *root = NULL;
1784 char *buf = NULL;
1785
1786 root = cJSON_CreateObject();
1787 if (root == NULL) {
1788 TRANS_LOGE(TRANS_CTRL, "create json object failed.");
1789 return NULL;
1790 }
1791
1792 if (!AddNumberToJsonObject(root, JSON_KEY_PAGING_SINK_CHANNEL_ID, channelId)) {
1793 TRANS_LOGE(TRANS_CTRL, "add identity to json object failed.");
1794 cJSON_Delete(root);
1795 return NULL;
1796 }
1797
1798 buf = cJSON_PrintUnformatted(root);
1799 cJSON_Delete(root);
1800 return buf;
1801 }
1802
TransProxyPackIdentity(const char * identity)1803 char *TransProxyPackIdentity(const char *identity)
1804 {
1805 cJSON *root = NULL;
1806 char *buf = NULL;
1807
1808 if (identity == NULL) {
1809 TRANS_LOGE(TRANS_CTRL, "invalid param.");
1810 return NULL;
1811 }
1812
1813 root = cJSON_CreateObject();
1814 if (root == NULL) {
1815 TRANS_LOGE(TRANS_CTRL, "create json object failed.");
1816 return NULL;
1817 }
1818
1819 if (!AddStringToJsonObject(root, JSON_KEY_IDENTITY, identity)) {
1820 TRANS_LOGE(TRANS_CTRL, "add identity to json object failed.");
1821 cJSON_Delete(root);
1822 return NULL;
1823 }
1824
1825 buf = cJSON_PrintUnformatted(root);
1826 cJSON_Delete(root);
1827 return buf;
1828 }
1829
TransProxyUnpackIdentity(const char * msg,char * identity,uint32_t identitySize,int32_t len)1830 int32_t TransProxyUnpackIdentity(const char *msg, char *identity, uint32_t identitySize, int32_t len)
1831 {
1832 cJSON *root = NULL;
1833
1834 root = cJSON_ParseWithLength(msg, len);
1835 if (root == NULL) {
1836 TRANS_LOGE(TRANS_CTRL, "parse json failed.");
1837 return SOFTBUS_PARSE_JSON_ERR;
1838 }
1839
1840 if (!GetJsonObjectStringItem(root, JSON_KEY_IDENTITY, identity, identitySize)) {
1841 TRANS_LOGE(TRANS_CTRL, "fail to get json item");
1842 cJSON_Delete(root);
1843 return SOFTBUS_PARSE_JSON_ERR;
1844 }
1845
1846 cJSON_Delete(root);
1847 return SOFTBUS_OK;
1848 }
1849
TransProxyEncryptFastData(const char * sessionKey,int32_t seq,const char * in,uint32_t inLen,char * out,uint32_t * outLen)1850 static int32_t TransProxyEncryptFastData(const char *sessionKey, int32_t seq, const char *in, uint32_t inLen,
1851 char *out, uint32_t *outLen)
1852 {
1853 AesGcmCipherKey cipherKey = { 0 };
1854 cipherKey.keyLen = SESSION_KEY_LENGTH;
1855 if (memcpy_s(cipherKey.key, SESSION_KEY_LENGTH, sessionKey, SESSION_KEY_LENGTH) != EOK) {
1856 TRANS_LOGE(TRANS_CTRL, "memcpy key error.");
1857 return SOFTBUS_MEM_ERR;
1858 }
1859
1860 int ret = SoftBusEncryptDataWithSeq(&cipherKey, (unsigned char*)in, inLen,
1861 (unsigned char*)out, outLen, seq);
1862 (void)memset_s(cipherKey.key, SESSION_KEY_LENGTH, 0, SESSION_KEY_LENGTH);
1863
1864 if (ret != SOFTBUS_OK || *outLen != inLen + OVERHEAD_LEN) {
1865 TRANS_LOGE(TRANS_CTRL, "encrypt error, ret=%{public}d.", ret);
1866 return SOFTBUS_ENCRYPT_ERR;
1867 }
1868 return SOFTBUS_OK;
1869 }
1870
FastDataPackPacketHead(PacketFastHead * data)1871 static void FastDataPackPacketHead(PacketFastHead *data)
1872 {
1873 data->magicNumber = (int32_t)SoftBusHtoLl((uint32_t)data->magicNumber);
1874 data->seq = (int32_t)SoftBusHtoLl((uint32_t)data->seq);
1875 data->flags = (int32_t)SoftBusHtoLl((uint32_t)data->flags);
1876 data->dataLen = (int32_t)SoftBusHtoLl((uint32_t)data->dataLen);
1877 }
1878
TransProxyPackFastDataHead(ProxyDataInfo * dataInfo,const AppInfo * appInfo)1879 static int32_t TransProxyPackFastDataHead(ProxyDataInfo *dataInfo, const AppInfo *appInfo)
1880 {
1881 #define MAGIC_NUMBER 0xBABEFACE
1882 if (dataInfo == NULL || appInfo ==NULL) {
1883 TRANS_LOGE(TRANS_CTRL, "invaild param.");
1884 return SOFTBUS_INVALID_PARAM;
1885 }
1886 dataInfo->outLen = dataInfo->inLen + OVERHEAD_LEN + sizeof(PacketFastHead);
1887 uint32_t cipherLength = dataInfo->inLen + OVERHEAD_LEN;
1888 dataInfo->outData = (uint8_t *)SoftBusCalloc(dataInfo->outLen);
1889 if (dataInfo->outData == NULL) {
1890 TRANS_LOGE(TRANS_CTRL, "calloc error");
1891 return SOFTBUS_MALLOC_ERR;
1892 }
1893
1894 int32_t seq = atomic_fetch_add_explicit(&g_proxyPktHeadSeq, 1, memory_order_relaxed);
1895 if (TransProxyEncryptFastData(appInfo->sessionKey, seq, (const char*)dataInfo->inData,
1896 dataInfo->inLen, (char*)dataInfo->outData + sizeof(PacketFastHead), &cipherLength) != SOFTBUS_OK) {
1897 SoftBusFree(dataInfo->outData);
1898 TRANS_LOGE(TRANS_CTRL, "TransProxyEncryptFastData err");
1899 return SOFTBUS_TRANS_PROXY_SESS_ENCRYPT_ERR;
1900 }
1901
1902 PacketFastHead *pktHead = (PacketFastHead*)dataInfo->outData;
1903 pktHead->magicNumber = MAGIC_NUMBER;
1904 pktHead->seq = seq;
1905 pktHead->flags = (appInfo->businessType == BUSINESS_TYPE_BYTE) ? FLAG_BYTES : FLAG_MESSAGE;
1906 pktHead->dataLen = (int32_t)cipherLength;
1907 FastDataPackPacketHead(pktHead);
1908
1909 return SOFTBUS_OK;
1910 }
1911
FastDataPackSliceHead(SliceFastHead * data)1912 static void FastDataPackSliceHead(SliceFastHead *data)
1913 {
1914 data->priority = (int32_t)SoftBusHtoLl((uint32_t)data->priority);
1915 data->sliceNum = (int32_t)SoftBusHtoLl((uint32_t)data->sliceNum);
1916 data->sliceSeq = (int32_t)SoftBusHtoLl((uint32_t)data->sliceSeq);
1917 data->reserved = (int32_t)SoftBusHtoLl((uint32_t)data->reserved);
1918 }
TransProxyMessageData(const AppInfo * appInfo,ProxyDataInfo * dataInfo)1919 static int32_t TransProxyMessageData(const AppInfo *appInfo, ProxyDataInfo *dataInfo)
1920 {
1921 dataInfo->inData = (uint8_t *)SoftBusMalloc(appInfo->fastTransDataSize);
1922 if (dataInfo->inData == NULL) {
1923 TRANS_LOGE(TRANS_CTRL, "malloc error");
1924 return SOFTBUS_MALLOC_ERR;
1925 }
1926 uint16_t fastDataSize = appInfo->fastTransDataSize;
1927 if (memcpy_s(dataInfo->inData, fastDataSize, appInfo->fastTransData, fastDataSize) != EOK) {
1928 TRANS_LOGE(TRANS_CTRL, "memcpy_s fastTransData error.");
1929 SoftBusFree(dataInfo->inData);
1930 return SOFTBUS_MEM_ERR;
1931 }
1932 dataInfo->inLen = fastDataSize;
1933 return SOFTBUS_OK;
1934 }
1935
TransProxyByteData(const AppInfo * appInfo,ProxyDataInfo * dataInfo)1936 static int32_t TransProxyByteData(const AppInfo *appInfo, ProxyDataInfo *dataInfo)
1937 {
1938 dataInfo->inData = (uint8_t *)SoftBusMalloc(appInfo->fastTransDataSize + sizeof(SessionHead));
1939 if (dataInfo->inData == NULL) {
1940 TRANS_LOGE(TRANS_CTRL, "malloc error");
1941 return SOFTBUS_MALLOC_ERR;
1942 }
1943 uint16_t fastDataSize = appInfo->fastTransDataSize;
1944 SessionHead *sessionHead = (SessionHead*)dataInfo->inData;
1945 sessionHead->seq = atomic_fetch_add_explicit(&g_proxyPktHeadSeq, 1, memory_order_relaxed);
1946 sessionHead->packetFlag = (appInfo->businessType == BUSINESS_TYPE_BYTE) ? FLAG_BYTES : FLAG_MESSAGE;
1947 sessionHead->shouldAck = 0;
1948 if (memcpy_s(dataInfo->inData + sizeof(SessionHead), fastDataSize, appInfo->fastTransData, fastDataSize) != EOK) {
1949 TRANS_LOGE(TRANS_CTRL, "memcpy_s fastTransData error.");
1950 SoftBusFree(dataInfo->inData);
1951 return SOFTBUS_MEM_ERR;
1952 }
1953 dataInfo->inLen = fastDataSize + sizeof(SessionHead);
1954 return SOFTBUS_OK;
1955 }
1956
TransProxyPackFastData(const AppInfo * appInfo,uint32_t * outLen)1957 char *TransProxyPackFastData(const AppInfo *appInfo, uint32_t *outLen)
1958 {
1959 ProxyDataInfo dataInfo = {0};
1960 if (appInfo->businessType == BUSINESS_TYPE_MESSAGE && appInfo->routeType == WIFI_STA) {
1961 if (TransProxyMessageData(appInfo, &dataInfo) != SOFTBUS_OK) {
1962 TRANS_LOGE(TRANS_CTRL, "TransProxyMessageData error");
1963 return NULL;
1964 }
1965 } else {
1966 if (TransProxyByteData(appInfo, &dataInfo) != SOFTBUS_OK) {
1967 TRANS_LOGE(TRANS_CTRL, "TransProxyByteData error");
1968 return NULL;
1969 }
1970 }
1971 if (TransProxyPackFastDataHead(&dataInfo, appInfo) != SOFTBUS_OK) {
1972 TRANS_LOGE(TRANS_CTRL, "TransProxyPackFastDataHead error");
1973 SoftBusFree(dataInfo.inData);
1974 return NULL;
1975 }
1976
1977 char *sliceData = (char *)SoftBusMalloc(dataInfo.outLen + sizeof(SliceFastHead));
1978 if (sliceData == NULL) {
1979 TRANS_LOGE(TRANS_CTRL, "malloc slice data error");
1980 SoftBusFree(dataInfo.inData);
1981 SoftBusFree(dataInfo.outData);
1982 return NULL;
1983 }
1984 SliceFastHead *slicehead = (SliceFastHead*)sliceData;
1985 slicehead->priority = (appInfo->businessType == BUSINESS_TYPE_BYTE) ? FLAG_BYTES : FLAG_MESSAGE;
1986 slicehead->sliceNum = 1;
1987 slicehead->sliceSeq = 0;
1988 FastDataPackSliceHead(slicehead);
1989 if (memcpy_s(sliceData + sizeof(SliceFastHead), dataInfo.outLen, dataInfo.outData, dataInfo.outLen) != EOK) {
1990 TRANS_LOGE(TRANS_CTRL, "memcpy_s error");
1991 SoftBusFree(dataInfo.inData);
1992 SoftBusFree(dataInfo.outData);
1993 SoftBusFree(sliceData);
1994 return NULL;
1995 }
1996 *outLen = dataInfo.outLen + sizeof(SliceFastHead);
1997 SoftBusFree(dataInfo.inData);
1998 SoftBusFree(dataInfo.outData);
1999 return sliceData;
2000 }
2001
TransProxyParseD2DData(const char * data,int32_t len)2002 int32_t TransProxyParseD2DData(const char *data, int32_t len)
2003 {
2004 if (data == NULL || len <= PROXY_CHANNEL_D2D_HEAD_LEN) {
2005 TRANS_LOGE(TRANS_CTRL, "invalid param");
2006 return SOFTBUS_INVALID_PARAM;
2007 }
2008 char *ptr = (char *)data;
2009 ptr +=sizeof(uint16_t);
2010 int16_t peerId = (int16_t)SoftBusBEtoLEs(*(uint16_t *)ptr);
2011 ptr +=sizeof(uint16_t);
2012 int16_t myId = (int16_t)SoftBusBEtoLEs(*(uint16_t *)ptr);
2013 ptr +=sizeof(uint16_t);
2014 ProxyChannelInfo info = { 0 };
2015 if (TransProxyGetSendMsgChanInfo(myId, &info) != SOFTBUS_OK) {
2016 TRANS_LOGE(TRANS_CTRL, "data recv get info fail, myId=%{public}d, peerId=%{public}d", myId, peerId);
2017 return SOFTBUS_TRANS_NODE_NOT_FOUND;
2018 }
2019 return OnProxyChannelMsgReceived(myId, &(info.appInfo), data + PROXY_CHANNEL_D2D_HEAD_LEN,
2020 len - PROXY_CHANNEL_D2D_HEAD_LEN);
2021 }