1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "nstackx_dfile_frame.h"
17 #include "nstackx_util.h"
18 #include "nstackx_error.h"
19 #include "nstackx_dfile.h"
20 #include "nstackx_dfile_log.h"
21 #include "nstackx_dfile_config.h"
22 #include "nstackx_dev.h"
23 #include "securec.h"
24
25 #define TAG "nStackXDFile"
26
GetFrameName(DFileFrameType frameType)27 const char *GetFrameName(DFileFrameType frameType)
28 {
29 uint32_t i;
30
31 static const char *frameNameList[] = {
32 [NSTACKX_DFILE_FILE_HEADER_FRAME] = "FILE_HEADER_FRAME",
33 [NSTACKX_DFILE_FILE_HEADER_CONFIRM_FRAME] = "FILE_HEADER_CONFIRM_FRAME",
34 [NSTACKX_DFILE_FILE_TRANSFER_REQ_FRAME] = "FILE_TRANSFER_REQ_FRAME",
35 [NSTACKX_DFILE_FILE_DATA_FRAME] = "FILE_DATA_FRAME",
36 [NSTACKX_DFILE_FILE_TRANSFER_DONE_FRAME] = "FILE_TRANSFER_DONE_FRAME",
37 [NSTACKX_DFILE_FILE_TRANSFER_DONE_ACK_FRAME] = "FILE_TRANSFER_DONE_ACK_FRAME",
38 [NSTACKX_DFILE_SETTING_FRAME] = "SETTING_FRAME",
39 [NSTACKX_DFILE_RST_FRAME] = "RST_FRAME",
40 };
41
42 for (i = 0; i < sizeof(frameNameList) / sizeof(frameNameList[0]); i++) {
43 if (i == frameType) {
44 return frameNameList[i];
45 }
46 }
47
48 return "unknown";
49 }
50
GetTarTotalBlockLength(FileList * fileList)51 uint64_t GetTarTotalBlockLength(FileList *fileList)
52 {
53 char pathSeparator = '/';
54 uint64_t tarFilesTotalLen = 0;
55 uint64_t blockCnt;
56 uint32_t i;
57 int32_t ret;
58 struct stat statInfo;
59 char *path = NULL;
60
61 for (i = 0; i < fileList->num; i++) {
62 tarFilesTotalLen += BLOCK_LEN;
63
64 path = fileList->list[i].fullFileName;
65 if (strlen(path) > MAX_NAME_LEN) {
66 // +1 because of the string end '\0'
67 tarFilesTotalLen += BLOCK_LEN +
68 (((strlen(path) + 1 - (long long)(path[0] == pathSeparator) + BLOCK_LEN - 1) / BLOCK_LEN) * BLOCK_LEN);
69 }
70
71 ret = stat(path, &statInfo);
72 if (ret != NSTACKX_EOK) {
73 DFILE_LOGE(TAG, "get stat error: %d", ret);
74 return 0;
75 }
76
77 // file body length
78 blockCnt = (uint64_t)((statInfo.st_size + BLOCK_LEN - 1) / BLOCK_LEN);
79 tarFilesTotalLen += (blockCnt * BLOCK_LEN);
80 }
81
82 // file tail paddings length
83 tarFilesTotalLen += BLOCK_LEN;
84
85 return tarFilesTotalLen;
86 }
87
EncodeFileInfo(FileList * fileList,uint16_t fileId,uint8_t * buffer,size_t length,size_t * fileInfoSize)88 static int32_t EncodeFileInfo(FileList *fileList, uint16_t fileId, uint8_t *buffer, size_t length,
89 size_t *fileInfoSize)
90 {
91 FileInfoUnit *fileInfoUnit = (FileInfoUnit *)buffer;
92 const char *fileName = NULL;
93 uint16_t fileNameLen;
94 size_t remainLength;
95 uint64_t filesTotalLen;
96
97 if (fileId == 0) {
98 if (fileList->packedUserData != NULL) {
99 fileName = (char *)fileList->packedUserData;
100 fileNameLen = fileList->packedUserDataLen;
101 } else {
102 fileName = fileList->userData;
103 fileNameLen = (uint16_t)strlen(fileName);
104 }
105 filesTotalLen = 0;
106 } else {
107 fileName = FileListGetRemotePath(fileList, fileId);
108 if (fileName == NULL) {
109 fileName = FileListGetFileName(fileList, fileId);
110 }
111 fileNameLen = (uint16_t)strlen(fileName);
112 if (fileList->tarFlag == NSTACKX_FALSE) {
113 filesTotalLen = FileListGetFileSize(fileList, fileId);
114 } else {
115 filesTotalLen = GetTarTotalBlockLength(fileList);
116 }
117 }
118
119 if (length <= offsetof(FileInfoUnit, fileName)) {
120 /* Running out of buffer */
121 DFILE_LOGE(TAG, "buffer length %zu is not enough", length);
122 return NSTACKX_EAGAIN;
123 }
124 remainLength = length - offsetof(FileInfoUnit, fileName);
125 if (memcpy_s(fileInfoUnit->fileName, remainLength, fileName, fileNameLen) != EOK) {
126 /* Running out of buffer */
127 DFILE_LOGE(TAG, "memcpy_s fileName error. remain length %zu, fileNameLen %hu", remainLength, fileNameLen);
128 return NSTACKX_EAGAIN;
129 }
130 fileInfoUnit->fileId = htons(fileId);
131 fileInfoUnit->fileSize = htobe64(filesTotalLen);
132 fileInfoUnit->fileNameLength = htons(fileNameLen);
133 *fileInfoSize = offsetof(FileInfoUnit, fileName) + fileNameLen;
134 return NSTACKX_EOK;
135 }
136
137 /* Caller should make sure that "length" can cover the minimum header length */
EncodeFileHeaderFrameSp(FileList * fileList,int32_t * fileId,uint8_t * buffer,size_t length,size_t * frameLength)138 void EncodeFileHeaderFrameSp(FileList *fileList, int32_t *fileId, uint8_t *buffer, size_t length,
139 size_t *frameLength)
140 {
141 FileHeaderFrame *headerFrame = (FileHeaderFrame *)buffer;
142 size_t offset = 0;
143 size_t fileInfoSize = 0;
144 size_t bufferLength = length;
145 int32_t nextFileId;
146 int32_t lastAddedFileId = *fileId;
147 uint32_t fileNum;
148
149 /* Remaining buffer length for fileInfoUnit */
150 bufferLength -= (sizeof(uint16_t) + DFILE_FRAME_HEADER_LEN);
151
152 if (fileList->tarFlag == NSTACKX_TRUE) {
153 fileNum = 1;
154 } else {
155 fileNum = FileListGetNum(fileList);
156 }
157
158 do {
159 if (lastAddedFileId == (int32_t)fileNum || bufferLength <= offset) {
160 break;
161 }
162
163 nextFileId = lastAddedFileId + 1;
164 if (FileListGetFileNameAcked(fileList, (uint16_t)nextFileId) ||
165 (nextFileId == 0 && fileList->userData == NULL && fileList->packedUserData == NULL)) {
166 DFILE_LOGI(TAG, "SKIP FILE ID %d", nextFileId);
167 lastAddedFileId = nextFileId;
168 continue;
169 }
170
171 if (EncodeFileInfo(fileList, (uint16_t)nextFileId, &headerFrame->fileInfoUnit[offset],
172 bufferLength - offset, &fileInfoSize) != NSTACKX_EOK) {
173 DFILE_LOGE(TAG, "EncodeFileInfo fileId %d failed", nextFileId);
174 break;
175 }
176
177 offset += fileInfoSize;
178 lastAddedFileId = nextFileId;
179 } while (NSTACKX_TRUE);
180
181 headerFrame->header.type = NSTACKX_DFILE_FILE_HEADER_FRAME;
182 if (fileList->userData != NULL) {
183 SetDfileFrameUserDataFlag(&headerFrame->header);
184 }
185
186 if (fileList->pathType > 0) {
187 SetDfileFramePathTypeFlag(&headerFrame->header);
188 }
189 /* set no sync flag */
190 if (fileList->noSyncFlag) {
191 SetDfileFrameNoSyncFlag(&headerFrame->header);
192 }
193 /* Add "node number" */
194 offset += sizeof(uint16_t);
195 headerFrame->header.length = htons((uint16_t)offset);
196 headerFrame->nodeNumber = htons((uint16_t)fileNum);
197 /* Update internal buffer length */
198 *frameLength = DFILE_FRAME_HEADER_LEN + offset;
199 *fileId = lastAddedFileId;
200 }
201
EncodeFileHeaderFrame(FileList * fileList,int32_t * fileId,uint8_t * buffer,size_t length,size_t * frameLength)202 void EncodeFileHeaderFrame(FileList *fileList, int32_t *fileId, uint8_t *buffer, size_t length,
203 size_t *frameLength)
204 {
205 EncodeFileHeaderFrameSp(fileList, fileId, buffer, length, frameLength);
206 }
207
208 /* Caller should make sure that "length" can cover the minimum header length */
EncodeFileHeaderConfirmFrame(FileList * fileList,uint16_t * fileId,uint8_t * buffer,size_t length,size_t * frameLength)209 void EncodeFileHeaderConfirmFrame(FileList *fileList, uint16_t *fileId, uint8_t *buffer, size_t length,
210 size_t *frameLength)
211 {
212 FileHeaderConfirmFrame *confirmFrame = (FileHeaderConfirmFrame *)buffer;
213 size_t bufferLength = length;
214 uint16_t payloadLength;
215 uint16_t nextFileId;
216 uint16_t lastAckedFileId = *fileId;
217 uint16_t i = 0;
218
219 /* Remaining buffer length for payload */
220 bufferLength -= DFILE_FRAME_HEADER_LEN;
221
222 if ((fileList->userDataFlag & NSTACKX_DFILE_HEADER_FRAME_USER_DATA_FLAG) &&
223 (fileList->userDataFlag & NSTACKX_FLAGS_FILE_NAME_RECEIVED)) {
224 confirmFrame->fileId[i] = 0;
225 i++;
226 }
227
228 do {
229 if (lastAckedFileId == FileListGetNum(fileList)) {
230 break;
231 }
232
233 nextFileId = lastAckedFileId + 1;
234 if (!FileListGetFileNameReceived(fileList, nextFileId)) {
235 lastAckedFileId = nextFileId;
236 DFILE_LOGE(TAG, "fileId %u is not acked yet", nextFileId);
237 continue;
238 }
239 if (i >= (bufferLength >> 1)) {
240 break;
241 }
242 confirmFrame->fileId[i++] = htons(nextFileId);
243 lastAckedFileId = nextFileId;
244 } while (NSTACKX_TRUE);
245
246 payloadLength = (uint16_t)(i * sizeof(uint16_t)); /* length should be within MTU to avoid overflow */
247 confirmFrame->header.type = NSTACKX_DFILE_FILE_HEADER_CONFIRM_FRAME;
248 /* Don't have to set flag for ACK frame */
249 confirmFrame->header.flag = 0;
250 confirmFrame->header.length = htons(payloadLength);
251
252 /* Update internal buffer length */
253 *frameLength = DFILE_FRAME_HEADER_LEN + payloadLength;
254 *fileId = lastAckedFileId;
255 }
256
257 /* Caller should make sure that "length" can cover the minimum header length */
EncodeFileTransferDoneFrame(uint8_t * buffer,size_t length,uint16_t fileIdList[],uint32_t fileIdNum,size_t * frameLength)258 void EncodeFileTransferDoneFrame(uint8_t *buffer, size_t length, uint16_t fileIdList[], uint32_t fileIdNum,
259 size_t *frameLength)
260 {
261 uint32_t i;
262 uint32_t maxIdNum;
263 uint16_t payloadLength;
264 FileTransferDoneFrame *transferDoneFrame = (FileTransferDoneFrame *)buffer;
265
266 maxIdNum = (uint32_t)((length - DFILE_FRAME_HEADER_LEN) / sizeof(uint16_t));
267 if (maxIdNum > fileIdNum) {
268 maxIdNum = fileIdNum;
269 }
270
271 for (i = 0; i < maxIdNum; i++) {
272 transferDoneFrame->fileId[i] = htons(fileIdList[i]);
273 }
274
275 transferDoneFrame->header.type = NSTACKX_DFILE_FILE_TRANSFER_DONE_FRAME;
276
277 payloadLength = (uint16_t)(maxIdNum * sizeof(uint16_t));
278 transferDoneFrame->header.length = htons(payloadLength);
279
280 *frameLength = DFILE_FRAME_HEADER_LEN + payloadLength;
281 }
282
283 /* Caller should make sure that "length" can cover the minimum header length */
EncodeSettingFrame(uint8_t * buffer,size_t length,size_t * frameLength,const SettingFrame * settingFramePara)284 void EncodeSettingFrame(uint8_t *buffer, size_t length, size_t *frameLength, const SettingFrame *settingFramePara)
285 {
286 SettingFrame *settingFrame = (SettingFrame *)buffer;
287
288 *frameLength = sizeof(SettingFrame);
289 if (*frameLength > length) {
290 return;
291 }
292 settingFrame->header.type = NSTACKX_DFILE_SETTING_FRAME;
293 settingFrame->header.flag = 0;
294 settingFrame->header.sessionId = 0;
295 settingFrame->header.transId = 0;
296 settingFrame->mtu = htons(settingFramePara->mtu);
297 settingFrame->connType = htons(settingFramePara->connType);
298 settingFrame->dFileVersion = htonl(NSTACKX_DFILE_VERSION);
299 settingFrame->abmCapability = 0;
300 settingFrame->header.length = htons(*frameLength - DFILE_FRAME_HEADER_LEN);
301 settingFrame->capability = htonl(settingFramePara->capability);
302 settingFrame->dataFrameSize = htonl(settingFramePara->dataFrameSize);
303 settingFrame->capsCheck = htonl(settingFramePara->capsCheck);
304 settingFrame->cipherCapability = htonl(settingFramePara->cipherCapability);
305 settingFrame->deviceBits = htons(settingFramePara->deviceBits);
306 }
307
308 /* Caller should make sure that "length" can cover the minimum header length */
EncodeRstFrame(uint8_t * buffer,size_t length,size_t * frameLength,uint16_t transId,uint16_t errCode)309 void EncodeRstFrame(uint8_t *buffer, size_t length, size_t *frameLength, uint16_t transId, uint16_t errCode)
310 {
311 RstFrame *rstFrame = (RstFrame *)buffer;
312 uint16_t payloadLength;
313
314 payloadLength = sizeof(uint16_t);
315 *frameLength = DFILE_FRAME_HEADER_LEN + payloadLength;
316 if (*frameLength > length) {
317 return;
318 }
319 rstFrame->header.type = NSTACKX_DFILE_RST_FRAME;
320 rstFrame->header.flag = 0;
321 rstFrame->header.sessionId = 0;
322 rstFrame->header.transId = htons(transId);
323 rstFrame->code = htons(errCode);
324 rstFrame->header.length = htons(payloadLength);
325 }
326
EncodeBackPressFrame(uint8_t * buffer,size_t length,size_t * frameLength,uint8_t recvListOverIo)327 void EncodeBackPressFrame(uint8_t *buffer, size_t length, size_t *frameLength, uint8_t recvListOverIo)
328 {
329 BackPressureFrame *backPressFrame = (BackPressureFrame *)buffer;
330 uint16_t payloadLength;
331
332 payloadLength = sizeof(DataBackPressure);
333 *frameLength = DFILE_FRAME_HEADER_LEN + payloadLength;
334 if (*frameLength > length) {
335 return;
336 }
337
338 backPressFrame->header.type = NSTACKX_DFILE_FILE_BACK_PRESSURE_FRAME;
339 backPressFrame->header.flag = 0;
340 backPressFrame->header.sessionId = 0;
341 backPressFrame->header.transId = 0;
342 backPressFrame->header.length = htons(payloadLength);
343 backPressFrame->backPressure.recvListOverIo = recvListOverIo;
344 backPressFrame->backPressure.recvBufThreshold = 0;
345 backPressFrame->backPressure.stopSendPeriod = htonl(0);
346 }
347
348 /* Caller should make sure that "length" can cover the minimum header length */
EncodeFileTransferDoneAckFrame(uint8_t * buffer,size_t length,uint16_t transId,size_t * frameLength)349 void EncodeFileTransferDoneAckFrame(uint8_t *buffer, size_t length, uint16_t transId, size_t *frameLength)
350 {
351 FileTransferDoneAckFrame *transferDoneAckFrame = (FileTransferDoneAckFrame *)buffer;
352
353 *frameLength = DFILE_FRAME_HEADER_LEN;
354 if (*frameLength > length) {
355 return;
356 }
357 transferDoneAckFrame->header.type = NSTACKX_DFILE_FILE_TRANSFER_DONE_ACK_FRAME;
358 transferDoneAckFrame->header.transId = htons(transId);
359 }
360
DecodeDFileFrame(const uint8_t * buffer,size_t bufferLength,DFileFrame ** frame)361 int32_t DecodeDFileFrame(const uint8_t *buffer, size_t bufferLength, DFileFrame **frame)
362 {
363 DFileFrame *dFileFrame = (DFileFrame *)buffer;
364 uint16_t payloadLength;
365
366 if (bufferLength < DFILE_FRAME_HEADER_LEN) {
367 DFILE_LOGE(TAG, "drop malformed frame");
368 return NSTACKX_EFAILED;
369 }
370
371 payloadLength = ntohs(dFileFrame->header.length);
372 if (bufferLength - DFILE_FRAME_HEADER_LEN != payloadLength) {
373 DFILE_LOGE(TAG, "drop malformed frame");
374 return NSTACKX_EFAILED;
375 }
376
377 *frame = dFileFrame;
378 return NSTACKX_EOK;
379 }
380
SetDfileHeaderFrameUserDataFlag(FileList * fileList)381 static inline void SetDfileHeaderFrameUserDataFlag(FileList *fileList)
382 {
383 fileList->userDataFlag = fileList->userDataFlag | NSTACKX_DFILE_HEADER_FRAME_USER_DATA_FLAG;
384 }
385
CheckDfileHeaderFrameUserDataFlag(uint8_t flag)386 static inline uint8_t CheckDfileHeaderFrameUserDataFlag(uint8_t flag)
387 {
388 return flag & NSTACKX_DFILE_HEADER_FRAME_USER_DATA_FLAG;
389 }
390
CheckDfileHeaderFramePathTypeFlag(uint8_t flag)391 static inline uint8_t CheckDfileHeaderFramePathTypeFlag(uint8_t flag)
392 {
393 return flag & NSTACKX_DFILE_HEADER_FRAME_PATH_TYPE_FLAG;
394 }
395
CheckDfileHeaderFrameNoSyncFlag(uint8_t flag)396 static inline uint8_t CheckDfileHeaderFrameNoSyncFlag(uint8_t flag)
397 {
398 return flag & NSTACKX_DFILE_HEADER_FRAME_NO_SYNC_FLAG;
399 }
400
DecodeFileHeaderFrameSp(FileList * fileList,FileHeaderFrame * headerFrame)401 int32_t DecodeFileHeaderFrameSp(FileList *fileList, FileHeaderFrame *headerFrame)
402 {
403 FileInfoUnit *fileInfoUnit = NULL;
404 size_t offset = 0;
405 if (ntohs(headerFrame->header.length) <= sizeof(uint16_t)) {
406 return NSTACKX_EFAILED;
407 }
408 uint8_t *buffer = (uint8_t *)headerFrame->fileInfoUnit;
409 uint16_t length = ntohs(headerFrame->header.length) - sizeof(uint16_t);
410 uint16_t nodeNumber = ntohs(headerFrame->nodeNumber);
411 int32_t ret;
412 if (FileListSetNum(fileList, nodeNumber) != NSTACKX_EOK) {
413 return NSTACKX_EFAILED;
414 }
415 if (CheckDfileHeaderFrameUserDataFlag(headerFrame->header.flag) != 0 ||
416 (CheckDfileHeaderFramePathTypeFlag(headerFrame->header.flag) != 0)) {
417 SetDfileHeaderFrameUserDataFlag(fileList);
418 }
419 if (CheckDfileHeaderFrameNoSyncFlag(headerFrame->header.flag) != 0) {
420 fileList->noSyncFlag = NSTACKX_TRUE;
421 }
422 while (offset < length) {
423 fileInfoUnit = (FileInfoUnit *)&buffer[offset];
424 if (length - offset <= offsetof(FileInfoUnit, fileName)) {
425 DFILE_LOGE(TAG, "length %u is too small", length);
426 return NSTACKX_EFAILED;
427 }
428 size_t fileNameLength = ntohs(fileInfoUnit->fileNameLength);
429 uint16_t fileId = ntohs(fileInfoUnit->fileId);
430 if ((fileId == 0) && !(CheckDfileHeaderFrameUserDataFlag(headerFrame->header.flag)) &&
431 !(CheckDfileHeaderFramePathTypeFlag(headerFrame->header.flag))) {
432 /* Invalid file id, discard the whole frame. */
433 return NSTACKX_EFAILED;
434 }
435 /*
436 * fileNameLength validation:
437 * 1) Minimum value:
438 * For normal file name (file id != 0), it should be > 0;
439 * For user data (file id = 0), 0 is allowed.
440 * 2) Maximum value: should be <= remaining buffer - offsetof(FileInfoUnit, fileName)
441 */
442 if ((fileId != 0 && fileNameLength == 0) ||
443 (fileNameLength > (length - offset - offsetof(FileInfoUnit, fileName)))) {
444 return NSTACKX_EFAILED;
445 }
446 if (fileId == 0) {
447 ret = FileListAddUserData(fileList, fileInfoUnit->fileName, fileNameLength, headerFrame->header.flag);
448 } else {
449 uint64_t fileSize = be64toh(fileInfoUnit->fileSize);
450 ret = FileListAddFile(fileList, fileId, fileInfoUnit->fileName, fileNameLength, fileSize);
451 }
452 if (ret != NSTACKX_EOK) {
453 return NSTACKX_EFAILED;
454 }
455 offset += (offsetof(FileInfoUnit, fileName) + fileNameLength);
456 }
457
458 return NSTACKX_EOK;
459 }
460
DecodeFileHeaderFrame(FileList * fileList,FileHeaderFrame * headerFrame)461 int32_t DecodeFileHeaderFrame(FileList *fileList, FileHeaderFrame *headerFrame)
462 {
463 return DecodeFileHeaderFrameSp(fileList, headerFrame);
464 }
465
DecodeFileHeaderConfirmFrame(FileList * fileList,FileHeaderConfirmFrame * confirmFrame)466 int32_t DecodeFileHeaderConfirmFrame(FileList *fileList, FileHeaderConfirmFrame *confirmFrame)
467 {
468 uint16_t fileId;
469 uint16_t i;
470 size_t length = ntohs(confirmFrame->header.length);
471 DFILE_LOGI(TAG, "header confirm frame length %u", length);
472 /* Make sure payload buffer should contain valid number of file ID. */
473 if (length == 0 || length % sizeof(uint16_t) != 0) {
474 return NSTACKX_EFAILED;
475 }
476 uint16_t *fileIdList = confirmFrame->fileId;
477 uint16_t fileIdCount = (uint16_t)(length >> 1);
478
479 for (i = 0; i < fileIdCount; i++) {
480 fileId = ntohs(fileIdList[i]);
481 if (fileId > FileListGetNum(fileList)) {
482 DFILE_LOGE(TAG, "Invalid file ID %u", fileId);
483 continue;
484 }
485 FileListSetFileNameAcked(fileList, fileId);
486 }
487
488 return NSTACKX_EOK;
489 }
490
GetFileIdFromFileDataFrame(const FileList * fileList,const FileDataFrame * dataFrame)491 int16_t GetFileIdFromFileDataFrame(const FileList *fileList, const FileDataFrame *dataFrame)
492 {
493 uint16_t fileId;
494
495 fileId = ntohs(dataFrame->fileId);
496 if (fileId == NSTACKX_RESERVED_FILE_ID || fileId > FileListGetNum(fileList)) {
497 return 0;
498 }
499
500 return (int16_t)fileId;
501 }
502
DecodeFileTransferDoneFrame(FileList * fileList,FileTransferDoneFrame * transferDoneFrame)503 int32_t DecodeFileTransferDoneFrame(FileList *fileList, FileTransferDoneFrame *transferDoneFrame)
504 {
505 uint32_t i;
506 uint32_t fileIdNum;
507 uint16_t fileId;
508
509 uint16_t length = ntohs(transferDoneFrame->header.length);
510 if (length == 0 || length % sizeof(uint16_t) != 0) {
511 return NSTACKX_EFAILED;
512 }
513 fileIdNum = length / sizeof(uint16_t);
514
515 DFILE_LOGI(TAG, "transId %u, FileTransferDone:fileIdNum %u, file number %u",
516 ntohs(transferDoneFrame->header.transId), fileIdNum, FileListGetNum(fileList));
517 for (i = 0; i < fileIdNum; i++) {
518 fileId = ntohs(transferDoneFrame->fileId[i]);
519 if (fileId == 0 || fileId > FileListGetNum(fileList)) {
520 continue;
521 }
522 FileListSetFileSendSuccess(fileList, fileId);
523 }
524 return NSTACKX_EOK;
525 }
526
IsSettingFrameLengthValid(const SettingFrame * hostSettingFrame,uint16_t payloadLength)527 static uint8_t IsSettingFrameLengthValid(const SettingFrame *hostSettingFrame, uint16_t payloadLength)
528 {
529 /*
530 * From dfile with historical version NSTACKX_DFILE_VERSION_0, whose setting frame is composed of header,
531 * mtu and connType.
532 */
533 if (payloadLength == sizeof(hostSettingFrame->mtu) + sizeof(hostSettingFrame->connType)) {
534 return NSTACKX_TRUE;
535 }
536
537 if (payloadLength == sizeof(hostSettingFrame->mtu) + sizeof(hostSettingFrame->connType) +
538 sizeof(hostSettingFrame->dFileVersion)) {
539 return NSTACKX_TRUE;
540 }
541
542 if (payloadLength == sizeof(hostSettingFrame->mtu) + sizeof(hostSettingFrame->connType) +
543 sizeof(hostSettingFrame->dFileVersion) + sizeof(hostSettingFrame->abmCapability)) {
544 return NSTACKX_TRUE;
545 }
546
547 if (payloadLength == sizeof(hostSettingFrame->mtu) + sizeof(hostSettingFrame->connType) +
548 sizeof(hostSettingFrame->dFileVersion) + sizeof(hostSettingFrame->abmCapability) +
549 sizeof(hostSettingFrame->capability)) {
550 return NSTACKX_TRUE;
551 }
552
553 if (payloadLength == sizeof(hostSettingFrame->mtu) + sizeof(hostSettingFrame->connType) +
554 sizeof(hostSettingFrame->dFileVersion) + sizeof(hostSettingFrame->abmCapability) +
555 sizeof(hostSettingFrame->capability) + sizeof(hostSettingFrame->dataFrameSize)) {
556 return NSTACKX_TRUE;
557 }
558
559 if (payloadLength == sizeof(hostSettingFrame->mtu) + sizeof(hostSettingFrame->connType) +
560 sizeof(hostSettingFrame->dFileVersion) + sizeof(hostSettingFrame->abmCapability) +
561 sizeof(hostSettingFrame->capability) + sizeof(hostSettingFrame->dataFrameSize) +
562 sizeof(hostSettingFrame->capsCheck)) {
563 return NSTACKX_TRUE;
564 }
565
566 /*
567 * From dfile with the same version with local dfile.
568 */
569 if (payloadLength >= sizeof(SettingFrame) - DFILE_FRAME_HEADER_LEN) {
570 return NSTACKX_TRUE;
571 }
572
573 return NSTACKX_FALSE;
574 }
575
IsSettingFrameMtuAndTypeValid(const SettingFrame * netSettingFrame)576 static uint8_t IsSettingFrameMtuAndTypeValid(const SettingFrame *netSettingFrame)
577 {
578 if (ntohs(netSettingFrame->mtu) < NSTACKX_MIN_MTU_SIZE ||
579 ntohs(netSettingFrame->connType) == CONNECT_TYPE_NONE ||
580 ntohs(netSettingFrame->connType) >= CONNECT_TYPE_MAX) {
581 return NSTACKX_FALSE;
582 }
583 return NSTACKX_TRUE;
584 }
585
DFileCheckSettingFrame(SettingFrame * netSettingFrame,SettingFrame * hostSettingFrame)586 static int32_t DFileCheckSettingFrame(SettingFrame *netSettingFrame, SettingFrame *hostSettingFrame)
587 {
588 if (netSettingFrame->header.sessionId != 0 || netSettingFrame->header.transId != 0) {
589 DFILE_LOGE(TAG, "error transId for Setting Frame");
590 return NSTACKX_EFAILED;
591 }
592 uint16_t payloadLength = ntohs(netSettingFrame->header.length);
593 if (!IsSettingFrameLengthValid(hostSettingFrame, payloadLength)) {
594 DFILE_LOGE(TAG, "illegal setting frame length %u", payloadLength);
595 return NSTACKX_EFAILED;
596 }
597 if (!IsSettingFrameMtuAndTypeValid(netSettingFrame)) {
598 DFILE_LOGE(TAG, "illegal setting frame mtu or type");
599 return NSTACKX_EFAILED;
600 }
601 return NSTACKX_EOK;
602 }
603
604 /*
605 * Note: netSettingFrame is a malloced buffer with length reading from network, so it is not reliable and its length
606 * may be shorter than sizeof(SettingFrame).
607 */
DecodeSettingFrame(SettingFrame * netSettingFrame,SettingFrame * hostSettingFrame)608 int32_t DecodeSettingFrame(SettingFrame *netSettingFrame, SettingFrame *hostSettingFrame)
609 {
610 if (DFileCheckSettingFrame(netSettingFrame, hostSettingFrame) != NSTACKX_EOK) {
611 return NSTACKX_EFAILED;
612 }
613 uint16_t payloadLength = ntohs(netSettingFrame->header.length);
614 hostSettingFrame->header.sessionId = netSettingFrame->header.sessionId;
615 hostSettingFrame->mtu = ntohs(netSettingFrame->mtu);
616 hostSettingFrame->connType = ntohs(netSettingFrame->connType);
617 if (payloadLength == sizeof(hostSettingFrame->mtu) + sizeof(hostSettingFrame->connType)) {
618 /*
619 * In this condition, this netSettingFrame is from an old version and doesn't have the member dFileVersion.
620 * Then the dFileVersion will be set to zero by defulat.
621 * Note that the usage of netSettingFrame->dFileVersion is illegal in this condition.
622 */
623 DFILE_LOGI(TAG, "this setting frame is from an old version whose setting frame doesn't "
624 "have the member dFileVersion");
625 hostSettingFrame->dFileVersion = 0;
626 } else if (payloadLength == sizeof(hostSettingFrame->mtu) + sizeof(hostSettingFrame->connType) +
627 sizeof(hostSettingFrame->dFileVersion)) {
628 hostSettingFrame->dFileVersion = ntohl(netSettingFrame->dFileVersion);
629 hostSettingFrame->abmCapability = 0;
630 } else {
631 hostSettingFrame->dFileVersion = ntohl(netSettingFrame->dFileVersion);
632 hostSettingFrame->abmCapability = ntohl(netSettingFrame->abmCapability);
633 if (payloadLength > (sizeof(hostSettingFrame->mtu) + sizeof(hostSettingFrame->connType) +
634 sizeof(hostSettingFrame->dFileVersion) + sizeof(hostSettingFrame->abmCapability))) {
635 hostSettingFrame->capability = ntohl(netSettingFrame->capability);
636 }
637 if (payloadLength > (sizeof(hostSettingFrame->mtu) + sizeof(hostSettingFrame->connType) +
638 sizeof(hostSettingFrame->dFileVersion) + sizeof(hostSettingFrame->abmCapability) +
639 sizeof(hostSettingFrame->capability))) {
640 hostSettingFrame->dataFrameSize = ntohl(netSettingFrame->dataFrameSize);
641 }
642 if (payloadLength > (sizeof(hostSettingFrame->mtu) + sizeof(hostSettingFrame->connType) +
643 sizeof(hostSettingFrame->dFileVersion) + sizeof(hostSettingFrame->abmCapability) +
644 sizeof(hostSettingFrame->capability) + sizeof(hostSettingFrame->dataFrameSize))) {
645 hostSettingFrame->capsCheck = ntohl(netSettingFrame->capsCheck);
646 }
647 if (payloadLength > (sizeof(hostSettingFrame->mtu) + sizeof(hostSettingFrame->connType) +
648 sizeof(hostSettingFrame->dFileVersion) + sizeof(hostSettingFrame->abmCapability) +
649 sizeof(hostSettingFrame->capability) + sizeof(hostSettingFrame->dataFrameSize) +
650 sizeof(hostSettingFrame->capsCheck))) {
651 hostSettingFrame->cipherCapability = ntohl(netSettingFrame->cipherCapability);
652 hostSettingFrame->deviceBits = ntohs(netSettingFrame->deviceBits);
653 }
654 }
655 DFILE_LOGI(TAG, "local version is %u, remote version is %u capability 0x%x dataFrameSize %u capsCheck 0x%x "
656 "cipherCaps 0x%x deviceBits %u",
657 NSTACKX_DFILE_VERSION, hostSettingFrame->dFileVersion, hostSettingFrame->capability,
658 hostSettingFrame->dataFrameSize, hostSettingFrame->capsCheck,
659 hostSettingFrame->cipherCapability, hostSettingFrame->deviceBits);
660 return NSTACKX_EOK;
661 }
662
DecodeRstFrame(RstFrame * rstFrame,uint16_t * code,uint16_t ** fileIdList,uint16_t * listCount)663 int32_t DecodeRstFrame(RstFrame *rstFrame, uint16_t *code, uint16_t **fileIdList, uint16_t *listCount)
664 {
665 uint16_t payloadLen = ntohs(rstFrame->header.length);
666 if (payloadLen < sizeof(uint16_t) || (payloadLen - sizeof(uint16_t)) % sizeof(uint16_t) != 0) {
667 return NSTACKX_EFAILED;
668 }
669 *code = ntohs(rstFrame->code);
670
671 if (fileIdList != NULL && listCount != NULL) {
672 *fileIdList = rstFrame->fileId;
673 *listCount = (payloadLen - sizeof(uint16_t)) / sizeof(uint16_t);
674 }
675 return NSTACKX_EOK;
676 }
677
DecodeBackPressFrame(const BackPressureFrame * backPressFrame,DataBackPressure * backPressInfo)678 int32_t DecodeBackPressFrame(const BackPressureFrame *backPressFrame, DataBackPressure *backPressInfo)
679 {
680 uint16_t payloadLen = ntohs(backPressFrame->header.length);
681 if (payloadLen < sizeof(BackPressureFrame) - sizeof(DFileFrameHeader)) {
682 return NSTACKX_EFAILED;
683 }
684
685 backPressInfo->recvListOverIo = backPressFrame->backPressure.recvListOverIo;
686 backPressInfo->recvBufThreshold = backPressFrame->backPressure.recvBufThreshold;
687 backPressInfo->stopSendPeriod = ntohl(backPressFrame->backPressure.stopSendPeriod);
688
689 return NSTACKX_EOK;
690 }
691