1 /*
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "softbus_message_open_channel.h"
17
18 #include <securec.h>
19 #include <stdatomic.h>
20
21 #include "softbus_access_token_adapter.h"
22 #include "softbus_adapter_crypto.h"
23 #include "softbus_adapter_mem.h"
24 #include "softbus_adapter_socket.h"
25 #include "softbus_error_code.h"
26 #include "softbus_json_utils.h"
27 #include "softbus_utils.h"
28 #include "trans_log.h"
29
30 #define BASE64KEY 45 // Base64 encrypt SessionKey length
31 #define INVALID_USER_ID (-1)
32
PackError(int32_t errCode,const char * errDesc)33 char *PackError(int32_t errCode, const char *errDesc)
34 {
35 if (errDesc == NULL) {
36 TRANS_LOGW(TRANS_CTRL, "invalid param");
37 return NULL;
38 }
39 cJSON *json = cJSON_CreateObject();
40 if (json == NULL) {
41 TRANS_LOGE(TRANS_CTRL, "Cannot create cJSON object");
42 return NULL;
43 }
44 if (!AddNumberToJsonObject(json, CODE, CODE_OPEN_CHANNEL) ||
45 !AddNumberToJsonObject(json, ERR_CODE, errCode) ||
46 !AddStringToJsonObject(json, ERR_DESC, errDesc)) {
47 cJSON_Delete(json);
48 TRANS_LOGE(TRANS_CTRL, "add to cJSON object failed");
49 return NULL;
50 }
51 char *data = cJSON_PrintUnformatted(json);
52 if (data == NULL) {
53 TRANS_LOGE(TRANS_CTRL, "cJSON_PrintUnformatted failed");
54 }
55 cJSON_Delete(json);
56 return data;
57 }
58
PackFirstData(const AppInfo * appInfo,cJSON * json)59 static int32_t PackFirstData(const AppInfo *appInfo, cJSON *json)
60 {
61 TRANS_LOGD(TRANS_CTRL, "begin to pack first data");
62 uint8_t *encodeFastData = (uint8_t *)SoftBusCalloc(BASE64_FAST_DATA_LEN);
63 if (encodeFastData == NULL) {
64 TRANS_LOGE(TRANS_CTRL, "malloc encode fast data failed.");
65 return SOFTBUS_MALLOC_ERR;
66 }
67
68 uint32_t outLen;
69 char *buf = TransTdcPackFastData(appInfo, &outLen);
70 if (buf == NULL) {
71 TRANS_LOGE(TRANS_CTRL, "failed to pack bytes.");
72 SoftBusFree(encodeFastData);
73 return SOFTBUS_ENCRYPT_ERR;
74 }
75 if (outLen != appInfo->fastTransDataSize + FAST_TDC_EXT_DATA_SIZE) {
76 TRANS_LOGE(TRANS_CTRL, "pack bytes len error, outlen=%{public}d", outLen);
77 SoftBusFree(buf);
78 SoftBusFree(encodeFastData);
79 return SOFTBUS_ENCRYPT_ERR;
80 }
81 size_t fastDataSize = 0;
82 int32_t ret = SoftBusBase64Encode(encodeFastData, BASE64_FAST_DATA_LEN, &fastDataSize,
83 (const unsigned char *)buf, outLen);
84 if (ret != SOFTBUS_OK) {
85 TRANS_LOGE(TRANS_CTRL, "base64 encode failed.");
86 SoftBusFree(encodeFastData);
87 SoftBusFree(buf);
88 return SOFTBUS_DECRYPT_ERR;
89 }
90 if (!AddStringToJsonObject(json, FIRST_DATA, (char *)encodeFastData)) {
91 TRANS_LOGE(TRANS_CTRL, "add first data failed.");
92 SoftBusFree(encodeFastData);
93 SoftBusFree(buf);
94 return SOFTBUS_PARSE_JSON_ERR;
95 }
96 SoftBusFree(encodeFastData);
97 SoftBusFree(buf);
98 return SOFTBUS_OK;
99 }
100
JsonObjectPackRequestEx(const AppInfo * appInfo,cJSON * json,unsigned char * encodeSessionKey)101 static int32_t JsonObjectPackRequestEx(const AppInfo *appInfo, cJSON *json, unsigned char *encodeSessionKey)
102 {
103 if (!AddNumberToJsonObject(json, CODE, CODE_OPEN_CHANNEL) ||
104 !AddNumberToJsonObject(json, API_VERSION, appInfo->myData.apiVersion) ||
105 !AddStringToJsonObject(json, BUS_NAME, appInfo->peerData.sessionName) ||
106 !AddStringToJsonObject(json, GROUP_ID, appInfo->groupId) ||
107 !AddNumberToJsonObject(json, UID, appInfo->myData.uid) ||
108 !AddNumberToJsonObject(json, PID, appInfo->myData.pid) ||
109 !AddStringToJsonObject(json, SESSION_KEY, (char *)encodeSessionKey) ||
110 !AddNumberToJsonObject(json, MTU_SIZE, (int32_t)appInfo->myData.dataConfig)) {
111 return SOFTBUS_PARSE_JSON_ERR;
112 }
113
114 if (!AddNumberToJsonObject(json, TRANS_CAPABILITY, (int32_t)appInfo->channelCapability)) {
115 return SOFTBUS_PARSE_JSON_ERR;
116 }
117
118 char *authState = (char *)appInfo->myData.authState;
119 if (appInfo->myData.apiVersion != API_V1 && (!AddStringToJsonObject(json, PKG_NAME, appInfo->myData.pkgName) ||
120 !AddStringToJsonObject(json, CLIENT_BUS_NAME, appInfo->myData.sessionName) ||
121 !AddStringToJsonObject(json, AUTH_STATE, authState) ||
122 !AddNumberToJsonObject(json, MSG_ROUTE_TYPE, appInfo->routeType))) {
123 return SOFTBUS_PARSE_JSON_ERR;
124 }
125 (void)AddNumberToJsonObject(json, BUSINESS_TYPE, appInfo->businessType);
126 (void)AddNumberToJsonObject(json, AUTO_CLOSE_TIME, appInfo->autoCloseTime);
127 (void)AddNumberToJsonObject(json, TRANS_FLAGS, TRANS_FLAG_HAS_CHANNEL_AUTH);
128 (void)AddNumberToJsonObject(json, MY_HANDLE_ID, appInfo->myHandleId);
129 (void)AddNumberToJsonObject(json, PEER_HANDLE_ID, appInfo->peerHandleId);
130 (void)AddNumber64ToJsonObject(json, JSON_KEY_CALLING_TOKEN_ID, (int64_t)appInfo->callingTokenId);
131 if (SoftBusCheckIsCollabApp(appInfo->callingTokenId, appInfo->myData.sessionName)) {
132 (void)AddStringToJsonObject(json, ACCOUNT_ID, appInfo->myData.accountId);
133 (void)AddNumberToJsonObject(json, USER_ID, appInfo->myData.userId);
134 }
135 return SOFTBUS_OK;
136 }
137
PackRequest(const AppInfo * appInfo)138 char *PackRequest(const AppInfo *appInfo)
139 {
140 if (appInfo == NULL) {
141 TRANS_LOGW(TRANS_CTRL, "invalid param.");
142 return NULL;
143 }
144
145 cJSON *json = cJSON_CreateObject();
146 if (json == NULL) {
147 TRANS_LOGE(TRANS_CTRL, "Cannot create cJSON object");
148 return NULL;
149 }
150 if (!AddNumber16ToJsonObject(json, FIRST_DATA_SIZE, appInfo->fastTransDataSize)) {
151 cJSON_Delete(json);
152 return NULL;
153 }
154 if (appInfo->fastTransDataSize > 0 && PackFirstData(appInfo, json) != SOFTBUS_OK) {
155 TRANS_LOGE(TRANS_CTRL, "pack first data failed");
156 cJSON_Delete(json);
157 return NULL;
158 }
159
160 unsigned char encodeSessionKey[BASE64KEY] = {0};
161 size_t keyLen = 0;
162 int32_t ret = SoftBusBase64Encode(encodeSessionKey, BASE64KEY,
163 &keyLen, (unsigned char *)appInfo->sessionKey, SESSION_KEY_LENGTH);
164 if (ret != SOFTBUS_OK) {
165 cJSON_Delete(json);
166 return NULL;
167 }
168 ret = JsonObjectPackRequestEx(appInfo, json, encodeSessionKey);
169 (void)memset_s(encodeSessionKey, sizeof(encodeSessionKey), 0, sizeof(encodeSessionKey));
170 if (ret != SOFTBUS_OK) {
171 cJSON_Delete(json);
172 return NULL;
173 }
174 char *data = cJSON_PrintUnformatted(json);
175 if (data == NULL) {
176 TRANS_LOGW(TRANS_CTRL, "cJSON_PrintUnformatted failed");
177 }
178 cJSON_Delete(json);
179 return data;
180 }
181
UnpackFirstData(AppInfo * appInfo,const cJSON * json)182 static int32_t UnpackFirstData(AppInfo *appInfo, const cJSON *json)
183 {
184 if (!GetJsonObjectNumber16Item(json, FIRST_DATA_SIZE, &(appInfo->fastTransDataSize))) {
185 appInfo->fastTransDataSize = 0;
186 }
187 TRANS_LOGD(TRANS_CTRL, "fastDataSize=%{public}d", appInfo->fastTransDataSize);
188 if (appInfo->fastTransDataSize > 0 && appInfo->fastTransDataSize <= MAX_FAST_DATA_LEN) {
189 uint8_t *encodeFastData = (uint8_t *)SoftBusCalloc(BASE64_FAST_DATA_LEN);
190 if (encodeFastData == NULL) {
191 TRANS_LOGE(TRANS_CTRL, "malloc encode fast data failed.");
192 return SOFTBUS_MALLOC_ERR;
193 }
194 size_t fastDataSize = 0;
195 if (!GetJsonObjectStringItem(json, FIRST_DATA, (char *)encodeFastData, BASE64_FAST_DATA_LEN)) {
196 TRANS_LOGE(TRANS_CTRL, "Failed to get fast data");
197 SoftBusFree(encodeFastData);
198 return SOFTBUS_PARSE_JSON_ERR;
199 }
200 appInfo->fastTransData = (uint8_t *)SoftBusCalloc(appInfo->fastTransDataSize + FAST_TDC_EXT_DATA_SIZE);
201 if (appInfo->fastTransData == NULL) {
202 TRANS_LOGE(TRANS_CTRL, "malloc fast data failed.");
203 SoftBusFree(encodeFastData);
204 return SOFTBUS_MALLOC_ERR;
205 }
206 int32_t ret = SoftBusBase64Decode((unsigned char *)appInfo->fastTransData, appInfo->fastTransDataSize +
207 FAST_TDC_EXT_DATA_SIZE, &fastDataSize, encodeFastData, strlen((char *)encodeFastData));
208 if (ret != SOFTBUS_OK) {
209 TRANS_LOGE(TRANS_CTRL, "mbedtls decode failed.");
210 SoftBusFree((void *)appInfo->fastTransData);
211 appInfo->fastTransData = NULL;
212 SoftBusFree(encodeFastData);
213 return SOFTBUS_DECRYPT_ERR;
214 }
215 SoftBusFree(encodeFastData);
216 }
217 return SOFTBUS_OK;
218 }
219
ParseMessageToAppInfo(const cJSON * msg,AppInfo * appInfo)220 static int32_t ParseMessageToAppInfo(const cJSON *msg, AppInfo *appInfo)
221 {
222 char sessionKey[BASE64KEY] = {0};
223 if (!GetJsonObjectStringItem(msg, BUS_NAME, (appInfo->myData.sessionName), SESSION_NAME_SIZE_MAX) ||
224 !GetJsonObjectStringItem(msg, GROUP_ID, (appInfo->groupId), GROUP_ID_SIZE_MAX) ||
225 !GetJsonObjectStringItem(msg, SESSION_KEY, sessionKey, sizeof(sessionKey))) {
226 TRANS_LOGE(TRANS_CTRL, "Failed to get BUS_NAME");
227 return SOFTBUS_PARSE_JSON_ERR;
228 }
229 if (!GetJsonObjectNumberItem(msg, MTU_SIZE, (int32_t *)&(appInfo->peerData.dataConfig))) {
230 TRANS_LOGW(TRANS_CTRL, "peer dataconfig is null.");
231 }
232 appInfo->peerData.uid = -1;
233 appInfo->peerData.pid = -1;
234 (void)GetJsonObjectNumberItem(msg, UID, &appInfo->peerData.uid);
235 (void)GetJsonObjectNumberItem(msg, PID, &appInfo->peerData.pid);
236 (void)GetJsonObjectStringItem(msg, ACCOUNT_ID, (appInfo->peerData.accountId), ACCOUNT_UID_LEN_MAX);
237 if (!GetJsonObjectNumberItem(msg, USER_ID, &appInfo->peerData.userId)) {
238 appInfo->peerData.userId = INVALID_USER_ID;
239 }
240 appInfo->myHandleId = -1;
241 appInfo->peerHandleId = -1;
242 if (!GetJsonObjectInt32Item(msg, MY_HANDLE_ID, &(appInfo->peerHandleId)) ||
243 !GetJsonObjectInt32Item(msg, PEER_HANDLE_ID, &(appInfo->myHandleId))) {
244 appInfo->myHandleId = -1;
245 appInfo->peerHandleId = -1;
246 }
247
248 size_t len = 0;
249 int32_t ret = SoftBusBase64Decode((unsigned char *)appInfo->sessionKey, SESSION_KEY_LENGTH,
250 &len, (unsigned char *)sessionKey, strlen(sessionKey));
251 (void)memset_s(sessionKey, sizeof(sessionKey), 0, sizeof(sessionKey));
252 if (len != SESSION_KEY_LENGTH) {
253 TRANS_LOGE(TRANS_CTRL, "Failed to decode sessionKey ret=%{public}d, len=%{public}zu", ret, len);
254 return SOFTBUS_PARSE_JSON_ERR;
255 }
256 return SOFTBUS_OK;
257 }
258
UnpackRequest(const cJSON * msg,AppInfo * appInfo)259 int32_t UnpackRequest(const cJSON *msg, AppInfo *appInfo)
260 {
261 if (msg == NULL || appInfo == NULL) {
262 TRANS_LOGW(TRANS_CTRL, "invalid param");
263 return SOFTBUS_INVALID_PARAM;
264 }
265 int32_t ret = UnpackFirstData(appInfo, msg);
266 if (ret != SOFTBUS_OK) {
267 TRANS_LOGE(TRANS_CTRL, "unpack first data failed");
268 return ret;
269 }
270
271 int32_t apiVersion = API_V1;
272 (void)GetJsonObjectNumberItem(msg, API_VERSION, &apiVersion);
273 appInfo->peerData.apiVersion = (ApiVersion)apiVersion;
274 if (ParseMessageToAppInfo(msg, appInfo) != SOFTBUS_OK) {
275 TRANS_LOGE(TRANS_CTRL, "fill appInfo failed.");
276 SoftBusFree((void *)appInfo->fastTransData);
277 return SOFTBUS_PARSE_JSON_ERR;
278 }
279 if (apiVersion == API_V1) {
280 return SOFTBUS_OK;
281 }
282
283 if (!GetJsonObjectStringItem(msg, PKG_NAME, (appInfo->peerData.pkgName), PKG_NAME_SIZE_MAX) ||
284 !GetJsonObjectStringItem(msg, CLIENT_BUS_NAME, (appInfo->peerData.sessionName), SESSION_NAME_SIZE_MAX) ||
285 !GetJsonObjectStringItem(msg, AUTH_STATE, (appInfo->peerData.authState), AUTH_STATE_SIZE_MAX)) {
286 TRANS_LOGE(TRANS_CTRL, "Failed to get pkgName");
287 SoftBusFree((void *)appInfo->fastTransData);
288 return SOFTBUS_PARSE_JSON_ERR;
289 }
290 int32_t routeType = WIFI_STA;
291 if (GetJsonObjectNumberItem(msg, MSG_ROUTE_TYPE, &routeType) != SOFTBUS_OK) {
292 TRANS_LOGW(TRANS_CTRL, "Failed to get route type");
293 }
294 appInfo->routeType = (RouteType)routeType;
295
296 if (!GetJsonObjectNumberItem(msg, BUSINESS_TYPE, (int32_t *)&appInfo->businessType)) {
297 appInfo->businessType = BUSINESS_TYPE_NOT_CARE;
298 }
299 int32_t transFlag = TRANS_FLAG_HAS_CHANNEL_AUTH;
300 (void)GetJsonObjectNumberItem(msg, AUTO_CLOSE_TIME, (int32_t *)&appInfo->autoCloseTime);
301 (void)GetJsonObjectNumberItem(msg, TRANS_FLAGS, &transFlag);
302 if (!GetJsonObjectNumber64Item(msg, JSON_KEY_CALLING_TOKEN_ID, (int64_t *)&appInfo->callingTokenId)) {
303 appInfo->callingTokenId = TOKENID_NOT_SET;
304 }
305 uint32_t remoteCapability = 0;
306 (void)GetJsonObjectNumberItem(msg, TRANS_CAPABILITY, (int32_t *)&remoteCapability);
307 appInfo->channelCapability = remoteCapability & TRANS_CHANNEL_CAPABILITY;
308 return SOFTBUS_OK;
309 }
310
AddItemsToJsonObject(const AppInfo * appInfo,cJSON * json)311 static int32_t AddItemsToJsonObject(const AppInfo *appInfo, cJSON *json)
312 {
313 TRANS_CHECK_AND_RETURN_RET_LOGE(AddNumberToJsonObject(json, CODE, CODE_OPEN_CHANNEL),
314 SOFTBUS_CREATE_JSON_ERR, TRANS_CTRL, "Failed to add channels");
315 TRANS_CHECK_AND_RETURN_RET_LOGE(AddNumberToJsonObject(json, API_VERSION, appInfo->myData.apiVersion),
316 SOFTBUS_CREATE_JSON_ERR, TRANS_CTRL, "Failed to add apiVersion");
317 TRANS_CHECK_AND_RETURN_RET_LOGE(AddStringToJsonObject(json, DEVICE_ID, appInfo->myData.deviceId),
318 SOFTBUS_CREATE_JSON_ERR, TRANS_CTRL, "Failed to add deviceId");
319 TRANS_CHECK_AND_RETURN_RET_LOGE(AddNumberToJsonObject(json, UID, appInfo->myData.uid),
320 SOFTBUS_CREATE_JSON_ERR, TRANS_CTRL, "Failed to add uid");
321 TRANS_CHECK_AND_RETURN_RET_LOGE(AddNumberToJsonObject(json, PID, appInfo->myData.pid),
322 SOFTBUS_CREATE_JSON_ERR, TRANS_CTRL, "Failed to add pid");
323 TRANS_CHECK_AND_RETURN_RET_LOGE(AddNumberToJsonObject(json, TRANS_CAPABILITY, appInfo->channelCapability),
324 SOFTBUS_CREATE_JSON_ERR, TRANS_CTRL, "Failed to add channelCapability");
325 return SOFTBUS_OK;
326 }
327
PackReply(const AppInfo * appInfo)328 char *PackReply(const AppInfo *appInfo)
329 {
330 if (appInfo == NULL) {
331 TRANS_LOGE(TRANS_CTRL, "invalid param");
332 return NULL;
333 }
334 cJSON *json = cJSON_CreateObject();
335 if (json == NULL) {
336 return NULL;
337 }
338 char *data = NULL;
339 if (AddItemsToJsonObject(appInfo, json) != SOFTBUS_OK) {
340 goto EXIT_FAIL;
341 }
342 if (appInfo->peerData.dataConfig != 0) {
343 if (!AddNumberToJsonObject(json, MTU_SIZE, appInfo->myData.dataConfig)) {
344 goto EXIT_FAIL;
345 }
346 }
347 if (!AddNumber16ToJsonObject(json, FIRST_DATA_SIZE, appInfo->fastTransDataSize)) {
348 TRANS_LOGE(TRANS_CTRL, "Failed to add trans data size");
349 goto EXIT_FAIL;
350 }
351 if (appInfo->myData.apiVersion != API_V1) {
352 char *authState = (char *)appInfo->myData.authState;
353 if (!AddStringToJsonObject(json, PKG_NAME, appInfo->myData.pkgName) ||
354 !AddStringToJsonObject(json, AUTH_STATE, authState)) {
355 TRANS_LOGE(TRANS_CTRL, "Failed to add pkgName or authState");
356 goto EXIT_FAIL;
357 }
358 }
359 if (!AddNumberToJsonObject(json, MY_HANDLE_ID, appInfo->myHandleId) ||
360 !AddNumberToJsonObject(json, PEER_HANDLE_ID, appInfo->peerHandleId)) {
361 TRANS_LOGE(TRANS_CTRL, "Failed to add items");
362 goto EXIT_FAIL;
363 }
364 data = cJSON_PrintUnformatted(json);
365 if (data == NULL) {
366 TRANS_LOGW(TRANS_CTRL, "cJSON_PrintUnformatted failed");
367 }
368 cJSON_Delete(json);
369 return data;
370
371 EXIT_FAIL:
372 cJSON_Delete(json);
373 return NULL;
374 }
375
UnpackReply(const cJSON * msg,AppInfo * appInfo,uint16_t * fastDataSize)376 int32_t UnpackReply(const cJSON *msg, AppInfo *appInfo, uint16_t *fastDataSize)
377 {
378 if (msg == NULL || appInfo == NULL) {
379 TRANS_LOGW(TRANS_CTRL, "invalid param");
380 return SOFTBUS_INVALID_PARAM;
381 }
382
383 char uuid[DEVICE_ID_SIZE_MAX] = { 0 };
384 if (!GetJsonObjectStringItem(msg, DEVICE_ID, uuid, DEVICE_ID_SIZE_MAX)) {
385 TRANS_LOGE(TRANS_CTRL, "Failed to get uuid");
386 return SOFTBUS_PARSE_JSON_ERR;
387 }
388 if (strcmp(uuid, appInfo->peerData.deviceId) != 0) {
389 TRANS_LOGE(TRANS_CTRL, "Invalid uuid");
390 return SOFTBUS_TRANS_INVALID_UUID;
391 }
392 if (!GetJsonObjectNumber16Item(msg, FIRST_DATA_SIZE, fastDataSize)) {
393 TRANS_LOGW(TRANS_CTRL, "Failed to get fast data size");
394 }
395
396 int32_t apiVersion = API_V1;
397 (void)GetJsonObjectNumberItem(msg, API_VERSION, &apiVersion);
398 appInfo->peerData.apiVersion = (ApiVersion)apiVersion;
399 appInfo->peerData.uid = -1;
400 appInfo->peerData.pid = -1;
401 (void)GetJsonObjectNumberItem(msg, UID, &appInfo->peerData.uid);
402 (void)GetJsonObjectNumberItem(msg, PID, &appInfo->peerData.pid);
403 if (!GetJsonObjectInt32Item(msg, MY_HANDLE_ID, &(appInfo->peerHandleId)) ||
404 !GetJsonObjectInt32Item(msg, PEER_HANDLE_ID, &(appInfo->myHandleId))) {
405 appInfo->myHandleId = -1;
406 appInfo->peerHandleId = -1;
407 }
408 if (!GetJsonObjectNumberItem(msg, MTU_SIZE, (int32_t *)&(appInfo->peerData.dataConfig))) {
409 TRANS_LOGW(TRANS_CTRL, "peer dataconfig is null.");
410 }
411 if (apiVersion != API_V1) {
412 if (!GetJsonObjectStringItem(msg, PKG_NAME, (appInfo->peerData.pkgName), PKG_NAME_SIZE_MAX) ||
413 !GetJsonObjectStringItem(msg, AUTH_STATE, (appInfo->peerData.authState), AUTH_STATE_SIZE_MAX)) {
414 TRANS_LOGE(TRANS_CTRL, "Failed to get pkgName or authState");
415 return SOFTBUS_PARSE_JSON_ERR;
416 }
417 }
418 if (!GetJsonObjectNumberItem(msg, TRANS_CAPABILITY, (int32_t *)&(appInfo->channelCapability))) {
419 appInfo->channelCapability = 0;
420 }
421 return SOFTBUS_OK;
422 }
423
UnpackReplyErrCode(const cJSON * msg,int32_t * errCode)424 int32_t UnpackReplyErrCode(const cJSON *msg, int32_t *errCode)
425 {
426 if ((msg == NULL) || (errCode == NULL)) {
427 TRANS_LOGW(TRANS_CTRL, "invalid param");
428 return SOFTBUS_INVALID_PARAM;
429 }
430
431 if (!GetJsonObjectInt32Item(msg, ERR_CODE, errCode)) {
432 return SOFTBUS_PARSE_JSON_ERR;
433 }
434
435 return SOFTBUS_OK;
436 }
437
TransTdcEncrypt(const char * sessionKey,const char * in,uint32_t inLen,char * out,uint32_t * outLen)438 static int32_t TransTdcEncrypt(const char *sessionKey, const char *in, uint32_t inLen, char *out, uint32_t *outLen)
439 {
440 AesGcmCipherKey cipherKey = {0};
441 cipherKey.keyLen = SESSION_KEY_LENGTH;
442 if (memcpy_s(cipherKey.key, SESSION_KEY_LENGTH, sessionKey, SESSION_KEY_LENGTH) != EOK) {
443 TRANS_LOGE(TRANS_CTRL, "memcpy key error.");
444 return SOFTBUS_MEM_ERR;
445 }
446 int32_t ret = SoftBusEncryptData(&cipherKey, (unsigned char *)in, inLen, (unsigned char *)out, outLen);
447 (void)memset_s(&cipherKey, sizeof(AesGcmCipherKey), 0, sizeof(AesGcmCipherKey));
448 if (ret != SOFTBUS_OK) {
449 TRANS_LOGE(TRANS_CTRL, "SoftBusEncryptData fail. ret=%{public}d", ret);
450 return SOFTBUS_ENCRYPT_ERR;
451 }
452 return SOFTBUS_OK;
453 }
454
PackTcpFastDataPacketHead(TcpFastDataPacketHead * data)455 static void PackTcpFastDataPacketHead(TcpFastDataPacketHead *data)
456 {
457 data->magicNumber = SoftBusHtoLl(data->magicNumber);
458 data->seq = (int32_t)SoftBusHtoLl((uint32_t)data->seq);
459 data->flags = SoftBusHtoLl(data->flags);
460 data->dataLen = SoftBusHtoLl(data->dataLen);
461 }
462
TransTdcPackFastData(const AppInfo * appInfo,uint32_t * outLen)463 char *TransTdcPackFastData(const AppInfo *appInfo, uint32_t *outLen)
464 {
465 #define MAGIC_NUMBER 0xBABEFACE
466 #define TDC_PKT_HEAD_SEQ_START 1024
467 if ((appInfo == NULL) || (outLen == NULL)) {
468 TRANS_LOGE(TRANS_CTRL, "invalid param");
469 return NULL;
470 }
471 uint32_t dataLen = appInfo->fastTransDataSize + OVERHEAD_LEN;
472 char *buf = (char *)SoftBusCalloc(dataLen + FAST_DATA_HEAD_SIZE);
473 if (buf == NULL) {
474 TRANS_LOGE(TRANS_CTRL, "malloc failed.");
475 return NULL;
476 }
477 static _Atomic int32_t tdcPktHeadSeq = TDC_PKT_HEAD_SEQ_START;
478 TcpFastDataPacketHead pktHead = {
479 .magicNumber = MAGIC_NUMBER,
480 .seq = atomic_fetch_add_explicit(&tdcPktHeadSeq, 1, memory_order_relaxed),
481 .flags = (appInfo->businessType == BUSINESS_TYPE_BYTE) ? FLAG_BYTES : FLAG_MESSAGE,
482 .dataLen = dataLen,
483 };
484 PackTcpFastDataPacketHead(&pktHead);
485 if (memcpy_s(buf, FAST_DATA_HEAD_SIZE, &pktHead, sizeof(TcpFastDataPacketHead)) != EOK) {
486 SoftBusFree(buf);
487 TRANS_LOGE(TRANS_CTRL, "memcpy_s error");
488 return NULL;
489 }
490 if (TransTdcEncrypt(appInfo->sessionKey, (const char *)appInfo->fastTransData,
491 appInfo->fastTransDataSize, buf + FAST_DATA_HEAD_SIZE, &dataLen) != SOFTBUS_OK) {
492 TRANS_LOGE(TRANS_CTRL, "encrypt error");
493 SoftBusFree(buf);
494 return NULL;
495 }
496 *outLen = dataLen + FAST_DATA_HEAD_SIZE;
497 return buf;
498 }