From 281610ac56799f6870c587a942495d91cd55b227 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Wed, 30 Dec 2020 13:02:30 +0200 Subject: merge - fix --- .../Embedded/Common/SWUpdate/FileSystem.c | 457 ++++++++++++++------- 1 file changed, 303 insertions(+), 154 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c') diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c index 018e83ce0..efc156da3 100644 --- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c +++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c @@ -31,14 +31,11 @@ #include #include -#include "third_party/fatfs/src/ffconf.h" -#include "third_party/fatfs/src/diskio.h" -#include "drivers/Flash_Memory/Flash_Memory.h" + #include "drivers/Flash_Memory/fatfs/ff.h" #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h" -#include "third_party/fatfs/src/ffconf.h" - +#include "Modules/Control/Control.h" #include "StateMachines/Printing/PrintingSTM.h" @@ -53,7 +50,7 @@ FIL *UploadFileHandle = 0; //the system supports a single active file FIL *DownloadFileHandle = 0; //the system supports a single active file char FileHandleChar[5]; char ErrorMsg[100]; -#define MAX_CHUNK_LENGTH 3500 +#define MAX_CHUNK_LENGTH 4096 int32_t FileLength = 0; int32_t FileReceivedLength = 0; int32_t FileSentLength = 0; @@ -63,6 +60,7 @@ uint32_t ReadBytes = 0; Task_Handle CommRxTaskHandle; extern Semaphore_Handle FFS_Sem; +extern Semaphore_Handle FileUpload_sem_param; ErrorCode getErrorCode(FRESULT Fresult) { @@ -74,14 +72,19 @@ bool isDirectory(FileAttribute FileAtt) return true; return false; } -bool FileDone = false; +bool FileDone = true; +bool FileUploadGetState(void) +{ + return FileDone; +} +int CommRxpri; uint32_t FileUploadRequestFunc(MessageContainer* requestContainer) { //uint32_t status = OK; FRESULT Fresult = FR_OK; - + bool sem_ok = false; MessageContainer responseContainer; FileUploadRequest* request = file_upload_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); @@ -90,7 +93,10 @@ uint32_t FileUploadRequestFunc(MessageContainer* requestContainer) WrittenBytes=0; if (JobIsActive()) + { Fresult = FR_DENIED; + Report("file uplad rejected - job is running", __FILE__, __LINE__, 4, RpWarning, (int)0, 0); + } else { UploadFileHandle = my_malloc(sizeof(FIL)); @@ -98,38 +104,58 @@ uint32_t FileUploadRequestFunc(MessageContainer* requestContainer) Fresult = FR_DENIED; else { - Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER); - Fresult = f_open(UploadFileHandle,request->path,FA_READ | FA_WRITE | FA_OPEN_ALWAYS | FA_CREATE_ALWAYS); - if (Fresult == FR_OK) + if (1)//(Semaphore_pend(FileUpload_sem_param, BIOS_NO_WAIT)) { - FileLength = request->length; - FileReceivedLength = 0; - REPORT_MSG (FileLength,"file upload request"); - response.has_maxchunklength = true; - response.maxchunklength = MAX_CHUNK_LENGTH; - strcpy(FileHandleChar, "1234"); - response.uploadid = FileHandleChar; //supporting only single file at each time. - FileDone = false; + sem_ok = true; } else { - my_free (UploadFileHandle); - UploadFileHandle = 0; - Semaphore_post(FFS_Sem); + Semaphore_post(FileUpload_sem_param); + Report("semaphore was not free", __FILE__, __LINE__, request->length, RpWarning, (int)MAX_CHUNK_LENGTH, 0); + sem_ok = true; } + if (sem_ok == true) + { + CommRxTaskHandle = Task_self(); + CommRxpri = Task_getPri(CommRxTaskHandle); + Task_setPri(CommRxTaskHandle, 11); + Report("Task_setPri", __FILE__, __LINE__, 11, RpWarning, (int)CommRxTaskHandle, 0); + //Report("FileUploadRequestFunc 2", __FILE__, __LINE__, msec_millisecondCounter, RpWarning, (int)0, 0); + Fresult = f_open(UploadFileHandle,request->path,FA_READ | FA_WRITE | FA_OPEN_ALWAYS | FA_CREATE_ALWAYS); + if (Fresult == FR_OK) + { + usnprintf(ErrorMsg, 100, "file upload request %s %d",request->path,request->length); + Report(ErrorMsg, __FILE__, __LINE__, request->length, RpWarning, (int)MAX_CHUNK_LENGTH, 0); + FileLength = request->length; + FileReceivedLength = 0; + response.has_maxchunklength = true; + response.maxchunklength = MAX_CHUNK_LENGTH; + strcpy(FileHandleChar, "1234"); + response.uploadid = FileHandleChar; //supporting only single file at each time. + FileDone = false; + } + else + { + my_free (UploadFileHandle); + UploadFileHandle = 0; + Semaphore_post(FileUpload_sem_param); + } + } + else + { + Fresult = FR_DENIED; + Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning, (int)0, 0); + } } } - CommRxTaskHandle = Task_self(); - Task_setPri(CommRxTaskHandle, 4); - // Report("Task_setPri", __FILE__, __LINE__, 4, RpWarning, (int)CommRxTaskHandle, 0); - - responseContainer = createContainer(MESSAGE_TYPE__FileUploadResponse, requestContainer->token, false, &response, &file_upload_response__pack, &file_upload_response__get_packed_size); + responseContainer = createContainer(MESSAGE_TYPE__FileUploadResponse, requestContainer->token, true, &response, &file_upload_response__pack, &file_upload_response__get_packed_size); if (Fresult!= FR_OK) { + responseContainer.has_error = true; responseContainer.error = getErrorCode(Fresult); - responseContainer.errormessage = "File operation error"; + responseContainer.errormessage = "File operation upload request error"; } responseContainer.continuous = false; uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); @@ -141,6 +167,25 @@ uint32_t FileUploadRequestFunc(MessageContainer* requestContainer) return OK; } FRESULT lFresult = FR_OK; +uint32_t Chunk_ControlId = 0xFF; +uint32_t FileChunkUploadCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) +{ + Report("chunk timeout error",__FILE__,IfIndex,FileReceivedLength,RpWarning,BusyFlag,0); + f_close(UploadFileHandle); + my_free (UploadFileHandle); + UploadFileHandle = 0; + FileReceivedLength = 0; + FileDone = true; + Task_setPri(CommRxTaskHandle, CommRxpri); + Semaphore_post(FileUpload_sem_param); + Report("Task_setPri", __FILE__, __LINE__, CommRxpri, RpWarning, (int)CommRxTaskHandle, 0); + if (SafeRemoveControlCallback(Chunk_ControlId, FileChunkUploadCallBackFunction )==OK) + Chunk_ControlId = 0xFF; + + return OK; + +} + uint32_t FileChunkUploadRequestFunc(MessageContainer* requestContainer) { //uint32_t status = OK; @@ -155,15 +200,27 @@ uint32_t FileChunkUploadRequestFunc(MessageContainer* requestContainer) FIL *ReceivedFileHandle; //the system supports a single active file + uint32_t save_milisec = 0; // if (request->uploadid == 1) ReceivedFileHandle = UploadFileHandle; // memcpy (&ReceivedFileHandle,request->uploadid,sizeof(ReceivedFileHandle)); //if (ReceivedFileHandle == FileHandle) //{ - Control_WD(ENABLE,55); //activate heaters/dispenser watchdog, 0.5 seconds - GeneralHwReady = false; - KeepAliveOneSecondCounter = 0; - Fresult = f_write(ReceivedFileHandle,request->buffer.data,request->buffer.len,&WrittenBytes ); + //Control_WD(ENABLE,55); //activate heaters/dispenser watchdog, 0.5 seconds + //GeneralHwReady = false; + if (ReceivedFileHandle==NULL) + { + Fresult = FR_DENIED; + Report("file chunk upload rejected - file not created", __FILE__, __LINE__, 4, RpWarning, (int)0, 0); + FileDone = true; + } + else + { + KeepAliveOneSecondCounter = 0; + save_milisec = msec_millisecondCounter; + Chunk_ControlId = AddControlCallback("chunk", FileChunkUploadCallBackFunction, eOneSecond, TemplateDataReadCBFunction,0,request->buffer.len, WrittenBytes ); + + Fresult = f_write(ReceivedFileHandle,request->buffer.data,request->buffer.len,&WrittenBytes ); lFresult = Fresult; if(Fresult != FR_OK) { @@ -173,6 +230,10 @@ uint32_t FileChunkUploadRequestFunc(MessageContainer* requestContainer) else { FileReceivedLength += WrittenBytes; + ReportWithPackageFilter(CommFilter,"Chunk received", __FILE__,FileLength,FileReceivedLength, RpMessage,msec_millisecondCounter-save_milisec, 0); + RemoveControlCallback(Chunk_ControlId, FileChunkUploadCallBackFunction ); + Chunk_ControlId = 0xFF; + //REPORT_MSG (FileReceivedLength,"file upload chunk"); if (FileReceivedLength == FileLength) { @@ -196,20 +257,14 @@ uint32_t FileChunkUploadRequestFunc(MessageContainer* requestContainer) } } } - /*} - else - { - LOG_ERROR (ReceivedFileHandle,"file id error"); - f_close(FileHandle); - free (FileHandle); - status = ERROR_CODE__FILE_NOT_FOUND; - }*/ + } responseContainer = createContainer(MESSAGE_TYPE__FileChunkUploadResponse, requestContainer->token, FileDone, &response, &file_chunk_upload_response__pack, &file_chunk_upload_response__get_packed_size); if (Fresult!= OK) { + responseContainer.has_error = true; responseContainer.error = getErrorCode(Fresult); - responseContainer.errormessage = "File operation error"; + responseContainer.errormessage = "File operation chunk upload error"; } responseContainer.continuous = false; uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); @@ -220,13 +275,26 @@ uint32_t FileChunkUploadRequestFunc(MessageContainer* requestContainer) SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__FileChunkUploadResponse); if (FileDone == true) { - Task_setPri(CommRxTaskHandle, 9); - GeneralHwReady = true; - Semaphore_post(FFS_Sem); - //Report("Task_setPri", __FILE__, __LINE__, 9, RpWarning, (int)CommRxTaskHandle, 0); + Task_setPri(CommRxTaskHandle, CommRxpri); + Semaphore_post(FileUpload_sem_param); + Report("Task_setPri", __FILE__, __LINE__, CommRxpri, RpWarning, (int)CommRxTaskHandle, 0); } return OK; } +void FileChunkUploadError(void) +{ + if (FileDone == false) + { + REPORT_MSG (FileReceivedLength,"file upload too much data!"); + f_close(UploadFileHandle); + //my_free (UploadFileHandle); CAN NOT CALL FREE() FROM INTERRUPT + UploadFileHandle = 0; + FileReceivedLength = 0; + FileDone = true; + Task_setPri(CommRxTaskHandle, CommRxpri); + Semaphore_post(FileUpload_sem_param); + } +} uint32_t FileDownloadRequestFunc(MessageContainer* requestContainer) { //uint32_t status = OK; @@ -256,16 +324,27 @@ uint32_t FileDownloadRequestFunc(MessageContainer* requestContainer) Fresult = FR_DENIED; else { - Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER); - Fresult = f_open(DownloadFileHandle,request->filename,FA_READ ); - if (Fresult == FR_OK) + if (1)//(Semaphore_pend(FFS_Sem, BIOS_NO_WAIT)) + { + Fresult = f_open(DownloadFileHandle,request->filename,FA_READ ); + if (Fresult == FR_OK) + { + response.has_maxchunklength = true; + response.maxchunklength = MAX_CHUNK_LENGTH; + strcpy(FileHandleChar, "1234"); + response.downloadid = FileHandleChar; //supporting only single file at each time. + Report("data request", __FILE__, 1234, MAX_CHUNK_LENGTH, RpWarning, (int)fno->fsize, 0); + } + else + { + Semaphore_post(FFS_Sem); + } + } + else { - response.has_maxchunklength = true; - response.maxchunklength = MAX_CHUNK_LENGTH; - strcpy(FileHandleChar, "1234"); - response.downloadid = FileHandleChar; //supporting only single file at each time. + Fresult = FR_DENIED; + Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning, (int)0, 0); } - } } @@ -273,8 +352,9 @@ uint32_t FileDownloadRequestFunc(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__FileDownloadResponse, requestContainer->token, false, &response, &file_download_response__pack, &file_download_response__get_packed_size); if (Fresult!= FR_OK) { + responseContainer.has_error = true; responseContainer.error = getErrorCode(Fresult); - responseContainer.errormessage = "File operation error"; + responseContainer.errormessage = "File operation download request error"; } responseContainer.continuous = false; uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); @@ -299,10 +379,11 @@ uint32_t FileChunkDownloadRequestFunc(MessageContainer* requestContainer) Buffer = my_malloc (MAX_CHUNK_LENGTH); if (Buffer != NULL) { - Fresult = f_read(SentFileHandle,Buffer,2000,&ReadBytes ); + Fresult = f_read(SentFileHandle,Buffer,MAX_CHUNK_LENGTH,&ReadBytes ); if(Fresult != FR_OK) { - LOG_ERROR (Fresult,"f_write error"); + LOG_ERROR (Fresult,"f_read error"); + Semaphore_post(FFS_Sem); } else { @@ -310,6 +391,7 @@ uint32_t FileChunkDownloadRequestFunc(MessageContainer* requestContainer) response.buffer.len = ReadBytes; response.buffer.data = Buffer; FileSentLength += ReadBytes; + Report("sending data to MS", __FILE__, ReadBytes, FileSentLength, RpWarning, (int)FileLength, 0); if (FileSentLength == FileLength) { REPORT_MSG (FileSentLength,"file download ended successfully"); @@ -335,8 +417,9 @@ uint32_t FileChunkDownloadRequestFunc(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__FileChunkDownloadResponse, requestContainer->token, false, &response, &file_chunk_download_response__pack, &file_chunk_download_response__get_packed_size); if (Fresult!= OK) { + responseContainer.has_error = true; responseContainer.error = getErrorCode(Fresult); - responseContainer.errormessage = "File operation error"; + responseContainer.errormessage = "File operation chunk download error"; } responseContainer.continuous = false; uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); @@ -362,8 +445,9 @@ uint32_t ExecuteProcessRequestFunc(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__ExecuteProcessResponse, requestContainer->token, false, &response, &execute_process_response__pack, &execute_process_response__get_packed_size); if (status!= OK) { + responseContainer.has_error = true; responseContainer.error = ERROR_CODE__GENERAL_ERROR;//getErrorCode(Fresult); - responseContainer.errormessage = "File operation error"; + responseContainer.errormessage = "File operation execute error"; } responseContainer.continuous = false; uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); @@ -388,8 +472,9 @@ uint32_t KillProcessRequestFunc(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__KillProcessResponse, requestContainer->token, false, &response, &kill_process_response__pack, &kill_process_response__get_packed_size); if (status!= OK) { + responseContainer.has_error = true; responseContainer.error = ERROR_CODE__GENERAL_ERROR;//getErrorCode(Fresult); - responseContainer.errormessage = "File operation error"; + responseContainer.errormessage = "File operation kill error"; } responseContainer.continuous = false; uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); @@ -413,6 +498,8 @@ uint32_t CreateRequestFunc(MessageContainer* requestContainer) if (isDirectory(request->attribute)) { Fresult = f_mkdir(request->path); + if (Fresult == FR_EXIST) + Fresult = FR_OK; //ingnore f_exist in directory create } else { @@ -421,22 +508,30 @@ uint32_t CreateRequestFunc(MessageContainer* requestContainer) Fresult = FR_DENIED; else { - Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER); - Fresult = f_open(UploadFileHandle,request->path,FA_CREATE_NEW); - if (Fresult == FR_OK) + if (1)//(Semaphore_pend(FFS_Sem, BIOS_NO_WAIT)) { - if (f_close (UploadFileHandle)!= FR_OK) + Fresult = f_open(UploadFileHandle,request->path,FA_READ | FA_WRITE | FA_OPEN_ALWAYS | FA_CREATE_ALWAYS); + if (Fresult == FR_OK) { - Fresult = FR_LOCKED; + if (f_close (UploadFileHandle)!= FR_OK) + { + Fresult = FR_LOCKED; + } } + Semaphore_post(FFS_Sem); + } + else + { + Fresult = FR_DENIED; + Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning, (int)0, 0); } - Semaphore_post(FFS_Sem); } } if (Fresult != FR_OK) { //status = ERROR_CODE__FILE_NOT_FOUND; - usnprintf(ErrorMsg, 100, "File Operation failed error code %d",Fresult); + //usnprintf(ErrorMsg, 100, "File Operation failed error code %d",Fresult); + Report("File Operation failed error code", __FILE__, __LINE__, Fresult, RpWarning, (int)0, 0); } free (UploadFileHandle); @@ -444,8 +539,9 @@ uint32_t CreateRequestFunc(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__CreateResponse, requestContainer->token, false, &response, &create_response__pack, &create_response__get_packed_size); if (Fresult!= OK) { + responseContainer.has_error = true; responseContainer.error = getErrorCode(Fresult); - responseContainer.errormessage = "File operation error"; + responseContainer.errormessage = "File operation create error"; } responseContainer.continuous = false; uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); @@ -470,17 +566,17 @@ uint32_t DeleteRequestFunc(MessageContainer* requestContainer) //int NumOfFiles = 0; FRESULT Fresult = FR_OK; - Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER); Fresult = f_unlink(request->path); Semaphore_post(FFS_Sem); REPORT_MSG(Fresult, "File Delete"); responseContainer = createContainer(MESSAGE_TYPE__DeleteResponse, requestContainer->token, false, &response, &delete_response__pack, &delete_response__get_packed_size); - if (Fresult!= OK) + if ((Fresult!= FR_OK)&&(Fresult!= FR_NO_FILE)) { - usnprintf(ErrorMsg, 100, "File Operation failed error code %d",Fresult); + //usnprintf(ErrorMsg, 100, "File Operation failed error code %d",Fresult); + responseContainer.has_error = true; responseContainer.error = getErrorCode(Fresult); - responseContainer.errormessage = ErrorMsg; + responseContainer.errormessage = "File operation delete error"; } responseContainer.continuous = false; uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); @@ -525,8 +621,9 @@ uint32_t GetStorageInfoRequestFunc(MessageContainer* requestContainer) responseContainer = createContainer(MESSAGE_TYPE__GetStorageInfoResponse, requestContainer->token, false, &response, &get_storage_info_response__pack, &get_storage_info_response__get_packed_size); if (Fresult!= OK) { + responseContainer.has_error = true; responseContainer.error = getErrorCode(Fresult); - responseContainer.errormessage = "File operation error"; + responseContainer.errormessage = "File operation get storage info error"; } responseContainer.continuous = false; uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); @@ -537,6 +634,8 @@ uint32_t GetStorageInfoRequestFunc(MessageContainer* requestContainer) return OK; } +//char Datestr[100]; + uint32_t GetFilesRequestFunc(MessageContainer* requestContainer) { //uint32_t status = OK; @@ -546,77 +645,98 @@ uint32_t GetFilesRequestFunc(MessageContainer* requestContainer) GetFilesRequest* request = get_files_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); GetFilesResponse response = GET_FILES_RESPONSE__INIT; - - #define MAX_NUM_OF_FILES 20 + //struct tm RTC_time; + #define MAX_NUM_OF_FILES 40 DIR dir; FILINFO* fno[MAX_NUM_OF_FILES]; char FullPath[MAX_NUM_OF_FILES][60]; - int i,NumOfFiles = 0; + int i,NumOfFiles = 0, ListedFiles = 0; FRESULT Fresult = FR_OK; + FileInfo **FilesInfo = (FileInfo**)my_malloc(sizeof(FileInfo *)*(MAX_NUM_OF_FILES)); + FileInfo Data[MAX_NUM_OF_FILES]; - Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER); - Fresult |= f_opendir(&dir, g_cCwdBuf); - if(Fresult != FR_OK) + if (1)//(Semaphore_pend(FFS_Sem, BIOS_NO_WAIT)) { - Semaphore_post(FFS_Sem); - return(Fresult); - } + Fresult |= f_opendir(&dir, g_cCwdBuf); + if(Fresult != FR_OK) + { + Semaphore_post(FFS_Sem); + return(Fresult); + } - memset (fno,0,sizeof(fno)); - FileInfo **FilesInfo = (FileInfo**)my_malloc(sizeof(FileInfo *)*(MAX_NUM_OF_FILES)); - FileInfo Data[MAX_NUM_OF_FILES]; - memset(fno,0,sizeof(fno)); - fno[0] = my_malloc(sizeof(FILINFO)); - memset (fno[0],0,sizeof(FILINFO)); + memset (fno,0,sizeof(fno)); + memset(fno,0,sizeof(fno)); + fno[0] = my_malloc(sizeof(FILINFO)); + memset (fno[0],0,sizeof(FILINFO)); - //============================ - Fresult = f_opendir(&dir, request->path); /* Open the directory */ - if (Fresult == FR_OK) - { - for (NumOfFiles = 1;NumOfFiles < MAX_NUM_OF_FILES;NumOfFiles++) + //============================ + Fresult = f_opendir(&dir, request->path); /* Open the directory */ + if (Fresult == FR_OK) { - fno[NumOfFiles] = my_malloc(sizeof(FILINFO)); - memset (fno[NumOfFiles],0,sizeof(FILINFO)); - Fresult = f_readdir(&dir, fno[NumOfFiles]); /* Read a directory item */ - if (Fresult == FR_OK) + for (NumOfFiles = 1;NumOfFiles < MAX_NUM_OF_FILES;NumOfFiles++) { - if(fno[NumOfFiles]->fname[0] ==0) + fno[NumOfFiles] = my_malloc(sizeof(FILINFO)); + memset (fno[NumOfFiles],0,sizeof(FILINFO)); + Fresult = f_readdir(&dir, fno[NumOfFiles]); /* Read a directory item */ + if (Fresult == FR_OK) { - break; + if(fno[NumOfFiles]->fname[0] ==0) + { + break; + } } } } - } - Semaphore_post(FFS_Sem); + Semaphore_post(FFS_Sem); + } + else + { + Fresult = FR_DENIED; + Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning, (int)0, 0); + } if ((Fresult == FR_OK)&&(NumOfFiles)) { for (i = 0;i < NumOfFiles;i++) { - file_info__init(&Data[i]); - FilesInfo[i] = &Data[i]; - Data[i].has_attribute = true; - Data[i].attribute = fno[i]->fattrib; - Data[i].name = fno[i]->fname; - Data[i].has_length = true; - Data[i].length = fno[i]->fsize; - Data[i].has_lastmodifieddate = true; - Data[i].lastmodifieddate = fno[i]->fdate; - Data[i].has_lastmodifiedtime = true; - Data[i].lastmodifiedtime = fno[i]->ftime; - //Report(Data[i].name, __FILE__, __LINE__, Data[i].lastmodifieddate, RpWarning, (int)Data[i].lastmodifiedtime, 0); - - if (i==0) - usnprintf(&FullPath[i], 50, "%s", request->path); + if (i==0) + usnprintf(&FullPath[ListedFiles], 50, "%s", request->path); + else + if (strlen(request->path)==1) //info under the root + usnprintf(&FullPath[ListedFiles], 50, "%s%s", request->path, fno[i]->fname); + else + usnprintf(&FullPath[ListedFiles], 50, "%s%s%s", request->path,"/", fno[i]->fname); + if (fno[i]->fattrib != 0xFF) //garbage + { + file_info__init(&Data[ListedFiles]); + FilesInfo[ListedFiles] = &Data[ListedFiles]; + Data[ListedFiles].has_attribute = true; + Data[ListedFiles].attribute = fno[i]->fattrib; + Data[ListedFiles].name = fno[i]->fname; + Data[ListedFiles].has_length = true; + Data[ListedFiles].length = fno[i]->fsize; + Data[ListedFiles].has_lastmodifieddate = true; + Data[ListedFiles].lastmodifieddate = fno[i]->fdate; + Data[ListedFiles].has_lastmodifiedtime = true; + Data[ListedFiles].lastmodifiedtime = fno[i]->ftime; + Data[ListedFiles].fullpath = &FullPath[i][0]; + ListedFiles++; + } else - if (strlen(request->path)==1) //info under the root - usnprintf(&FullPath[i], 50, "%s%s", request->path, fno[i]->fname); - else - usnprintf(&FullPath[i], 50, "%s%s%s", request->path,"/", fno[i]->fname); - Data[i].fullpath = &FullPath[i]; + { + // f_unlink(Data[ListedFiles].fullpath); + Report("file system error - format FFS", __FILE__, __LINE__, 255, RpWarning, (int)0, 0); + } + /*RTC_time.tm_year=(fno[i]->fdate>>9)+1980;//populate the time struct (FAT start==1980, RTC.year==0) + RTC_time.tm_mon=(fno[i]->fdate>>5)&0x000F; + RTC_time.tm_mday=fno[i]->fdate&0x001F; + RTC_time.tm_hour=(fno[i]->ftime>>11)&0x001F; + RTC_time.tm_min=(fno[i]->ftime>>5)&0x003F; + RTC_time.tm_sec=(fno[i]->ftime<<1)&0x003E;*/ + } - response.n_items = NumOfFiles; + response.n_items = ListedFiles; response.items = FilesInfo; } else @@ -628,8 +748,9 @@ uint32_t GetFilesRequestFunc(MessageContainer* requestContainer) if (Fresult!= OK) { + responseContainer.has_error = true; responseContainer.error = getErrorCode(Fresult); - responseContainer.errormessage = "File operation error"; + responseContainer.errormessage = "File operation get files error"; } responseContainer.continuous = false; uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); @@ -638,8 +759,10 @@ uint32_t GetFilesRequestFunc(MessageContainer* requestContainer) size_t container_size = message_container__pack(&responseContainer, container_buffer); SendChars(container_buffer, container_size); } - my_free(responseContainer.data.data); - my_free(FilesInfo); + if (responseContainer.data.data) + my_free(responseContainer.data.data); + if (FilesInfo) + my_free(FilesInfo); get_files_request__free_unpacked(request,NULL); for (i = 0;i < NumOfFiles;i++) { @@ -661,27 +784,35 @@ FRESULT FileWrite(void * buffer, uint16_t size,char *path, uint32_t timeout) Fresult = FR_DENIED; else { - if (Semaphore_pend(FFS_Sem, timeout) == false) - { - LOG_ERROR (false,"file system busy error"); - return FR_TIMEOUT; - } - - Fresult = f_open(FileHandle,path,FA_WRITE | FA_OPEN_ALWAYS); - if (Fresult == FR_OK) + if (1)//(Semaphore_pend(FFS_Sem, BIOS_NO_WAIT)) { - Fresult = f_write(FileHandle,buffer,size,&Bytes ); - if(Fresult != FR_OK) + Fresult = f_open(FileHandle,path,FA_WRITE | FA_OPEN_ALWAYS|FA_CREATE_ALWAYS); + if (Fresult == FR_OK) + { + Fresult = f_write(FileHandle,buffer,size,&Bytes ); + if(Fresult != FR_OK) + { + LOG_ERROR (Fresult,"fwrite error"); + } + else + { + //LOG_ERROR (Bytes,"f_write ok no of bytes"); + Report("f_write ok no of bytes", __FILE__, __LINE__, Bytes, RpWarning, (int)size, 0); + } + f_close(FileHandle); + } + else { - LOG_ERROR (Fresult,"fread error"); + LOG_ERROR (Fresult,"fopen error"); } - f_close(FileHandle); + Semaphore_post(FFS_Sem); } else { - LOG_ERROR (Fresult,"fopen error"); + Fresult = FR_DENIED; + Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning, (int)0, 0); } - Semaphore_post(FFS_Sem); + my_free(FileHandle); } } @@ -711,40 +842,50 @@ FRESULT FileRead(char *path, uint32_t *Size, void **Buffer) Fresult = FR_DENIED; else { - Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER); - Fresult = f_open(FileHandle,path,FA_READ); - if (Fresult == FR_OK) + if (1)//(Semaphore_pend(FFS_Sem, BIOS_NO_WAIT)) { - Fresult = f_read(FileHandle,buffer,fno->fsize,&Bytes ); - if(Fresult == FR_OK) + Fresult = f_open(FileHandle,path,FA_READ); + if (Fresult == FR_OK) { - *Buffer = buffer; - *Size = (uint32_t)fno->fsize; + Fresult = f_read(FileHandle,buffer,fno->fsize,&Bytes ); + if(Fresult == FR_OK) + { + *Buffer = buffer; + *Size = (uint32_t)fno->fsize; + Report("f_read ok no of bytes", __FILE__, __LINE__, Bytes, RpWarning, (int)fno->fsize, 0); + } + else + { + LOG_ERROR (Fresult,"fread error"); + my_free (buffer); + } + f_close(FileHandle); } else { - LOG_ERROR (Fresult,"fread error"); + LOG_ERROR (Fresult,"fopen error"); my_free (buffer); } - f_close(FileHandle); Semaphore_post(FFS_Sem); } else { - LOG_ERROR (Fresult,"fopen error"); - my_free (buffer); + Fresult = FR_DENIED; + Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning, (int)0, 0); } my_free(FileHandle); } } else { - LOG_ERROR (Fresult,"malloc error"); + Report("malloc error", __FILE__, __LINE__, Fresult, RpWarning, (int)fno->fsize, 0); + Fresult = FR_DENIED; } } else { - LOG_ERROR (Fresult,"f_stat error"); + Report("f_stat error", __FILE__, __LINE__, Fresult, RpWarning, (int)0, 0); + Fresult = FR_DENIED; } my_free(fno); return Fresult; @@ -766,12 +907,20 @@ FRESULT FileOpen(char *path, uint32_t *Size, FIL *FileHandle) if (FileHandle == 0) Fresult = FR_DENIED; else - Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER); - Fresult = f_open(FileHandle,path,FA_READ); + if (1)//(Semaphore_pend(FFS_Sem, BIOS_NO_WAIT)) + { + Fresult = f_open(FileHandle,path,FA_READ); + Semaphore_post(FFS_Sem); //will be closed with the f_close, in the job + } + else + { + Fresult = FR_DENIED; + Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning, (int)0, 0); + } } else { - LOG_ERROR (Fresult,"f_stat error"); + Report("f_stat error", __FILE__, __LINE__,Fresult, RpWarning, (int)0, 0); } my_free(fno); return Fresult; -- cgit v1.3.1