int fs_slfs_open(const char *pathname, int flags, mode_t mode) { int fd; for (fd = 0; fd < MAX_OPEN_SLFS_FILES; fd++) { if (s_sl_fds[fd].fh <= 0) break; } if (fd >= MAX_OPEN_SLFS_FILES) return set_errno(ENOMEM); struct sl_fd_info *fi = &s_sl_fds[fd]; /* * Apply path manipulations again, in case we got here directly * (via TI libc's "add_device"). */ pathname = drop_dir(pathname, NULL); _u32 am = 0; fi->size = (size_t) -1; int rw = (flags & 3); size_t new_size = FS_SLFS_MAX_FILE_SIZE; if (rw == O_RDONLY) { SlFsFileInfo_t sl_fi; _i32 r = sl_FsGetInfo((const _u8 *) pathname, 0, &sl_fi); if (r == SL_FS_OK) { fi->size = SL_FI_FILE_SIZE(sl_fi); } am = SL_FS_READ; } else { if (!(flags & O_TRUNC) || (flags & O_APPEND)) { // FailFS files cannot be opened for append and will be truncated // when opened for write. return set_errno(ENOTSUP); } if (flags & O_CREAT) { size_t i; for (i = 0; i < MAX_OPEN_SLFS_FILES; i++) { if (s_sl_file_size_hints[i].name != NULL && strcmp(s_sl_file_size_hints[i].name, pathname) == 0) { new_size = s_sl_file_size_hints[i].size; MG_FREE(s_sl_file_size_hints[i].name); s_sl_file_size_hints[i].name = NULL; break; } } am = FS_MODE_OPEN_CREATE(new_size, 0); } else { am = SL_FS_WRITE; } } fi->fh = slfs_open((_u8 *) pathname, am); LOG(LL_DEBUG, ("sl_FsOpen(%s, 0x%x) sz %u = %d", pathname, (int) am, (unsigned int) new_size, (int) fi->fh)); int r; if (fi->fh >= 0) { fi->pos = 0; r = fd; } else { r = set_errno(sl_fs_to_errno(fi->fh)); } return r; }
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; }
int fs_slfs_stat(const char *pathname, struct stat *s) { SlFsFileInfo_t sl_fi; _i32 r = sl_FsGetInfo((const _u8 *) pathname, 0, &sl_fi); if (r == SL_FS_OK) { s->st_mode = S_IFREG | 0666; s->st_nlink = 1; s->st_size = sl_fi.FileLen; return 0; } return set_errno(sl_fs_to_errno(r)); }
int fs_slfs_open(const char *pathname, int flags, mode_t mode) { int fd; for (fd = 0; fd < MAX_OPEN_SLFS_FILES; fd++) { if (s_sl_fds[fd].fh <= 0) break; } if (fd >= MAX_OPEN_SLFS_FILES) return set_errno(ENOMEM); struct sl_fd_info *fi = &s_sl_fds[fd]; _u32 am = 0; fi->size = (size_t) -1; if (pathname[0] == '/') pathname++; int rw = (flags & 3); if (rw == O_RDONLY) { SlFsFileInfo_t sl_fi; _i32 r = sl_FsGetInfo((const _u8 *) pathname, 0, &sl_fi); if (r == SL_FS_OK) { fi->size = sl_fi.FileLen; } am = FS_MODE_OPEN_READ; } else { if (!(flags & O_TRUNC) || (flags & O_APPEND)) { // FailFS files cannot be opened for append and will be truncated // when opened for write. return set_errno(ENOTSUP); } if (flags & O_CREAT) { size_t i, size = FS_SLFS_MAX_FILE_SIZE; for (i = 0; i < MAX_OPEN_SLFS_FILES; i++) { if (s_sl_file_size_hints[i].name != NULL && strcmp(s_sl_file_size_hints[i].name, pathname) == 0) { size = s_sl_file_size_hints[i].size; free(s_sl_file_size_hints[i].name); s_sl_file_size_hints[i].name = NULL; break; } } DBG(("creating %s with max size %d", pathname, (int) size)); am = FS_MODE_OPEN_CREATE(size, 0); } else { am = FS_MODE_OPEN_WRITE; } } _i32 r = sl_FsOpen((_u8 *) pathname, am, NULL, &fi->fh); DBG(("sl_FsOpen(%s, 0x%x) = %d, %d", pathname, (int) am, (int) r, (int) fi->fh)); if (r == SL_FS_OK) { fi->pos = 0; r = fd; } else { fi->fh = -1; r = set_errno(sl_fs_to_errno(r)); } return r; }
int32_t SLFS::open(const uint8_t *filename, int32_t mode) { SlFsFileInfo_t finfo; if (filehandle) { retval = SLFS_LIB_ERR_FILE_ALREADY_OPEN; return retval; } retval = sl_FsOpen((unsigned char*)filename, mode, NULL, &filehandle); if (retval != SL_FS_OK) return retval; offset = 0; filesize = 0; if (mode == FS_MODE_OPEN_READ) { is_write = false; // Discover actual filesize retval = sl_FsGetInfo((unsigned char*)filename, 0, &finfo); if (retval != SL_FS_OK) { sl_FsClose(filehandle, NULL, NULL, 0); filehandle = 0; return retval; } filesize = finfo.FileLen; } else { is_write = true; // Discover maximum file size, store in 'filesize' so we know when to reject writes. retval = sl_FsGetInfo((unsigned char*)filename, 0, &finfo); if (retval != SL_FS_OK) { sl_FsClose(filehandle, NULL, NULL, 0); filehandle = 0; return retval; } filesize = finfo.AllocatedLen; } return retval; }
_i32 fs_delete_container(const char *cpfx, int cidx) { _i32 ret = -1; SlFsFileInfo_t fi; _u8 fname[MAX_FS_CONTAINER_FNAME_LEN]; fs_container_fname(cpfx, cidx, fname); ret = sl_FsGetInfo(fname, 0, &fi); if (ret == 0) { LOG(LL_INFO, ("Deleting %s", fname)); ret = sl_FsDel(fname, 0); } return ret; }
int fs_slfs_stat(const char *pathname, struct stat *s) { SlFsFileInfo_t sl_fi; /* * Apply path manipulations again, in case we got here directly * (via TI libc's "add_device"). */ pathname = drop_dir(pathname, NULL); _i32 r = sl_FsGetInfo((const _u8 *) pathname, 0, &sl_fi); if (r == SL_FS_OK) { s->st_mode = S_IFREG | 0666; s->st_nlink = 1; s->st_size = SL_FI_FILE_SIZE(sl_fi); return 0; } return set_errno(sl_fs_to_errno(r)); }
//***************************************************************************** //! Verifies the integrity of the new application binary //***************************************************************************** static bool bootmgr_verify (_u8 *image) { SlFsFileInfo_t FsFileInfo; _u32 reqlen, offset = 0; _i32 fHandle; // open the file for reading if (0 == sl_FsOpen(image, FS_MODE_OPEN_READ, NULL, &fHandle)) { // get the file size sl_FsGetInfo(image, 0, &FsFileInfo); if (FsFileInfo.FileLen > BOOTMGR_HASH_SIZE) { FsFileInfo.FileLen -= BOOTMGR_HASH_SIZE; CRYPTOHASH_SHAMD5Start(BOOTMGR_HASH_ALGO, FsFileInfo.FileLen); do { if ((FsFileInfo.FileLen - offset) > BOOTMGR_BUFF_SIZE) { reqlen = BOOTMGR_BUFF_SIZE; } else { reqlen = FsFileInfo.FileLen - offset; } offset += sl_FsRead(fHandle, offset, bootmgr_file_buf, reqlen); CRYPTOHASH_SHAMD5Update(bootmgr_file_buf, reqlen); } while (offset < FsFileInfo.FileLen); CRYPTOHASH_SHAMD5Read (bootmgr_file_buf); // convert the resulting hash to hex for (_u32 i = 0; i < (BOOTMGR_HASH_SIZE / 2); i++) { snprintf ((char *)&bootmgr_hash_buf[(i * 2)], 3, "%02x", bootmgr_file_buf[i]); } // read the hash from the file and close it sl_FsRead(fHandle, offset, bootmgr_file_buf, BOOTMGR_HASH_SIZE); sl_FsClose (fHandle, NULL, NULL, 0); bootmgr_file_buf[BOOTMGR_HASH_SIZE] = '\0'; // compare both hashes if (!strcmp((const char *)bootmgr_hash_buf, (const char *)bootmgr_file_buf)) { // it's a match return true; } } // close the file sl_FsClose(fHandle, NULL, NULL, 0); } return false; }
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; }
//***************************************************************************** //! Loads the application from sFlash and executes //***************************************************************************** static void bootmgr_load_and_execute (_u8 *image) { SlFsFileInfo_t pFsFileInfo; _i32 fhandle; // open the application binary if (!sl_FsOpen(image, FS_MODE_OPEN_READ, NULL, &fhandle)) { // get the file size if (!sl_FsGetInfo(image, 0, &pFsFileInfo)) { // read the application into SRAM if (pFsFileInfo.FileLen == sl_FsRead(fhandle, 0, (unsigned char *)APP_IMG_SRAM_OFFSET, pFsFileInfo.FileLen)) { // close the file sl_FsClose(fhandle, 0, 0, 0); // stop the network services sl_Stop(SL_STOP_TIMEOUT); // execute the application bootmgr_run_app(APP_IMG_SRAM_OFFSET); } } } }
int load_image(const char *fn, _u8 *dst) { _i32 fh; SlFsFileInfo_t fi; _i32 r = sl_FsGetInfo((const _u8 *) fn, 0, &fi); dbg_putc(r == 0 ? '+' : '-'); if (r != 0) return r; { char buf[20]; __utoa(fi.FileLen, buf, 10); dbg_puts(buf); } r = sl_FsOpen((const _u8 *) fn, FS_MODE_OPEN_READ, NULL, &fh); dbg_putc(r == 0 ? '+' : '-'); if (r != 0) return r; r = sl_FsRead(fh, 0, dst, fi.FileLen); if (r != fi.FileLen) return r; sl_FsClose(fh, NULL, NULL, 0); return 0; }
static int fs_get_info(const char *cpfx, int cidx, struct fs_container_info *info) { _u8 fname[MAX_FS_CONTAINER_FNAME_LEN]; union fs_container_meta meta; SlFsFileInfo_t fi; _i32 fh; _u32 offset; fs_container_fname(cpfx, cidx, fname); _i32 r = sl_FsGetInfo(fname, 0, &fi); DBG(("finfo %s %d %d %d", fname, (int) r, (int) fi.FileLen, (int) fi.AllocatedLen)); if (r != 0) return r; if (fi.AllocatedLen < sizeof(meta)) return -200; r = sl_FsOpen(fname, FS_MODE_OPEN_READ, NULL, &fh); DBG(("fopen %s %d", fname, (int) r)); if (r != 0) return r; offset = fi.FileLen - sizeof(meta); r = sl_FsRead(fh, offset, (_u8 *) &meta, sizeof(meta)); DBG(("read meta @ %d: %d", (int) offset, (int) r)); if (r != sizeof(meta)) { r = -201; goto out_close; } if (meta.info.seq > FS_INITIAL_SEQ || meta.info.seq == 0 || meta.info.fs_size == ~0UL) { r = -202; goto out_close; } memcpy(info, &meta.info, sizeof(*info)); DBG(("found fs: %llu %d %d %d %d", info->seq, (int) info->fs_size, (int) info->fs_block_size, (int) info->fs_page_size, (int) info->fs_erase_size)); r = 0; out_close: sl_FsClose(fh, NULL, NULL, 0); return r; }
static void FileTest(void) { UART_PRINT("Hello World"); int retVal = 0; long handle; unsigned long token; SlFsFileInfo_t tempInfo; //retVal = sl_FsOpen((unsigned char *)"/www/main.html", FS_MODE_OPEN_READ, &token, &handle); if (retVal == -1) { UART_PRINT("ERROR file open \n\r"); return; } UART_PRINT("file open \n\r"); retVal = sl_FsGetInfo((unsigned char *)&filename, token, &tempInfo); if (retVal == -1) { UART_PRINT("ERROR file info \n\r"); return; } UART_PRINT("file info \n\r"); UART_PRINT("file len: %d", tempInfo.FileLen); retVal = sl_FsClose(handle, NULL, NULL, 0); if (retVal == -1) { UART_PRINT("ERROR file close \n\r"); return; } UART_PRINT("file close \n\r"); }
static int fs_get_info(int cidx, struct fs_info *info) { union fs_meta meta; SlFsFileInfo_t fi; _i32 fh; _u32 offset; _i32 r = sl_FsGetInfo(container_fname(cidx), 0, &fi); dprintf(("finfo %s %d %d %d\n", container_fname(cidx), (int) r, (int) fi.FileLen, (int) fi.AllocatedLen)); if (r != 0) return r; if (fi.AllocatedLen < sizeof(meta)) return -200; r = sl_FsOpen(container_fname(cidx), FS_MODE_OPEN_READ, NULL, &fh); dprintf(("fopen %s %d\n", container_fname(cidx), (int) r)); if (r != 0) return r; offset = fi.FileLen - sizeof(meta); r = sl_FsRead(fh, offset, (_u8 *) &meta, sizeof(meta)); dprintf(("read meta @ %d: %d\n", (int) offset, (int) r)); if (r != sizeof(meta)) { r = -201; goto out_close; } if (meta.info.seq > INITIAL_SEQ || meta.info.fs_size < 0) { r = -202; goto out_close; } memcpy(info, &meta.info, sizeof(*info)); dprintf(("found fs: %llu %d %d %d\n", info->seq, (int) info->fs_size, (int) info->fs_block_size, (int) info->fs_page_size)); r = 0; out_close: sl_FsClose(fh, NULL, NULL, 0); return r; }
/** * Process a static-content HTTP request * This function is called after a request was already initialized, and a Flash content entry was identified during a call to HttpStatic_InitRequest() * This function calls HttpResponse_*() to send the content data to the browser. * @param request Pointer to all data available about the request * @return nonzero if request was handled. zero if not. */ int HttpStatic_ProcessRequest(struct HttpRequest* request) { struct HttpBlob location,contentType; struct HttpBlob* content = (struct HttpBlob*)malloc(sizeof(struct HttpBlob)); unsigned long Offset = 0; SlFsFileInfo_t pFsFileInfo; UINT32 TotalLength; UINT8 HeaderFlag =0; location.pData = NULL; location.uLength = 0; contentType = location; /* if HTTP_REQUEST_FLAG_METHOD_POST==1 (i.e. it is POST) HttpResponse_CannedError() responds to client with status HTTP_STATUS_ERROR_INTERNAL POST method is not supported for static pages */ if (request->uFlags & HTTP_REQUEST_FLAG_METHOD_POST) { /* HttpResponse_CannedError responds to client with 500 ERROR_INTERNAL */ if(!HttpResponse_CannedError(request->uConnection, HTTP_STATUS_ERROR_INTERNAL)) return 0; else return 1; } //sl_FsGetInfo((unsigned char *)g_cFileName, NULL, &pFsFileInfo); sl_FsGetInfo((unsigned char *)g_cFileName, 0, &pFsFileInfo); TotalLength = (&pFsFileInfo)->FileLen; while(TotalLength > 0) { content->uLength = ((TotalLength < 1000) ? (TotalLength):(1000)); UINT8* (buffer) = (UINT8*)malloc(content->uLength); content->pData = buffer; /* if got here than it is a GET method HttpResponse_Headers() responds to client with status HTTP_STATUS_OK */ if(sl_FsRead(glFileHandle, Offset, (unsigned char *) content->pData, content->uLength) < 0) { /* call HttpResponse_CannedError responds to client with 500 ERROR_INTERNAL */ if(!HttpResponse_CannedError( request->uConnection, HTTP_STATUS_ERROR_NOT_ACCEPTED)) return 0; else return 1; } else { if(!HeaderFlag) { if(!HttpResponse_Headers( request->uConnection, HTTP_STATUS_OK, 0, TotalLength, contentType, location)) return 0; HeaderFlag = 1; } /* HttpResponse_Content() sends requested page to the client */ if(!HttpResponse_Content(request->uConnection, *content)) return 0; } TotalLength -= content->uLength; Offset += content->uLength; free(buffer); } sl_FsClose(glFileHandle,0,0,0); free(content); return 1; }
int ComputeSHA(const char *sourceFile, uint8_t *resultHash) { long sfileHandle = -1; unsigned long sToken = 0; long retVal = 0; unsigned long bytesRead = 0; unsigned long readsize = 0; uint8_t buffer[BLOCKSIZE]; SlFsFileInfo_t sFileInfo; UART_PRINT("\r\nStarted comuting hash\r\n"); //Enable MD5SHA module PRCMPeripheralClkEnable(PRCM_DTHE, PRCM_RUN_MODE_CLK); MAP_SHAMD5IntRegister(SHAMD5_BASE, SHAMD5IntHandler); //reset modul PRCMPeripheralReset(PRCM_DTHE); //clear flags g_bContextReadyFlag = false; g_bInputReadyFlag = false; //Enable Interrupts SHAMD5IntEnable(SHAMD5_BASE, SHAMD5_INT_CONTEXT_READY | SHAMD5_INT_PARTHASH_READY | SHAMD5_INT_INPUT_READY | SHAMD5_INT_OUTPUT_READY); //wait for context ready flag. while (!g_bContextReadyFlag) ; //Configure SHA/MD5 module SHAMD5ConfigSet(SHAMD5_BASE, SHAMD5_ALGO_SHA1); // get file size retVal = sl_FsGetInfo((unsigned char *) sourceFile, sToken, &sFileInfo); if (retVal < 0) { // File Doesn't exit create a new of 45 KB file UART_PRINT("Error during opening the source file\r\n"); return -1; } // open the source file for reading retVal = sl_FsOpen((unsigned char *) sourceFile, FS_MODE_OPEN_READ, &sToken, &sfileHandle); if (retVal < 0) { UART_PRINT("Error during opening the source file\r\n"); return -1; } SHAMD5DataLengthSet(SHAMD5_BASE, (uint32_t) sFileInfo.FileLen); // Copy the files from temporary file to original file // If user file has checksum which can be used to verify the temporary // file then file should be verified before copying while (bytesRead < sFileInfo.FileLen) { if ((sFileInfo.FileLen - bytesRead) > BLOCKSIZE) readsize = BLOCKSIZE; else readsize = (sFileInfo.FileLen - bytesRead); memset(buffer, 0, sizeof(buffer)); retVal = sl_FsRead(sfileHandle, bytesRead, (unsigned char *) buffer, readsize); if (retVal < 0) { // Error close the file and delete the temporary file retVal = sl_FsClose(sfileHandle, 0, 0, 0); UART_PRINT("Error during reading the file\r\n"); return -1; } SHAMD5DataWrite(SHAMD5_BASE, buffer); bytesRead += readsize; } // Close the opened files retVal = sl_FsClose(sfileHandle, 0, 0, 0); if (retVal < 0) { // Error close the file and delete the temporary file UART_PRINT("Error during close the file\r\n"); return -1; } UART_PRINT("Hash successfully\r\n"); SHAMD5ResultRead(SHAMD5_BASE, resultHash); return 0; }
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(); }