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