MERGE

1 files changed, 138 insertions, 78 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
index 3b5ba176d..6715e8e42 100644
--- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
@@ -89,7 +89,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));
@@ -132,9 +135,10 @@ uint32_t    FileUploadRequestFunc(MessageContainer* requestContainer)
         }
     }
 
-    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";
     }
@@ -170,9 +174,17 @@ uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer)
     //{
     //Control_WD(ENABLE,55);  //activate heaters/dispenser watchdog, 0.5 seconds
     //GeneralHwReady = false;
-    KeepAliveOneSecondCounter = 0;
-    save_milisec = msec_millisecondCounter;
-    Fresult = f_write(ReceivedFileHandle,request->buffer.data,request->buffer.len,&WrittenBytes );
+    if (ReceivedFileHandle==NULL)
+    {
+        Fresult = FR_DENIED;
+        Report("file chunk uplad rejected - file not created", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
+        FileDone = true;
+    }
+    else
+    {
+        KeepAliveOneSecondCounter = 0;
+        save_milisec = msec_millisecondCounter;
+        Fresult = f_write(ReceivedFileHandle,request->buffer.data,request->buffer.len,&WrittenBytes );
         lFresult = Fresult;
         if(Fresult != FR_OK)
         {
@@ -207,18 +219,12 @@ 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";
     }
@@ -296,6 +302,11 @@ uint32_t    FileDownloadRequestFunc(MessageContainer* requestContainer)
                     Semaphore_post(FFS_Sem);
                 }
             }
+            else
+            {
+                Fresult = FR_DENIED;
+                Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
+            }
         }
     }
 
@@ -303,6 +314,7 @@ 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";
     }
@@ -367,6 +379,7 @@ 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";
     }
@@ -394,6 +407,7 @@ 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";
     }
@@ -420,6 +434,7 @@ 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";
     }
@@ -453,16 +468,23 @@ 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 (Semaphore_pend(FFS_Sem, BIOS_NO_WAIT))
             {
-                if (f_close (UploadFileHandle)!= FR_OK)
+                Fresult = f_open(UploadFileHandle,request->path,FA_CREATE_NEW);
+                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)
@@ -476,6 +498,7 @@ 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";
     }
@@ -502,15 +525,23 @@ 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);
+    if (Semaphore_pend(FFS_Sem, BIOS_NO_WAIT))
+    {
+        Fresult = f_unlink(request->path);
+        Semaphore_post(FFS_Sem);
+    }
+    else
+    {
+        Fresult = FR_DENIED;
+        Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
+    }
 
     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)
     {
         usnprintf(ErrorMsg, 100, "File Operation failed error code %d",Fresult);
+        responseContainer.has_error = true;
         responseContainer.error = getErrorCode(Fresult);
         responseContainer.errormessage = ErrorMsg;
     }
@@ -557,6 +588,7 @@ 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";
     }
@@ -587,6 +619,8 @@ uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
     char FullPath[MAX_NUM_OF_FILES][60];
     int i,NumOfFiles = 0;
     FRESULT Fresult = FR_OK;
+    FileInfo **FilesInfo = (FileInfo**)my_malloc(sizeof(FileInfo *)*(MAX_NUM_OF_FILES));
+    FileInfo Data[MAX_NUM_OF_FILES];
     /*
     time_t t;
     struct tm *ltm;
@@ -597,40 +631,45 @@ uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
     Report(curTime, __FILE__, ltm->tm_hour,ltm->tm_min , RpWarning,  ltm->tm_sec, 0);
      */
 
-    Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER);
-    Fresult |= f_opendir(&dir, g_cCwdBuf);
-    if(Fresult != FR_OK)
+    if (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))
     {
@@ -678,6 +717,7 @@ uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
 
     if (Fresult!= OK)
     {
+        responseContainer.has_error = true;
         responseContainer.error = getErrorCode(Fresult);
         responseContainer.errormessage = "File operation error";
     }
@@ -688,8 +728,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++)
     {
@@ -711,29 +753,32 @@ 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|FA_CREATE_ALWAYS);
-            if (Fresult == FR_OK)
+            if (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");
+                    }
+                    //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,"fwrite error");
+                    LOG_ERROR (Fresult,"fopen error");
                 }
-                //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);
+                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);
         }
     }
@@ -763,29 +808,36 @@ 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 (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;
-                        Report("f_read ok no of bytes", __FILE__, __LINE__, Bytes, RpWarning,   (int)fno->fsize, 0);
+                        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);
             }
@@ -819,8 +871,16 @@ 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 (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
     {