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