DRESULT sflash_disk_init (void) { _i32 fileHandle; SlFsFileInfo_t FsFileInfo; if (!sflash_init_done) { // Allocate space for the block cache ASSERT ((sflash_block_cache = mem_Malloc(SFLASH_BLOCK_SIZE)) != NULL); sflash_init_done = true; sflash_prblock = UINT32_MAX; sflash_cache_is_dirty = false; // In order too speed up booting, check the last block, if exists, then // it means that the file system has been already created print_block_name (SFLASH_BLOCK_COUNT - 1); sl_LockObjLock (&wlan_LockObj, SL_OS_WAIT_FOREVER); if (!sl_FsGetInfo(sflash_block_name, 0, &FsFileInfo)) { sl_LockObjUnlock (&wlan_LockObj); return RES_OK; } sl_LockObjUnlock (&wlan_LockObj); // Proceed to format the memory for (int i = 0; i < SFLASH_BLOCK_COUNT; i++) { print_block_name (i); sl_LockObjLock (&wlan_LockObj, SL_OS_WAIT_FOREVER); // Create the block file if it doesn't exist if (sl_FsGetInfo(sflash_block_name, 0, &FsFileInfo) != 0) { if (!sl_FsOpen(sflash_block_name, FS_MODE_OPEN_CREATE(SFLASH_BLOCK_SIZE, 0), NULL, &fileHandle)) { sl_FsClose(fileHandle, NULL, NULL, 0); sl_LockObjUnlock (&wlan_LockObj); memset(sflash_block_cache, 0xFF, SFLASH_BLOCK_SIZE); if (!sflash_access(FS_MODE_OPEN_WRITE, sl_FsWrite)) { return RES_ERROR; } } else { // Unexpected failure while creating the file sl_LockObjUnlock (&wlan_LockObj); return RES_ERROR; } } sl_LockObjUnlock (&wlan_LockObj); } } return RES_OK; }
bool updater_start (void) { _u32 AccessModeAndMaxSize = FS_MODE_OPEN_WRITE; SlFsFileInfo_t FsFileInfo; bool result = false; sl_LockObjLock (&wlan_LockObj, SL_OS_WAIT_FOREVER); if (0 != sl_FsGetInfo((_u8 *)updater_data.path, 0, &FsFileInfo)) { // file doesn't exist, create it AccessModeAndMaxSize = FS_MODE_OPEN_CREATE(updater_data.fsize, 0); } if (!sl_FsOpen((_u8 *)updater_data.path, AccessModeAndMaxSize, NULL, &updater_data.fhandle)) { updater_data.foffset = 0; result = true; } sl_LockObjUnlock (&wlan_LockObj); return result; }
_i32 sl_extlib_FlcOpenFile(_u8 *file_name, _i32 file_size, _u32 *ulToken, _i32 *lFileHandle, _i32 open_flags) { char uclocalFilename[100]; if(open_flags == _FS_MODE_OPEN_READ) { return sl_FsOpen((_u8 *)file_name, _FS_MODE_OPEN_READ, ulToken, lFileHandle); } else { /* MCU image name should be changed */ if(strstr((char *)file_name, "/sys/mcuimgA") != NULL) { switch(_McuImageGetNewIndex()) { case IMG_ACT_USER1: strcpy(uclocalFilename,IMG_USER_1); break; case IMG_ACT_USER2: strcpy(uclocalFilename,IMG_USER_2); break; } /* make sure that the file is not opened as fail-safe since it might fill the entire SFLASH and it is not required for the MCU image */ open_flags &= ~_FS_FILE_OPEN_FLAG_COMMIT; Report("sl_extlib_FlcOpenFile: MCU image" "name converted to %s \r\n", uclocalFilename); } else { strcpy(uclocalFilename,(char *)file_name); } return sl_FsOpen((_u8 *)uclocalFilename, FS_MODE_OPEN_CREATE(file_size, open_flags), ulToken, lFileHandle); } }
//**************************************************************************** // //! \brief Obtain the file from the server //! //! This function requests the file from the server and save it on serial flash. //! To request a different file for different user needs to modify the //! PREFIX_BUFFER macros. //! //! \param[in] cli - Instance of the HTTP connection //! //! \return 0 for success and negative for error // //**************************************************************************** static int GetData(HTTPCli_Handle cli) { long lRetVal = 0; long fileHandle = -1; unsigned long Token = 0; int id; int len=0; bool moreFlag = 0; HTTPCli_Field fields[3] = { {HTTPCli_FIELD_NAME_HOST, HOST_NAME}, {HTTPCli_FIELD_NAME_ACCEPT, "text/html, application/xhtml+xml, */*"}, {NULL, NULL} }; const char *ids[4] = { HTTPCli_FIELD_NAME_CONTENT_LENGTH, HTTPCli_FIELD_NAME_TRANSFER_ENCODING, HTTPCli_FIELD_NAME_CONNECTION, NULL }; UART_PRINT("Start downloading the file\r\n"); // Set request fields HTTPCli_setRequestFields(cli, fields); memset(g_buff, 0, sizeof(g_buff)); // Make HTTP 1.1 GET request lRetVal = HTTPCli_sendRequest(cli, HTTPCli_METHOD_GET, PREFIX_BUFFER, 0); if (lRetVal < 0) { // error ASSERT_ON_ERROR(TCP_SEND_ERROR); } // Test getResponseStatus: handle lRetVal = HTTPCli_getResponseStatus(cli); if (lRetVal != 200) { FlushHTTPResponse(cli); if(lRetVal == 404) { ASSERT_ON_ERROR(FILE_NOT_FOUND_ERROR); } ASSERT_ON_ERROR(INVALID_SERVER_RESPONSE); } HTTPCli_setResponseFields(cli, ids); // Read response headers while ((id = HTTPCli_getResponseField(cli, (char *)g_buff, sizeof(g_buff), &moreFlag)) != HTTPCli_FIELD_ID_END) { if(id == 0) { UART_PRINT("Content length: %s\n\r", g_buff); } else if(id == 1) { if(!strncmp((const char *)g_buff, "chunked", sizeof("chunked"))) { UART_PRINT("Chunked transfer encoding\n\r"); } } else if(id == 2) { if(!strncmp((const char *)g_buff, "close", sizeof("close"))) { ASSERT_ON_ERROR(FORMAT_NOT_SUPPORTED); } } } // Open file to save the downloaded file lRetVal = sl_FsOpen((_u8 *)FILE_NAME, FS_MODE_OPEN_WRITE, &Token, &fileHandle); if(lRetVal < 0) { // File Doesn't exit create a new of 40 KB file lRetVal = sl_FsOpen((unsigned char *)FILE_NAME, \ FS_MODE_OPEN_CREATE(SIZE_40K, \ _FS_FILE_OPEN_FLAG_COMMIT|_FS_FILE_PUBLIC_WRITE), &Token, &fileHandle); ASSERT_ON_ERROR(lRetVal); } while(1) { len = HTTPCli_readResponseBody(cli, (char *)g_buff, sizeof(g_buff) - 1, &moreFlag); if(len < 0) { // Close file without saving lRetVal = sl_FsClose(fileHandle, 0, (unsigned char*) "A", 1); return lRetVal; } lRetVal = sl_FsWrite(fileHandle, bytesReceived, (unsigned char *)g_buff, len); if(lRetVal < len) { UART_PRINT("Failed during writing the file, Error-code: %d\r\n", \ FILE_WRITE_ERROR); // Close file without saving lRetVal = sl_FsClose(fileHandle, 0, (unsigned char*) "A", 1); return lRetVal; } bytesReceived +=len; if ((len - 2) >= 0 && g_buff[len - 2] == '\r' && g_buff [len - 1] == '\n'){ break; } if(!moreFlag) { break; } } // // If user file has checksum which can be used to verify the temporary // file then file should be verified // In case of invalid file (FILE_NAME) should be closed without saving to // recover the previous version of file // // Save and close file UART_PRINT("Total bytes received: %d\n\r", bytesReceived); lRetVal = sl_FsClose(fileHandle, 0, 0, 0); ASSERT_ON_ERROR(lRetVal); return SUCCESS; }
//***************************************************************************** // //! This funtion includes the following steps: //! -open a user file for writing //! -write "Old MacDonalds" child song 37 times to get just below a 64KB file //! -close the user file //! //! /param[out] ulToken : file token //! /param[out] lFileHandle : file handle //! //! /return 0:Success, -ve: failure // //***************************************************************************** long WriteFileToDevice(unsigned long *ulToken, long *lFileHandle) { long lRetVal = -1; int iLoopCnt = 0; // // create a user file // lRetVal = sl_FsOpen((unsigned char *)USER_FILE_NAME, FS_MODE_OPEN_CREATE(65536, \ _FS_FILE_OPEN_FLAG_COMMIT|_FS_FILE_PUBLIC_WRITE), ulToken, lFileHandle); if(lRetVal < 0) { // // File may already be created // lRetVal = sl_FsClose(*lFileHandle, 0, 0, 0); ASSERT_ON_ERROR(lRetVal); } else { // // close the user file // lRetVal = sl_FsClose(*lFileHandle, 0, 0, 0); if (SL_RET_CODE_OK != lRetVal) { ASSERT_ON_ERROR(FILE_CLOSE_ERROR); } } // // open a user file for writing // lRetVal = sl_FsOpen((unsigned char *)USER_FILE_NAME, FS_MODE_OPEN_WRITE, ulToken, lFileHandle); if(lRetVal < 0) { lRetVal = sl_FsClose(*lFileHandle, 0, 0, 0); ASSERT_ON_ERROR(FILE_OPEN_WRITE_FAILED); } // // write "Old MacDonalds" child song as many times to get just below a 64KB file // for (iLoopCnt = 0; iLoopCnt < (SL_MAX_FILE_SIZE / sizeof(gaucOldMacDonald)); iLoopCnt++) { lRetVal = sl_FsWrite(*lFileHandle, (unsigned int)(iLoopCnt * sizeof(gaucOldMacDonald)), (unsigned char *)gaucOldMacDonald, sizeof(gaucOldMacDonald)); if (lRetVal < 0) { lRetVal = sl_FsClose(*lFileHandle, 0, 0, 0); ASSERT_ON_ERROR(FILE_WRITE_FAILED); } } // // close the user file // lRetVal = sl_FsClose(*lFileHandle, 0, 0, 0); if (SL_RET_CODE_OK != lRetVal) { ASSERT_ON_ERROR(FILE_CLOSE_ERROR); } return SUCCESS; }
short saveConfig() { long status = 0; long configFile = -1; UART_PRINT("[Blink] Saving configuration\r\n"); status = sl_FsOpen((unsigned char *) CONFIG_FILENAME, FS_MODE_OPEN_CREATE(65536, _FS_FILE_OPEN_FLAG_COMMIT | _FS_FILE_PUBLIC_WRITE), NULL, &configFile); if (status < 0) { ERR_PRINT(status); if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) { UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n"); } return status; } sl_FsClose(configFile, 0, 0, 0); configFile = -1; status = sl_FsOpen((unsigned char *) CONFIG_FILENAME, FS_MODE_OPEN_WRITE, NULL, &configFile); if (status < 0) { ERR_PRINT(status); if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) { UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n"); } sl_FsClose(configFile, 0, 0, 0); return status; } UART_PRINT("[Blink] Application Id : %s\r\n", g_ApplicationID); long readOffset = 0; status = sl_FsWrite(configFile, readOffset, (unsigned char *)g_ApplicationID, sizeof(g_ApplicationID)); if (status < 0) { ERR_PRINT(status); if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) { UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n"); } sl_FsClose(configFile, 0, 0, 0); return status; } UART_PRINT("[Blink] Client key : %s\r\n", g_ClientKey); readOffset = readOffset + status; status = sl_FsWrite(configFile, readOffset, (unsigned char *)g_ClientKey, sizeof(g_ClientKey)); if (status < 0) { ERR_PRINT(status); if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) { UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n"); } sl_FsClose(configFile, 0, 0, 0); return status; } UART_PRINT("[Blink] Installation Id : %s\r\n", g_InstallationID); readOffset = readOffset + status; status = sl_FsWrite(configFile, readOffset, (unsigned char *)g_InstallationID, sizeof(g_InstallationID)); if (status < 0) { ERR_PRINT(status); if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) { UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n"); } sl_FsClose(configFile, 0, 0, 0); return status; } UART_PRINT("[Blink] Session token : %s\r\n", g_SessionToken); readOffset = readOffset + status; status = sl_FsWrite(configFile, readOffset, (unsigned char *)g_SessionToken, sizeof(g_SessionToken)); if (status < 0) { ERR_PRINT(status); if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) { UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n"); } sl_FsClose(configFile, 0, 0, 0); return status; } UART_PRINT("[Blink] Device name : %s\r\n", g_DeviceName); readOffset = readOffset + status; status = sl_FsWrite(configFile, readOffset, (unsigned char *)g_DeviceName, sizeof(g_DeviceName)); if (status < 0) { ERR_PRINT(status); if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) { UART_PRINT("[Blink] No available blocks. Need to flash your device file system...\r\n"); } sl_FsClose(configFile, 0, 0, 0); return status; } sl_FsClose(configFile, 0, 0, 0); return status; }
static void TFTPTask(void *pvParameters) { SlSecParams_t secParams; unsigned char *pucFileBuffer = NULL; // Data read or to be written unsigned long uiFileSize; const char *FileRead = "readFromServer.txt"; // File to be read using TFTP. Change string to filename const char *FileWrite = "writeToServer.txt"; // File to be written using TFTP. Change string to filename. long pFileHandle; // Pointer to file handle SlFsFileInfo_t pFsFileInfo; long lRetVal = -1; unsigned short uiTftpErrCode; //get wifi information // get_wifi_info(ap_ssid, secPrams); // Configuring security parameters for the AP secParams.Key = (_i8*)SSID_KEY; secParams.KeyLen = 30; secParams.Type = SL_SEC_TYPE_WPA_WPA2; lRetVal = Network_IF_InitDriver(ROLE_STA); // Connecting to WLAN AP - Set with static parameters defined at the top // After this call we will be connected and have IP address lRetVal = Network_IF_ConnectAP((char*)SSID,secParams); UART_PRINT("Connecting to TFTP server %d.%d.%d.%d\n\r",\ SL_IPV4_BYTE(TFTP_IP, 3),SL_IPV4_BYTE(TFTP_IP, 2), SL_IPV4_BYTE(TFTP_IP, 1),SL_IPV4_BYTE(TFTP_IP, 0)); if(TFTP_READ) { uiFileSize = FILE_SIZE_MAX; pucFileBuffer = new unsigned char[uiFileSize]; if(NULL == pucFileBuffer) { UART_PRINT("Can't Allocate Resources\r\n"); LOOP_FOREVER(); } memset(pucFileBuffer,'\0',uiFileSize); lRetVal = sl_TftpRecv(TFTP_IP, FileRead, (char *)pucFileBuffer,\ &uiFileSize, &uiTftpErrCode ); UART_PRINT("file read is %s\n", pucFileBuffer); if(lRetVal < 0) { free(pucFileBuffer); ERR_PRINT(lRetVal); LOOP_FOREVER(); } lRetVal = sl_FsGetInfo((unsigned char *)FileRead, 0, &pFsFileInfo); if(lRetVal < 0 ) lRetVal = sl_FsOpen((unsigned char *)FileRead,\ FS_MODE_OPEN_CREATE(FILE_SIZE_MAX,_FS_FILE_OPEN_FLAG_COMMIT|\ _FS_FILE_PUBLIC_WRITE), NULL,&pFileHandle); else lRetVal = sl_FsOpen((unsigned char *)FileRead,FS_MODE_OPEN_WRITE, \ NULL,&pFileHandle); if(lRetVal < 0) { free(pucFileBuffer); ERR_PRINT(lRetVal); LOOP_FOREVER(); } lRetVal = sl_FsWrite(pFileHandle,0, pucFileBuffer, uiFileSize); if(lRetVal < 0) { free(pucFileBuffer); lRetVal = sl_FsClose(pFileHandle,0,0,0); ERR_PRINT(lRetVal); LOOP_FOREVER(); } UART_PRINT("TFTP Read Successful \r\n"); lRetVal = sl_FsClose(pFileHandle,0,0,0); } if(TFTP_WRITE) { /* open same file which has been written with the server's file content */ lRetVal = sl_FsOpen((unsigned char *)FileRead,FS_MODE_OPEN_READ, \ NULL,&pFileHandle); if(lRetVal < 0) { free(pucFileBuffer); ERR_PRINT(lRetVal); LOOP_FOREVER(); } lRetVal = sl_FsGetInfo((unsigned char *)FileRead, 0, &pFsFileInfo); if(lRetVal < 0) { lRetVal = sl_FsClose(pFileHandle,0,0,0); free(pucFileBuffer); ERR_PRINT(lRetVal); LOOP_FOREVER(); } uiFileSize = (&pFsFileInfo)->FileLen; lRetVal = sl_FsRead(pFileHandle, 0, pucFileBuffer, uiFileSize); if(lRetVal < 0) { lRetVal = sl_FsClose(pFileHandle,0,0,0); free(pucFileBuffer); ERR_PRINT(lRetVal); LOOP_FOREVER(); } lRetVal = sl_FsClose(pFileHandle,0,0,0); /* write to server with different file name */ lRetVal = sl_TftpSend(TFTP_IP, FileWrite,(char *) pucFileBuffer,\ &uiFileSize, &uiTftpErrCode ); if(lRetVal < 0) { free(pucFileBuffer); ERR_PRINT(lRetVal); LOOP_FOREVER(); } UART_PRINT("TFTP Write Successful \r\n"); } LOOP_FOREVER(); }
short saveClientState(ParseClientInternal *parseClient) { #ifdef CLIENT_DEBUG DEBUG_PRINT("[Parse] Saving client state\r\n"); #endif /* CLIENT_DEBUG */ snprintf(clientStateFileName, CLIENT_STATE_FILENAME_LEN, CLIENT_STATE_FILENAME, parseClient->applicationId); long clientStateFile = -1; sl_FsDel((unsigned char *)clientStateFileName, 0); short status = sl_FsOpen((unsigned char *)clientStateFileName, FS_MODE_OPEN_CREATE(65536, _FS_FILE_OPEN_FLAG_COMMIT | _FS_FILE_PUBLIC_WRITE), NULL, &clientStateFile); if (status < 0) { #ifdef CLIENT_DEBUG if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) { DEBUG_PRINT("[Parse] No available blocks. Need to flash your device file system...\r\n"); } #endif /* CLIENT_DEBUG */ return status; } sl_FsClose(clientStateFile, 0, 0, 0); clientStateFile = -1; status = sl_FsOpen((unsigned char *)clientStateFileName, FS_MODE_OPEN_WRITE, NULL, &clientStateFile); if (status < 0) { #ifdef CLIENT_DEBUG if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) { DEBUG_PRINT("[Parse] No available blocks. Need to flash your device file system...\r\n"); } #endif /* CLIENT_DEBUG */ sl_FsClose(clientStateFile, 0, 0, 0); return status; } #ifdef CLIENT_DEBUG DEBUG_PRINT("[Parse] Installation Id: %s\r\n", parseClient->installationId); #endif /* CLIENT_DEBUG */ long writeOffset = 0; status = sl_FsWrite(clientStateFile, writeOffset, (unsigned char *)parseClient->installationId, sizeof(parseClient->installationId)); if (status < 0) { #ifdef CLIENT_DEBUG if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) { DEBUG_PRINT("[Parse] No available blocks. Need to flash your device file system...\r\n"); } #endif /* CLIENT_DEBUG */ sl_FsClose(clientStateFile, 0, 0, 0); return status; } #ifdef CLIENT_DEBUG DEBUG_PRINT("[Parse] Session token: %s\r\n", parseClient->sessionToken); #endif /* CLIENT_DEBUG */ writeOffset = writeOffset + status; status = sl_FsWrite(clientStateFile, writeOffset, (unsigned char *)parseClient->sessionToken, sizeof(parseClient->sessionToken)); if (status < 0) { #ifdef CLIENT_DEBUG if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) { DEBUG_PRINT("[Parse] No available blocks. Need to flash your device file system...\r\n"); } #endif /* CLIENT_DEBUG */ sl_FsClose(clientStateFile, 0, 0, 0); return status; } #ifdef CLIENT_DEBUG DEBUG_PRINT("[Parse] Last push hash: %s\r\n", parseClient->lastPushHash); #endif /* CLIENT_DEBUG */ writeOffset = writeOffset + status; status = sl_FsWrite(clientStateFile, writeOffset, (unsigned char *)parseClient->lastPushHash, sizeof(parseClient->lastPushHash)); if (status < 0) { #ifdef CLIENT_DEBUG if (status == SL_FS_ERR_NO_AVAILABLE_BLOCKS) { DEBUG_PRINT("[Parse] No available blocks. Need to flash your device file system...\r\n"); } #endif /* CLIENT_DEBUG */ sl_FsClose(clientStateFile, 0, 0, 0); return status; } sl_FsClose(clientStateFile, 0, 0, 0); return status; }
int GetFileFromServer(const int socket, const char* filename, const char* filenameInFlash) { int transfer_len = 0; long retVal = 0; long fileHandle = -1; unsigned long Token = 0, bytesReceived = 0; unsigned char *pBuff = 0; unsigned long file_size = 0; unsigned char buffer[MAX_BUFF_SIZE + 1]; UART_PRINT("Start downloading the file %s\r\n", filename); memset(buffer, 0, sizeof(buffer)); // Puts together the HTTP GET string. strcpy((char *) buffer, PREFIX_BUFFER); strcat((char *) buffer, filename); strcat((char *) buffer, POST_BUFFER); // Send the HTTP GET string to the opened TCP/IP socket. transfer_len = sl_Send(socket, buffer, strlen((const char *) buffer), 0); if (transfer_len < 0) { // error UART_PRINT("Socket Send Error\r\n"); return -1; } memset(buffer, 0, sizeof(buffer)); // get the reply from the server in buffer. transfer_len = sl_Recv(socket, buffer, MAX_BUFF_SIZE, 0); if (transfer_len > 0) { // Check for 404 return code if (strstr((const char *) buffer, HTTP_FILE_NOT_FOUND) != 0) { UART_PRINT("File not found, check the file and try again\r\n"); return -1; } // if not "200 OK" return error if (strstr((const char *) buffer, HTTP_STATUS_OK) == 0) { UART_PRINT("Error during downloading the file\r\n"); return -1; } // check if content length is transfered with headers pBuff = (unsigned char *) strstr((const char *) buffer, HTTP_CONTENT_LENGTH); if (pBuff != 0) { pBuff += strlen(HTTP_CONTENT_LENGTH); while (*pBuff != 0x0d) pBuff++; unsigned long multiplicant = 1; pBuff--; while (*pBuff != ' ') { file_size += (*pBuff - '0') * multiplicant; multiplicant *= 10; pBuff--; } if (file_size == 0) { UART_PRINT("\nContent Length not detected.\r\n"); return -1; } UART_PRINT("Content Length %d\r\n", file_size); } else { UART_PRINT("\nContent Length not detected.\r\n"); return -1; } // "\r\n\r\n" marks the end of headers pBuff = (unsigned char *) strstr((const char *) buffer, HTTP_END_OF_HEADER); if (pBuff == 0) { UART_PRINT("Invalid response\r\n"); return -1; } // Increment by 4 to skip "\r\n\r\n" pBuff += 4; // Adjust buffer data length for header size transfer_len -= (pBuff - buffer); } // Delete eventually existing temporary file sl_FsDel((unsigned char *) filenameInFlash, Token); // Create a temporary file to save the downloaded file // open a user file for writing retVal = sl_FsOpen((unsigned char *) filenameInFlash, FS_MODE_OPEN_WRITE, &Token, &fileHandle); if (retVal < 0) { // File Doesn't exit create a new of file_size KB file retVal = sl_FsOpen((unsigned char *) filenameInFlash, FS_MODE_OPEN_CREATE(file_size, _FS_FILE_PUBLIC_WRITE), &Token, &fileHandle); if (retVal < 0) { UART_PRINT("Error during opening the temporary file\r\n"); return -1; } } while (bytesReceived < file_size) { retVal = sl_FsWrite(fileHandle, bytesReceived, (unsigned char *) pBuff, transfer_len); if (retVal < 0) { retVal = sl_FsClose(fileHandle, 0, 0, 0); retVal = sl_FsDel((unsigned char *) filenameInFlash, Token); UART_PRINT("Error during writing the file\r\n"); return -1; } bytesReceived += transfer_len; if (bytesReceived == file_size) break; memset(buffer, 0, sizeof(buffer)); transfer_len = sl_Recv(socket, buffer, MAX_BUFF_SIZE, 0); pBuff = buffer; } // Close the opened file retVal = sl_FsClose(fileHandle, 0, 0, 0); if (bytesReceived != file_size) { UART_PRINT("Error While File Download\r\n"); retVal = sl_FsDel((unsigned char *) filenameInFlash, Token); return -1; } else { UART_PRINT("\nDownloading File Completed\r\n"); } return 0; }