/* | |
* FreeRTOS+FAT build 191128 - Note: FreeRTOS+FAT is still in the lab! | |
* Copyright (C) 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. | |
* Authors include James Walmsley, Hein Tibosch and Richard Barry | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy of | |
* this software and associated documentation files (the "Software"), to deal in | |
* the Software without restriction, including without limitation the rights to | |
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of | |
* the Software, and to permit persons to whom the Software is furnished to do so, | |
* subject to the following conditions: | |
* | |
* The above copyright notice and this permission notice shall be included in all | |
* copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS | |
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR | |
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER | |
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
* | |
* https://www.FreeRTOS.org | |
* | |
*/ | |
/** | |
* @file ff_file.c | |
* @ingroup FILEIO | |
* | |
* @defgroup FILEIO FILE I/O Access | |
* @brief Provides an interface to allow File I/O on a mounted IOMAN. | |
* | |
* Provides file-system interfaces for the FAT file-system. | |
**/ | |
#include "ff_headers.h" | |
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) | |
#include <wchar.h> | |
#endif | |
static FF_Error_t FF_Truncate( FF_FILE *pxFile, BaseType_t bClosing ); | |
static int32_t FF_ReadPartial( FF_FILE *pxFile, uint32_t ulItemLBA, uint32_t ulRelBlockPos, uint32_t ulCount, | |
uint8_t *pucBuffer, FF_Error_t *pxError ); | |
static int32_t FF_WritePartial( FF_FILE *pxFile, uint32_t ulItemLBA, uint32_t ulRelBlockPos, uint32_t ulCount, | |
const uint8_t *pucBuffer, FF_Error_t *pxError ); | |
static uint32_t FF_SetCluster( FF_FILE *pxFile, FF_Error_t *pxError ); | |
static uint32_t FF_FileLBA( FF_FILE *pxFile ); | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Converts STDIO mode strings into the equivalent FreeRTOS+FAT mode. | |
* | |
* @param Mode The mode string e.g. "rb" "rb+" "w" "a" "r" "w+" "a+" etc | |
* | |
* @return Returns the mode bits that should be passed to the FF_Open function. | |
**/ | |
uint8_t FF_GetModeBits( const char *pcMode ) | |
{ | |
uint8_t ucModeBits = 0x00; | |
while( *pcMode != '\0' ) | |
{ | |
switch( *pcMode ) | |
{ | |
case 'r': /* Allow Read. */ | |
case 'R': | |
ucModeBits |= FF_MODE_READ; | |
break; | |
case 'w': /* Allow Write. */ | |
case 'W': | |
ucModeBits |= FF_MODE_WRITE; | |
ucModeBits |= FF_MODE_CREATE; /* Create if not exist. */ | |
ucModeBits |= FF_MODE_TRUNCATE; | |
break; | |
case 'a': /* Append new writes to the end of the file. */ | |
case 'A': | |
ucModeBits |= FF_MODE_WRITE; | |
ucModeBits |= FF_MODE_APPEND; | |
ucModeBits |= FF_MODE_CREATE; /* Create if not exist. */ | |
break; | |
case '+': /* Update the file, don't Append! */ | |
ucModeBits |= FF_MODE_READ; | |
ucModeBits |= FF_MODE_WRITE; /* RW Mode. */ | |
break; | |
case 'D': | |
/* Internal use only! */ | |
ucModeBits |= FF_MODE_DIR; | |
break; | |
case 'b': | |
case 'B': | |
/* b|B flags not supported (Binary mode is native anyway). */ | |
break; | |
default: | |
break; | |
} | |
pcMode++; | |
} | |
return ucModeBits; | |
} /* FF_GetModeBits() */ | |
/*-----------------------------------------------------------*/ | |
static FF_FILE *prvAllocFileHandle( FF_IOManager_t *pxIOManager, FF_Error_t *pxError ) | |
{ | |
FF_FILE *pxFile; | |
pxFile = ffconfigMALLOC( sizeof( FF_FILE ) ); | |
if( pxFile == NULL ) | |
{ | |
*pxError = ( FF_Error_t ) ( FF_ERR_NOT_ENOUGH_MEMORY | FF_OPEN ); | |
} | |
else | |
{ | |
memset( pxFile, 0, sizeof( *pxFile ) ); | |
#if( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) | |
{ | |
pxFile->pucBuffer = ( uint8_t * ) ffconfigMALLOC( pxIOManager->usSectorSize ); | |
if( pxFile->pucBuffer != NULL ) | |
{ | |
memset( pxFile->pucBuffer, 0, pxIOManager->usSectorSize ); | |
} | |
else | |
{ | |
*pxError = ( FF_Error_t ) ( FF_ERR_NOT_ENOUGH_MEMORY | FF_OPEN ); | |
ffconfigFREE( pxFile ); | |
/* Make sure that NULL will be returned. */ | |
pxFile = NULL; | |
} | |
} | |
#else | |
{ | |
/* Remove compiler warnings. */ | |
( void ) pxIOManager; | |
} | |
#endif | |
} | |
return pxFile; | |
} /* prvAllocFileHandle() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* FF_Open() Mode Information | |
* - FF_MODE_WRITE | |
* - Allows WRITE access to the file. | |
* . | |
* - FF_MODE_READ | |
* - Allows READ access to the file. | |
* . | |
* - FF_MODE_CREATE | |
* - Create file if it doesn't exist. | |
* . | |
* - FF_MODE_TRUNCATE | |
* - Erase the file if it already exists and overwrite. | |
* * | |
* - FF_MODE_APPEND | |
* - Causes all writes to occur at the end of the file. (Its impossible to overwrite other data in a file with this flag set). | |
* . | |
* . | |
* | |
* Some sample modes: | |
* - (FF_MODE_WRITE | FF_MODE_CREATE | FF_MODE_TRUNCATE) | |
* - Write access to the file. (Equivalent to "w"). | |
* . | |
* - (FF_MODE_WRITE | FF_MODE_READ) | |
* - Read and Write access to the file. (Equivalent to "rb+"). | |
* . | |
* - (FF_MODE_WRITE | FF_MODE_READ | FF_MODE_APPEND | FF_MODE_CREATE) | |
* - Read and Write append mode access to the file. (Equivalent to "a+"). | |
* . | |
* . | |
* Be careful when choosing modes. For those using FF_Open() at the application layer | |
* its best to use the provided FF_GetModeBits() function, as this complies to the same | |
* behaviour as the stdio.h fopen() function. | |
* | |
**/ | |
/** | |
* @public | |
* @brief Opens a File for Access | |
* | |
* @param pxIOManager FF_IOManager_t object that was created by FF_CreateIOManger(). | |
* @param pcPath Path to the File or object. | |
* @param ucMode Access Mode required. Modes are a little complicated, the function FF_GetModeBits() | |
* @param ucMode will convert a stdio Mode string into the equivalent Mode bits for this parameter. | |
* @param pxError Pointer to a signed byte for error checking. Can be NULL if not required. | |
* @param pxError To be checked when a NULL pointer is returned. | |
* | |
* @return NULL pointer on error, in which case pxError should be checked for more information. | |
* @return pxError can be: | |
**/ | |
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) | |
FF_FILE *FF_Open( FF_IOManager_t *pxIOManager, const FF_T_WCHAR *pcPath, uint8_t ucMode, FF_Error_t *pxError ) | |
#else | |
FF_FILE *FF_Open( FF_IOManager_t *pxIOManager, const char *pcPath, uint8_t ucMode, FF_Error_t *pxError ) | |
#endif | |
{ | |
FF_FILE *pxFile = NULL; | |
FF_FILE *pxFileChain; | |
FF_DirEnt_t xDirEntry; | |
uint32_t ulFileCluster; | |
FF_Error_t xError; | |
BaseType_t xIndex; | |
FF_FindParams_t xFindParams; | |
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) | |
FF_T_WCHAR pcFileName[ ffconfigMAX_FILENAME ]; | |
#else | |
char pcFileName[ ffconfigMAX_FILENAME ]; | |
#endif | |
memset( &xFindParams, '\0', sizeof( xFindParams ) ); | |
/* Inform the functions that the entry will be created if not found. */ | |
if( ( ucMode & FF_MODE_CREATE ) != 0 ) | |
{ | |
xFindParams.ulFlags |= FIND_FLAG_CREATE_FLAG; | |
} | |
if( pxIOManager == NULL ) | |
{ | |
/* Use the error function code 'FF_OPEN' as this static | |
function is only called from that function. */ | |
xError = ( FF_Error_t ) ( FF_ERR_NULL_POINTER | FF_OPEN ); | |
} | |
#if( ffconfigREMOVABLE_MEDIA != 0 ) | |
else if( ( pxIOManager->ucFlags & FF_IOMAN_DEVICE_IS_EXTRACTED ) != 0 ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_IOMAN_DRIVER_NOMEDIUM | FF_OPEN ); | |
} | |
#endif /* ffconfigREMOVABLE_MEDIA */ | |
else | |
{ | |
xError = FF_ERR_NONE; | |
/* Let xIndex point to the last occurrence of '/' or '\', | |
to separate the path from the file name. */ | |
xIndex = ( BaseType_t ) STRLEN( pcPath ); | |
while( xIndex != 0 ) | |
{ | |
if( ( pcPath[ xIndex ] == '\\' ) || ( pcPath[ xIndex ] == '/' ) ) | |
{ | |
break; | |
} | |
xIndex--; | |
} | |
/* Copy the file name, i.e. the string that comes after the last separator. */ | |
STRNCPY( pcFileName, pcPath + xIndex + 1, ffconfigMAX_FILENAME ); | |
if( xIndex == 0 ) | |
{ | |
/* Only for the root, the slash is part of the directory name. | |
'xIndex' now equals to the length of the path name. */ | |
xIndex = 1; | |
} | |
/* FF_CreateShortName() might set flags FIND_FLAG_FITS_SHORT and FIND_FLAG_SIZE_OK. */ | |
FF_CreateShortName( &xFindParams, pcFileName ); | |
/* Lookup the path and find the cluster pointing to the directory: */ | |
xFindParams.ulDirCluster = FF_FindDir( pxIOManager, pcPath, xIndex, &xError ); | |
if( xFindParams.ulDirCluster == 0ul ) | |
{ | |
if( ( ucMode & FF_MODE_WRITE ) != 0 ) | |
{ | |
FF_PRINTF( "FF_Open[%s]: Path not found\n", pcPath ); | |
} | |
/* The user tries to open a file but the path leading to the file does not exist. */ | |
} | |
else if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
/* Allocate an empty file handle and buffer space for 'unaligned access'. */ | |
pxFile = prvAllocFileHandle( pxIOManager, &xError ); | |
} | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
/* Copy the Mode Bits. */ | |
pxFile->ucMode = ucMode; | |
/* See if the file does exist within the given directory. */ | |
ulFileCluster = FF_FindEntryInDir( pxIOManager, &xFindParams, pcFileName, 0x00, &xDirEntry, &xError ); | |
if( ulFileCluster == 0ul ) | |
{ | |
/* If cluster 0 was returned, it might be because the file has no allocated cluster, | |
i.e. only a directory entry and no stored data. */ | |
if( STRLEN( pcFileName ) == STRLEN( xDirEntry.pcFileName ) ) | |
{ | |
if( ( xDirEntry.ulFileSize == 0 ) && ( FF_strmatch( pcFileName, xDirEntry.pcFileName, ( BaseType_t ) STRLEN( pcFileName ) ) == pdTRUE ) ) | |
{ | |
/* It is the file, give it a pseudo cluster number '1'. */ | |
ulFileCluster = 1; | |
/* And reset any error. */ | |
xError = FF_ERR_NONE; | |
} | |
} | |
} | |
/* Test 'ulFileCluster' again, it might have been changed. */ | |
if( ulFileCluster == 0ul ) | |
{ | |
/* The path is found, but it does not contain the file name yet. | |
Maybe the user wants to create it? */ | |
if( ( ucMode & FF_MODE_CREATE ) == 0 ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_NOT_FOUND | FF_OPEN ); | |
} | |
else | |
{ | |
ulFileCluster = FF_CreateFile( pxIOManager, &xFindParams, pcFileName, &xDirEntry, &xError ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xDirEntry.usCurrentItem += 1; | |
} | |
} | |
} | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
/* Now the file exists, or it has been created. | |
Check if the Mode flags are allowed: */ | |
if( ( xDirEntry.ucAttrib == FF_FAT_ATTR_DIR ) && ( ( ucMode & FF_MODE_DIR ) == 0 ) ) | |
{ | |
/* Not the object, File Not Found! */ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_OBJECT_IS_A_DIR | FF_OPEN ); | |
} | |
/*---------- Ensure Read-Only files don't get opened for Writing. */ | |
else if( ( ( ucMode & ( FF_MODE_WRITE | FF_MODE_APPEND ) ) != 0 ) && ( ( xDirEntry.ucAttrib & FF_FAT_ATTR_READONLY ) != 0 ) ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_IS_READ_ONLY | FF_OPEN ); | |
} | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
pxFile->pxIOManager = pxIOManager; | |
pxFile->ulFilePointer = 0; | |
/* Despite the warning output by MSVC - it is not possible to get here | |
if xDirEntry has not been initialised. */ | |
pxFile->ulObjectCluster = xDirEntry.ulObjectCluster; | |
pxFile->ulFileSize = xDirEntry.ulFileSize; | |
pxFile->ulCurrentCluster = 0; | |
pxFile->ulAddrCurrentCluster = pxFile->ulObjectCluster; | |
pxFile->pxNext = NULL; | |
pxFile->ulDirCluster = xFindParams.ulDirCluster; | |
pxFile->usDirEntry = xDirEntry.usCurrentItem - 1; | |
pxFile->ulChainLength = 0; | |
pxFile->ulEndOfChain = 0; | |
pxFile->ulValidFlags &= ~( FF_VALID_FLAG_DELETED ); | |
/* Add pxFile onto the end of our linked list of FF_FILE objects. | |
But first make sure that there are not 2 handles with write access | |
to the same object. */ | |
FF_PendSemaphore( pxIOManager->pvSemaphore ); | |
{ | |
pxFileChain = ( FF_FILE * ) pxIOManager->FirstFile; | |
if( pxFileChain == NULL ) | |
{ | |
pxIOManager->FirstFile = pxFile; | |
} | |
else | |
{ | |
for( ; ; ) | |
{ | |
/* See if two file handles point to the same object. */ | |
if( ( pxFileChain->ulObjectCluster == pxFile->ulObjectCluster ) && | |
( pxFileChain->ulDirCluster == pxFile->ulDirCluster ) && | |
( pxFileChain->usDirEntry == pxFile->usDirEntry ) ) | |
{ | |
/* Fail if any of the two has write access to the object. */ | |
if( ( ( pxFileChain->ucMode | pxFile->ucMode ) & ( FF_MODE_WRITE | FF_MODE_APPEND ) ) != 0 ) | |
{ | |
/* File is already open! DON'T ALLOW IT! */ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_ALREADY_OPEN | FF_OPEN ); | |
break; | |
} | |
} | |
if( pxFileChain->pxNext == NULL ) | |
{ | |
pxFileChain->pxNext = pxFile; | |
break; | |
} | |
pxFileChain = ( FF_FILE * ) pxFileChain->pxNext; | |
} | |
} | |
} | |
FF_ReleaseSemaphore( pxIOManager->pvSemaphore ); | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
/* If the file is opened with the truncate flag, truncate its contents. */ | |
if( ( ucMode & FF_MODE_TRUNCATE ) != 0 ) | |
{ | |
/* Set the current size and position to zero. */ | |
pxFile->ulFileSize = 0; | |
pxFile->ulFilePointer = 0; | |
} | |
} | |
if( FF_isERR( xError ) != pdFALSE ) | |
{ | |
if( pxFile != NULL ) | |
{ | |
#if( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) | |
{ | |
ffconfigFREE( pxFile->pucBuffer ); | |
} | |
#endif | |
ffconfigFREE( pxFile ); | |
} | |
pxFile = NULL; | |
} | |
if( pxError != NULL ) | |
{ | |
*pxError = xError; | |
} | |
return pxFile; | |
} /* FF_Open() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Tests if a Directory contains any other files or folders. | |
* | |
* @param pxIOManager FF_IOManager_t object returned from the FF_CreateIOManger() function. | |
* | |
**/ | |
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) | |
BaseType_t FF_isDirEmpty ( FF_IOManager_t * pxIOManager, const FF_T_WCHAR *pcPath ) | |
#else | |
BaseType_t FF_isDirEmpty ( FF_IOManager_t * pxIOManager, const char *pcPath ) | |
#endif | |
{ | |
FF_DirEnt_t xDirEntry; | |
FF_Error_t xError = FF_ERR_NONE; | |
BaseType_t xReturn; | |
if( pxIOManager == NULL ) | |
{ | |
xReturn = pdFALSE; | |
} | |
else | |
{ | |
xError = FF_FindFirst( pxIOManager, &xDirEntry, pcPath ); | |
/* Assume the directory is empty until a file is | |
encountered with a name other than ".." or "." */ | |
xReturn = pdTRUE; | |
while( xError == 0 ) | |
{ | |
/* As we can't be sure the first 2 entries contain | |
* "." and "..", check it, not just count them | |
*/ | |
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) | |
if( ( wcscmp( xDirEntry.pcFileName, L".." ) != 0 ) && ( wcscmp( xDirEntry.pcFileName, L"." ) != 0 ) ) | |
#else | |
if( ( strcmp( xDirEntry.pcFileName, ".." ) != 0 ) && ( strcmp( xDirEntry.pcFileName, "." ) != 0 ) ) | |
#endif | |
{ | |
xReturn = pdFALSE; | |
break; | |
} | |
xError = FF_FindNext( pxIOManager, &xDirEntry ); | |
} | |
} | |
return xReturn; | |
} /* FF_isDirEmpty() */ | |
/*-----------------------------------------------------------*/ | |
#if( ffconfigPATH_CACHE != 0 ) | |
/* _HT_ After a directory has been renamed, the path cache becomes out-of-date */ | |
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) | |
static void FF_RmPathCache ( FF_IOManager_t * pxIOManager, const FF_T_WCHAR * pcPath ) | |
#else | |
static void FF_RmPathCache ( FF_IOManager_t * pxIOManager, const char *pcPath ) | |
#endif | |
{ | |
/* | |
* The directory 'path' will be removed or renamed | |
* now clear all entries starting with 'path' in the path cache | |
*/ | |
BaseType_t xIndex; | |
BaseType_t pathLen = STRLEN( pcPath ); | |
FF_PendSemaphore( pxIOManager->pvSemaphore ); | |
{ | |
for( xIndex = 0; xIndex < ffconfigPATH_CACHE_DEPTH; xIndex++ ) | |
{ | |
BaseType_t len2 = STRLEN( pxIOManager->xPartition.pxPathCache[ xIndex ].pcPath ); | |
if( len2 >= pathLen && FF_strmatch( pxIOManager->xPartition.pxPathCache[ xIndex ].pcPath, pcPath, pathLen ) ) | |
{ | |
pxIOManager->xPartition.pxPathCache[ xIndex ].pcPath[ 0 ] = '\0'; | |
pxIOManager->xPartition.pxPathCache[ xIndex ].ulDirCluster = 0; | |
} | |
} | |
} | |
FF_ReleaseSemaphore( pxIOManager->pvSemaphore ); | |
} | |
#endif /* ffconfigPATH_CACHE */ | |
/*-----------------------------------------------------------*/ | |
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) | |
FF_Error_t FF_RmDir( FF_IOManager_t *pxIOManager, const FF_T_WCHAR *pcPath ) | |
#else | |
FF_Error_t FF_RmDir( FF_IOManager_t *pxIOManager, const char *pcPath ) | |
#endif | |
{ | |
FF_FILE *pxFile; | |
uint8_t ucEntryBuffer[32]; | |
FF_FetchContext_t xFetchContext; | |
FF_Error_t xError = FF_ERR_NONE; | |
if( pxIOManager == NULL ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_NULL_POINTER | FF_RMDIR ); | |
} | |
#if( ffconfigREMOVABLE_MEDIA != 0 ) | |
else if( ( pxIOManager->ucFlags & FF_IOMAN_DEVICE_IS_EXTRACTED ) != 0 ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_IOMAN_DRIVER_NOMEDIUM | FF_RMDIR ); | |
} | |
#endif /* ffconfigREMOVABLE_MEDIA */ | |
else | |
{ | |
pxFile = FF_Open( pxIOManager, pcPath, FF_MODE_DIR, &xError ); | |
if( pxFile != NULL ) | |
{ | |
pxFile->ulValidFlags |= FF_VALID_FLAG_DELETED; | |
/* Clear the struct to allow a call to FF_CleanupEntryFetch() in any | |
state. */ | |
memset( &xFetchContext, '\0', sizeof( xFetchContext ) ); | |
/* This task will get the unique right to change directories. */ | |
FF_LockDirectory( pxIOManager ); | |
do /* while( pdFALSE ) */ | |
{ | |
/* This while loop is only introduced to be able to use break | |
statements. */ | |
if( FF_isDirEmpty( pxIOManager, pcPath ) == pdFALSE ) | |
{ | |
xError = ( FF_ERR_DIR_NOT_EMPTY | FF_RMDIR ); | |
break; | |
} | |
FF_LockFAT( pxIOManager ); | |
#if( ffconfigHASH_CACHE != 0 ) | |
{ | |
/* A directory is removed so invalidate any hash table | |
referring to this directory. */ | |
FF_UnHashDir( pxIOManager, pxFile->ulObjectCluster ); | |
} | |
#endif /* ffconfigHASH_CACHE */ | |
{ | |
/* Add parameter 0 to delete the entire chain! | |
The actual directory entries on disk will be freed. */ | |
xError = FF_UnlinkClusterChain( pxIOManager, pxFile->ulObjectCluster, 0 ); | |
} | |
FF_UnlockFAT( pxIOManager ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
/* Now remove this directory from its parent directory. | |
Initialise the dirent Fetch Context object for faster removal of | |
dirents. */ | |
xError = FF_InitEntryFetch( pxIOManager, pxFile->ulDirCluster, &xFetchContext ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
#if( ffconfigHASH_CACHE != 0 ) | |
{ | |
/* Invalidate any hash table of the parent directory | |
as well. */ | |
FF_UnHashDir( pxIOManager, pxFile->ulDirCluster ); | |
} | |
#endif /* ffconfigHASH_CACHE */ | |
/* Edit the Directory Entry, so it will show as deleted. | |
First remove the LFN entries: */ | |
xError = FF_RmLFNs( pxIOManager, pxFile->usDirEntry, &xFetchContext ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
/* And remove the Short file name entry: */ | |
xError = FF_FetchEntryWithContext( pxIOManager, pxFile->usDirEntry, &xFetchContext, ucEntryBuffer ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
ucEntryBuffer[0] = FF_FAT_DELETED; | |
FF_putShort( ucEntryBuffer, FF_FAT_DIRENT_CLUS_HIGH, ( uint32_t ) 0ul ); | |
FF_putShort( ucEntryBuffer, FF_FAT_DIRENT_CLUS_LOW, ( uint32_t ) 0ul ); | |
xError = FF_PushEntryWithContext( pxIOManager, pxFile->usDirEntry, &xFetchContext, ucEntryBuffer ); | |
} | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
#if( ffconfigPATH_CACHE != 0 ) | |
{ | |
/* We're removing a directory which might contain | |
subdirectories. Instead of iterating through all | |
subdirectories, just clear the path cache. */ | |
FF_RmPathCache( pxIOManager, pcPath ); | |
} | |
#endif | |
} while( pdFALSE ); | |
{ | |
FF_Error_t xTempError; | |
xTempError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = xTempError; | |
} | |
FF_UnlockDirectory( pxIOManager ); | |
/* Free the file pointer resources. */ | |
xTempError = FF_Close( pxFile ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = xTempError; | |
} | |
xTempError = FF_FlushCache( pxIOManager ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = xTempError; | |
} | |
} | |
} /* if( pxFile != NULL ) */ | |
} /* else if( pxIOManager != NULL ) */ | |
return xError; | |
} /* FF_RmDir() */ | |
/*-----------------------------------------------------------*/ | |
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) | |
FF_Error_t FF_RmFile( FF_IOManager_t *pxIOManager, const FF_T_WCHAR *pcPath ) | |
#else | |
FF_Error_t FF_RmFile( FF_IOManager_t *pxIOManager, const char *pcPath ) | |
#endif | |
{ | |
FF_FILE *pxFile; | |
FF_Error_t xError = FF_ERR_NONE; | |
uint8_t ucEntryBuffer[32]; | |
FF_FetchContext_t xFetchContext; | |
/* Opening the file-to-be-deleted in WR mode has two advantages: | |
1. The file handle gives all necessary information to delete it such | |
as the data clusters and directory entries. | |
2. The file is now locked, it can not be opened by another task. */ | |
pxFile = FF_Open( pxIOManager, pcPath, FF_MODE_WRITE, &xError ); | |
if( pxFile != NULL ) | |
{ | |
/* FF_Close() will see this flag and won't do any disc access. */ | |
pxFile->ulValidFlags |= FF_VALID_FLAG_DELETED; | |
/* Ensure there is actually a cluster chain to delete! */ | |
if( pxFile->ulObjectCluster != 0 ) | |
{ | |
/* Lock the FAT so its thread-safe. */ | |
FF_LockFAT( pxIOManager ); | |
{ | |
/* 0 to delete the entire chain! */ | |
xError = FF_UnlinkClusterChain( pxIOManager, pxFile->ulObjectCluster, 0 ); | |
} | |
FF_UnlockFAT( pxIOManager ); | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
/* Clear the struct to allow a call to FF_CleanupEntryFetch() in any | |
state. */ | |
memset( &xFetchContext, '\0', sizeof( xFetchContext ) ); | |
/* Get sole access to "directory changes" */ | |
FF_LockDirectory( pxIOManager ); | |
/* Edit the Directory Entry! (So it appears as deleted); */ | |
do { | |
xError = FF_InitEntryFetch( pxIOManager, pxFile->ulDirCluster, &xFetchContext ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
#if( ffconfigHASH_CACHE != 0 ) | |
{ | |
FF_UnHashDir( pxIOManager, pxFile->ulDirCluster ); | |
} | |
#endif /* ffconfigHASH_CACHE */ | |
/* Remove LFN entries, if any. */ | |
xError = FF_RmLFNs( pxIOManager, ( uint16_t ) pxFile->usDirEntry, &xFetchContext ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
/* Remove the Short file name entry. */ | |
xError = FF_FetchEntryWithContext( pxIOManager, pxFile->usDirEntry, &xFetchContext, ucEntryBuffer ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
ucEntryBuffer[0] = FF_FAT_DELETED; | |
FF_putShort( ucEntryBuffer, FF_FAT_DIRENT_CLUS_HIGH, ( uint32_t ) 0ul ); | |
FF_putShort( ucEntryBuffer, FF_FAT_DIRENT_CLUS_LOW, ( uint32_t ) 0ul ); | |
xError = FF_PushEntryWithContext( pxIOManager, pxFile->usDirEntry, &xFetchContext, ucEntryBuffer ); | |
} | |
} while( pdFALSE ); | |
{ | |
FF_Error_t xTempError; | |
xTempError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = xTempError; | |
} | |
FF_UnlockDirectory( pxIOManager ); | |
/* Free the file pointer resources. */ | |
xTempError = FF_Close( pxFile ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = xTempError; | |
} | |
xTempError = FF_FlushCache( pxIOManager ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = xTempError; | |
} | |
} | |
} | |
} /* if( pxFile != NULL ) */ | |
return xError; | |
} /* FF_RmFile() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Moves a file or directory from source to destination. | |
* | |
* @param pxIOManager The FF_IOManager_t object pointer. | |
* @param szSourceFile String of the source file to be moved or renamed. | |
* @param szDestinationFile String of the destination file to where the source should be moved or renamed. | |
* | |
* @return FF_ERR_NONE on success. | |
* @return FF_ERR_FILE_DESTINATION_EXISTS if the destination file exists. | |
* @return FF_ERR_FILE_COULD_NOT_CREATE_DIRENT if dirent creation failed (fatal error!). | |
* @return FF_ERR_FILE_DIR_NOT_FOUND if destination directory was not found. | |
* @return FF_ERR_FILE_SOURCE_NOT_FOUND if the source file was not found. | |
* | |
**/ | |
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) | |
FF_Error_t FF_Move( FF_IOManager_t *pxIOManager, const FF_T_WCHAR*szSourceFile, | |
const FF_T_WCHAR *szDestinationFile, BaseType_t xDeleteIfExists ) | |
#else | |
FF_Error_t FF_Move( FF_IOManager_t *pxIOManager, const char *szSourceFile, | |
const char *szDestinationFile, BaseType_t xDeleteIfExists ) | |
#endif | |
{ | |
FF_Error_t xError; | |
FF_FILE *pSrcFile, *pxDestFile; | |
FF_DirEnt_t xMyFile; | |
uint8_t ucEntryBuffer[32]; | |
BaseType_t xIndex; | |
uint32_t ulDirCluster = 0ul; | |
FF_FetchContext_t xFetchContext; | |
#if( ffconfigPATH_CACHE != 0 ) | |
BaseType_t xIsDirectory = pdFALSE; | |
#endif | |
memset( &xFetchContext, '\0', sizeof( xFetchContext ) ); | |
if( pxIOManager == NULL ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_NULL_POINTER | FF_MOVE ); | |
} | |
#if( ffconfigREMOVABLE_MEDIA != 0 ) | |
else if( ( pxIOManager->ucFlags & FF_IOMAN_DEVICE_IS_EXTRACTED ) != 0 ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_IOMAN_DRIVER_NOMEDIUM | FF_MOVE ); | |
} | |
#endif /* ffconfigREMOVABLE_MEDIA */ | |
else | |
{ | |
/* Check destination file doesn't exist! */ | |
pxDestFile = FF_Open( pxIOManager, szDestinationFile, FF_MODE_READ, &xError ); | |
if( ( pxDestFile != NULL) || ( FF_GETERROR( xError ) == FF_ERR_FILE_OBJECT_IS_A_DIR ) ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_DESTINATION_EXISTS | FF_MOVE ); | |
if( pxDestFile != NULL ) | |
{ | |
FF_Close( pxDestFile ); | |
if( xDeleteIfExists != pdFALSE ) | |
{ | |
xError = FF_RmFile( pxIOManager, szDestinationFile ); | |
} | |
} | |
} | |
else | |
{ | |
/* Discard the error set by FF_Open(). | |
The target file (or directory) is not found: continue renaming. */ | |
xError = FF_ERR_NONE; | |
} | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
/* About to move/rename 'szSourceFile'. When opening it with 'FF_MODE_WRITE' | |
only succeeds if it has no other open handle to it. */ | |
pSrcFile = FF_Open( pxIOManager, szSourceFile, FF_MODE_WRITE, &xError ); | |
if( FF_GETERROR( xError ) == FF_ERR_FILE_OBJECT_IS_A_DIR ) | |
{ | |
/* Open a directory for moving! */ | |
pSrcFile = FF_Open( pxIOManager, szSourceFile, FF_MODE_DIR, &xError ); | |
#if( ffconfigPATH_CACHE != 0 ) | |
xIsDirectory = pdTRUE; | |
#endif | |
} | |
if( pSrcFile != NULL ) | |
{ | |
/* Collect information about the current directory entry. */ | |
xError = FF_InitEntryFetch( pxIOManager, pSrcFile->ulDirCluster, &xFetchContext ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = FF_FetchEntryWithContext( pxIOManager, pSrcFile->usDirEntry, &xFetchContext, ucEntryBuffer ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xMyFile.ucAttrib = FF_getChar( ucEntryBuffer, ( uint16_t ) ( FF_FAT_DIRENT_ATTRIB ) ); | |
xMyFile.ulFileSize = pSrcFile->ulFileSize; | |
xMyFile.ulObjectCluster = pSrcFile->ulObjectCluster; | |
xMyFile.usCurrentItem = 0; | |
xIndex = ( BaseType_t ) STRLEN( szDestinationFile ); | |
while( xIndex != 0 ) | |
{ | |
if( ( szDestinationFile[ xIndex ] == '\\' ) || ( szDestinationFile[ xIndex ] == '/' ) ) | |
{ | |
break; | |
} | |
xIndex--; | |
} | |
/* Copy the base name of the destination file. */ | |
STRNCPY( xMyFile.pcFileName, ( szDestinationFile + xIndex + 1 ), ffconfigMAX_FILENAME ); | |
if( xIndex == 0 ) | |
{ | |
xIndex = 1; | |
} | |
/* Find the (cluster of the) directory in which the target file will be located. | |
It must exist before calling FF_Move(). */ | |
ulDirCluster = FF_FindDir( pxIOManager, szDestinationFile, xIndex, &xError ); | |
} | |
} | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
if( ulDirCluster != 0ul ) | |
{ | |
FF_FindParams_t xFindParams; | |
memset( &xFindParams, '\0', sizeof( xFindParams ) ); | |
/* Clean up because FF_CreateDirent might want to write to the same sector. */ | |
xError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
/* Destination directory was found, we can now create the new entry. */ | |
xFindParams.ulDirCluster = ulDirCluster; | |
xError = FF_CreateDirent( pxIOManager, &xFindParams, &xMyFile ); | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
/* Edit the Directory Entry! (So it appears as deleted); */ | |
FF_LockDirectory( pxIOManager ); | |
{ | |
xError = FF_RmLFNs( pxIOManager, pSrcFile->usDirEntry, &xFetchContext ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = FF_FetchEntryWithContext( pxIOManager, pSrcFile->usDirEntry, &xFetchContext, ucEntryBuffer ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
FF_Error_t xTempError; | |
ucEntryBuffer[0] = FF_FAT_DELETED; | |
FF_putShort( ucEntryBuffer, FF_FAT_DIRENT_CLUS_HIGH, ( uint32_t ) 0ul ); | |
FF_putShort( ucEntryBuffer, FF_FAT_DIRENT_CLUS_LOW, ( uint32_t ) 0ul ); | |
xError = FF_PushEntryWithContext( pxIOManager, pSrcFile->usDirEntry, &xFetchContext, ucEntryBuffer ); | |
/* The contents of 'xFetchContext' has changed, flush it to disk now. */ | |
xTempError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = xTempError; | |
} | |
} | |
} | |
} | |
FF_UnlockDirectory( pxIOManager ); | |
} | |
#if( ffconfigPATH_CACHE != 0 ) | |
{ | |
if( xIsDirectory != 0 ) | |
{ | |
/* We've renamed a directory which might contain | |
subdirectories. To avoid having false entries, clear | |
the path cache. */ | |
FF_RmPathCache( pxIOManager, szSourceFile ); | |
} | |
} | |
#endif | |
} | |
else /* ulDirCluster == 0ul */ | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_DIR_NOT_FOUND | FF_MOVE ); | |
} | |
} | |
if( pSrcFile != NULL ) | |
{ | |
/* The source file was opened in WRITE mode just to lock it. | |
Now clear the write flags to avoid writing back any changes. */ | |
pSrcFile->ucMode &= ~( FF_MODE_WRITE | FF_MODE_APPEND | FF_MODE_CREATE ); | |
FF_Close( pSrcFile ); | |
} | |
} | |
{ | |
FF_Error_t xTempError; | |
xTempError = FF_FlushCache( pxIOManager ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = xTempError; | |
} | |
xTempError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = xTempError; | |
} | |
} | |
return xError; | |
} /* FF_Move() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Get's the next Entry based on the data recorded in the FF_DirEnt_t object. | |
* | |
* @param pxFile FF_FILE object that was created by FF_Open(). | |
* | |
* @return pdTRUE if End of File was reached. pdFALSE if not. | |
* @return pdFALSE if a null pointer was provided. | |
* | |
**/ | |
BaseType_t FF_isEOF( FF_FILE *pxFile ) | |
{ | |
BaseType_t xReturn; | |
if( ( pxFile != NULL ) && ( pxFile->ulFilePointer >= pxFile->ulFileSize ) ) | |
{ | |
xReturn = pdTRUE; | |
} | |
else | |
{ | |
xReturn = pdFALSE; | |
} | |
return xReturn; | |
} /* FF_isEOF() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Checks the number of bytes left on a read handle | |
* | |
* @param pxFile An open file handle | |
* | |
* @return Less than zero: an error code | |
* @return Number of bytes left to read from handle | |
**/ | |
int32_t FF_BytesLeft( FF_FILE *pxFile ) | |
{ | |
BaseType_t xReturn; | |
if( pxFile == NULL ) | |
{ | |
xReturn = FF_ERR_NULL_POINTER | FF_BYTESLEFT; | |
} | |
else if( ( pxFile->ucMode & FF_MODE_READ ) == 0 ) | |
{ | |
xReturn = FF_ERR_FILE_NOT_OPENED_IN_READ_MODE | FF_BYTESLEFT; | |
} | |
else if( pxFile->ulFilePointer >= pxFile->ulFileSize ) | |
{ | |
xReturn = 0; | |
} | |
else | |
{ | |
xReturn = pxFile->ulFileSize - pxFile->ulFilePointer; | |
} | |
return xReturn; | |
} /* FF_BytesLeft() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Returns the file size of a read handle | |
* | |
* @param pxFile An open file handle | |
* | |
* @return Less than zero: an error code | |
* @return Number of bytes left to read from handle | |
**/ | |
FF_Error_t FF_GetFileSize( FF_FILE *pxFile, uint32_t *pulSize ) /* Writes # of bytes in a file to the parameter. */ | |
{ | |
BaseType_t xReturn; | |
if( pxFile == NULL ) | |
{ | |
xReturn = ( FF_Error_t ) ( FF_ERR_NULL_POINTER | FF_BYTESLEFT ); | |
*( pulSize ) = ( uint32_t ) 0u; | |
} | |
else if( FF_isERR( FF_CheckValid( pxFile ) ) ) | |
{ | |
xReturn = ( FF_Error_t ) ( FF_ERR_FILE_BAD_HANDLE | FF_BYTESLEFT ); | |
*( pulSize ) = ( uint32_t ) 0u; | |
} | |
else | |
{ | |
xReturn = 0; | |
*( pulSize ) = pxFile->ulFileSize; | |
} | |
return xReturn; | |
} /* FF_GetFileSize */ | |
int32_t FF_FileSize( FF_FILE *pxFile ) | |
{ | |
uint32_t ulLength; | |
FF_Error_t xResult; | |
/* Function is deprecated. Please use FF_GetFileSize(). */ | |
xResult = FF_GetFileSize( pxFile, &( ulLength ) ); | |
if( FF_isERR( xResult ) == 0 ) | |
{ | |
xResult = ( int32_t ) ulLength; | |
} | |
return ( int32_t ) xResult; | |
} /* FF_FileSize() */ | |
/*-----------------------------------------------------------*/ | |
static uint32_t FF_GetSequentialClusters( FF_IOManager_t *pxIOManager, uint32_t ulStartCluster, uint32_t ulLimit, FF_Error_t *pxError ) | |
{ | |
uint32_t ulCurrentCluster; | |
uint32_t ulNextCluster = ulStartCluster; | |
uint32_t ulIndex = 0; | |
FF_FATBuffers_t xFATBuffers; | |
FF_InitFATBuffers( &xFATBuffers, FF_MODE_READ ); | |
*pxError = FF_ERR_NONE; | |
FF_LockFAT( pxIOManager ); | |
do | |
{ | |
ulCurrentCluster = ulNextCluster; | |
ulNextCluster = FF_getFATEntry( pxIOManager, ulCurrentCluster, pxError, &xFATBuffers ); | |
if( FF_isERR( *pxError ) ) | |
{ | |
ulIndex = 0; | |
break; | |
} | |
if( ulNextCluster == ( ulCurrentCluster + 1 ) ) | |
{ | |
ulIndex++; | |
} | |
else | |
{ | |
break; | |
} | |
if( ( ulLimit != 0 ) && ( ulIndex == ulLimit ) ) | |
{ | |
break; | |
} | |
} | |
while( ulNextCluster == ( ulCurrentCluster + 1 ) ); | |
FF_UnlockFAT( pxIOManager ); | |
*pxError = FF_ReleaseFATBuffers( pxIOManager, &xFATBuffers ); | |
return ulIndex; | |
} /* FF_GetSequentialClusters() */ | |
/*-----------------------------------------------------------*/ | |
static FF_Error_t FF_ReadClusters( FF_FILE *pxFile, uint32_t ulCount, uint8_t *buffer ) | |
{ | |
uint32_t ulSectors; | |
uint32_t ulSequentialClusters = 0; | |
uint32_t ulItemLBA; | |
FF_Error_t xError = FF_ERR_NONE; | |
while( ulCount != 0 ) | |
{ | |
if( ( ulCount - 1 ) > 0 ) | |
{ | |
ulSequentialClusters = | |
FF_GetSequentialClusters( pxFile->pxIOManager, pxFile->ulAddrCurrentCluster, ulCount - 1, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
} | |
ulSectors = ( ulSequentialClusters + 1 ) * pxFile->pxIOManager->xPartition.ulSectorsPerCluster; | |
ulItemLBA = FF_Cluster2LBA( pxFile->pxIOManager, pxFile->ulAddrCurrentCluster ); | |
ulItemLBA = FF_getRealLBA( pxFile->pxIOManager, ulItemLBA ); | |
xError = FF_BlockRead( pxFile->pxIOManager, ulItemLBA, ulSectors, buffer, pdFALSE ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
ulCount -= ( ulSequentialClusters + 1 ); | |
FF_LockFAT( pxFile->pxIOManager ); | |
{ | |
pxFile->ulAddrCurrentCluster = | |
FF_TraverseFAT( pxFile->pxIOManager, pxFile->ulAddrCurrentCluster, ulSequentialClusters + 1, &xError ); | |
} | |
FF_UnlockFAT( pxFile->pxIOManager ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
pxFile->ulCurrentCluster += ( ulSequentialClusters + 1 ); | |
buffer += ulSectors * pxFile->pxIOManager->usSectorSize; | |
ulSequentialClusters = 0; | |
} | |
return xError; | |
} /* FF_ReadClusters ()*/ | |
/*-----------------------------------------------------------*/ | |
static FF_Error_t FF_ExtendFile( FF_FILE *pxFile, uint32_t ulSize ) | |
{ | |
FF_IOManager_t *pxIOManager = pxFile->pxIOManager; | |
uint32_t ulBytesPerCluster = pxIOManager->xPartition.usBlkSize * pxIOManager->xPartition.ulSectorsPerCluster; | |
uint32_t ulTotalClustersNeeded = ( ulSize + ulBytesPerCluster - 1 ) / ulBytesPerCluster; | |
uint32_t ulClusterToExtend; | |
/* Initialise xIndex just for the compiler. */ | |
BaseType_t xIndex = 0; | |
FF_DirEnt_t xOriginalEntry; | |
FF_Error_t xError = FF_ERR_NONE; | |
FF_FATBuffers_t xFATBuffers; | |
if( ( pxFile->ucMode & FF_MODE_WRITE ) != FF_MODE_WRITE ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_NOT_OPENED_IN_WRITE_MODE | FF_EXTENDFILE ); | |
} | |
else | |
{ | |
if( ( pxFile->ulFileSize == 0 ) && ( pxFile->ulObjectCluster == 0 ) ) | |
{ | |
/* If there is no object cluster yet, create it.*/ | |
pxFile->ulAddrCurrentCluster = FF_CreateClusterChain( pxFile->pxIOManager, &xError ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
/* The directory denotes the address of the first data cluster of every file. | |
Now change it to 'ulAddrCurrentCluster': */ | |
xError = FF_GetEntry( pxIOManager, pxFile->usDirEntry, pxFile->ulDirCluster, &xOriginalEntry ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xOriginalEntry.ulObjectCluster = pxFile->ulAddrCurrentCluster; | |
xError = FF_PutEntry( pxIOManager, pxFile->usDirEntry, pxFile->ulDirCluster, &xOriginalEntry, NULL ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
pxFile->ulObjectCluster = pxFile->ulAddrCurrentCluster; | |
pxFile->ulChainLength = 1; | |
pxFile->ulCurrentCluster = 0; | |
pxFile->ulEndOfChain = pxFile->ulAddrCurrentCluster; | |
} | |
} | |
} | |
} | |
else | |
{ | |
/* This file already has at least one cluster. */ | |
} | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
if( pxFile->ulChainLength == 0 ) | |
{ | |
/* This is the first extension requiring the chain length. | |
Calculate it now: */ | |
pxFile->ulChainLength = FF_GetChainLength( pxIOManager, pxFile->ulObjectCluster, &pxFile->ulEndOfChain, &xError ); | |
} | |
} | |
if( ( FF_isERR( xError ) == pdFALSE ) && ( ulTotalClustersNeeded > pxFile->ulChainLength ) ) | |
{ | |
uint32_t ulCurrentCluster, ulNextCluster; | |
ulClusterToExtend = ( ulTotalClustersNeeded - pxFile->ulChainLength ); | |
/* Now the file has at least 1 cluster, but it needs more clusters. */ | |
ulNextCluster = pxFile->ulAddrCurrentCluster; | |
FF_LockFAT( pxIOManager ); | |
ulCurrentCluster = FF_FindEndOfChain( pxIOManager, ulNextCluster, &xError ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
for( xIndex = 0; xIndex < ( BaseType_t ) ulClusterToExtend; xIndex++ ) | |
{ | |
/* In FF_ExtendFile() */ | |
ulNextCluster = FF_FindFreeCluster( pxIOManager, &xError, pdTRUE ); | |
if( ( FF_isERR( xError ) == pdFALSE ) && ( ulNextCluster == 0UL ) ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_FAT_NO_FREE_CLUSTERS | FF_EXTENDFILE ); | |
} | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
/* Can not use this buffer earlier because of FF_FindEndOfChain/FF_FindFreeCluster */ | |
FF_InitFATBuffers( &xFATBuffers, FF_MODE_WRITE ); | |
xError = FF_putFATEntry( pxIOManager, ulCurrentCluster, ulNextCluster, &xFATBuffers ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
xError = FF_ReleaseFATBuffers( pxIOManager, &xFATBuffers ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
ulCurrentCluster = ulNextCluster; | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
pxFile->ulEndOfChain = ulCurrentCluster; | |
} | |
pxFile->ulChainLength += xIndex; | |
} | |
FF_UnlockFAT( pxIOManager ); | |
{ | |
FF_Error_t xTempError; | |
xTempError = FF_DecreaseFreeClusters( pxIOManager, ( uint32_t ) xIndex ); /* Keep Tab of Numbers for fast FreeSize() */ | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = xTempError; | |
} | |
} | |
/* We must ensure that the ulAddrCurrentCluster is not out-of-sync with the CurrentCluster number. | |
This could have occurred in append mode, where the file was opened with a filesize % clustersize == 0 | |
because of a seek, where the ulAddrCurrentCluster was not updated after extending. This caused the data to | |
be written to the previous cluster(s). */ | |
if( ( pxFile->ulCurrentCluster == pxFile->ulChainLength - 1 ) && | |
( pxFile->ulAddrCurrentCluster != pxFile->ulEndOfChain ) ) | |
{ | |
pxFile->ulAddrCurrentCluster = pxFile->ulEndOfChain; | |
} | |
/* By default, 'ffconfigFILE_EXTEND_FLUSHES_BUFFERS' is | |
defined as 1. | |
Users may set it to zero in order to increase the | |
speed of writing to disk. */ | |
#if( ffconfigFILE_EXTEND_FLUSHES_BUFFERS != 0 ) | |
{ | |
FF_Error_t xTempError; | |
xTempError = FF_FlushCache( pxIOManager ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = xTempError; | |
} | |
} | |
#endif /* ffconfigFILE_EXTEND_FLUSHES_BUFFERS */ | |
} /* if( ulTotalClustersNeeded > pxFile->ulChainLength ) */ | |
return xError; | |
} /* FF_ExtendFile() */ | |
/*-----------------------------------------------------------*/ | |
static FF_Error_t FF_WriteClusters( FF_FILE *pxFile, uint32_t ulCount, uint8_t *buffer ) | |
{ | |
uint32_t ulSectors; | |
uint32_t ulSequentialClusters = 0; | |
uint32_t ulItemLBA; | |
FF_Error_t xError = FF_ERR_NONE; | |
while( ulCount != 0 ) | |
{ | |
if( ( ulCount - 1 ) > 0 ) | |
{ | |
ulSequentialClusters = | |
FF_GetSequentialClusters( pxFile->pxIOManager, pxFile->ulAddrCurrentCluster, ulCount - 1, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
} | |
ulSectors = ( ulSequentialClusters + 1 ) * pxFile->pxIOManager->xPartition.ulSectorsPerCluster; | |
ulItemLBA = FF_Cluster2LBA( pxFile->pxIOManager, pxFile->ulAddrCurrentCluster ); | |
ulItemLBA = FF_getRealLBA( pxFile->pxIOManager, ulItemLBA ); | |
xError = FF_BlockWrite( pxFile->pxIOManager, ulItemLBA, ulSectors, buffer, pdFALSE ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
ulCount -= ulSequentialClusters + 1; | |
FF_LockFAT( pxFile->pxIOManager ); | |
{ | |
pxFile->ulAddrCurrentCluster = | |
FF_TraverseFAT( pxFile->pxIOManager, pxFile->ulAddrCurrentCluster, ulSequentialClusters + 1, &xError ); | |
} | |
FF_UnlockFAT( pxFile->pxIOManager ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
pxFile->ulCurrentCluster += ( ulSequentialClusters + 1 ); | |
buffer += ulSectors * pxFile->pxIOManager->usSectorSize; | |
ulSequentialClusters = 0; | |
} | |
return xError; | |
} /* FF_WriteClusters */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @private | |
* @brief Calculate the Logical Block Address (LBA) | |
* | |
* @param pxFile The file handle | |
* | |
* @return LBA | |
* | |
* Must be set: | |
* - pxFile->ulFilePointer : byte offset in file | |
* - pxFile->ulAddrCurrentCluster : physical cluster on the partition | |
**/ | |
static uint32_t FF_FileLBA( FF_FILE *pxFile ) | |
{ | |
uint32_t ulItemLBA; | |
ulItemLBA = FF_Cluster2LBA( pxFile->pxIOManager, pxFile->ulAddrCurrentCluster ); | |
ulItemLBA += FF_getMajorBlockNumber( pxFile->pxIOManager, pxFile->ulFilePointer, 1 ); | |
ulItemLBA = FF_getRealLBA( pxFile->pxIOManager, ulItemLBA ); | |
ulItemLBA += FF_getMinorBlockNumber( pxFile->pxIOManager, pxFile->ulFilePointer, 1 ); | |
return ulItemLBA; | |
} /* FF_FileLBA() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @private | |
* @brief Depending on FilePointer, calculate CurrentCluster | |
* @brief and traverse the FAT to find the right ulAddrCurrentCluster | |
* | |
* @param pxFile The file handle | |
* | |
* @return FF_ERR_NONE on success | |
* @return Possible error returned by FF_TraverseFAT() or END_OF_DIR | |
* | |
* Side effects: | |
* - pxFile->ulCurrentCluster : relative cluster number (0 <= Num < ulChainLength) | |
* - pxFile->ulAddrCurrentCluster : fysical cluster on the partition | |
**/ | |
static uint32_t FF_SetCluster( FF_FILE *pxFile, FF_Error_t *pxError ) | |
{ | |
FF_IOManager_t *pxIOManager = pxFile->pxIOManager; | |
uint32_t ulNewCluster = FF_getClusterChainNumber( pxIOManager, pxFile->ulFilePointer, 1 ); | |
FF_Error_t xResult = FF_ERR_NONE; | |
uint32_t ulReturn; | |
if( ulNewCluster > pxFile->ulCurrentCluster ) | |
{ | |
FF_LockFAT( pxIOManager ); | |
{ | |
pxFile->ulAddrCurrentCluster = FF_TraverseFAT( pxIOManager, pxFile->ulAddrCurrentCluster, | |
ulNewCluster - pxFile->ulCurrentCluster, &xResult ); | |
} | |
FF_UnlockFAT( pxIOManager ); | |
} | |
else if( ulNewCluster < pxFile->ulCurrentCluster ) | |
{ | |
FF_LockFAT( pxIOManager ); | |
{ | |
pxFile->ulAddrCurrentCluster = FF_TraverseFAT( pxIOManager, pxFile->ulObjectCluster, ulNewCluster, &xResult ); | |
} | |
FF_UnlockFAT( pxIOManager ); | |
} | |
else | |
{ | |
/* Well positioned. */ | |
} | |
if( FF_isERR( xResult ) == pdFALSE ) | |
{ | |
pxFile->ulCurrentCluster = ulNewCluster; | |
ulReturn = FF_FileLBA( pxFile ); | |
} | |
else | |
{ | |
ulReturn = 0; | |
} | |
*pxError = xResult; | |
return ulReturn; | |
} /* FF_SetCluster() */ | |
/*-----------------------------------------------------------*/ | |
static int32_t FF_ReadPartial( FF_FILE *pxFile, uint32_t ulItemLBA, uint32_t ulRelBlockPos, uint32_t ulCount, | |
uint8_t *pucBuffer, FF_Error_t *pxError ) | |
{ | |
FF_Error_t xError = FF_ERR_NONE; | |
uint32_t ulBytesRead; | |
/* Bytes to read are within a block and less than a block size. */ | |
#if( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) | |
{ | |
BaseType_t xLastRead; | |
/* Optimised method: each file handle holds one data block | |
in cache: 'pxFile->pucBuffer'. */ | |
/* See if the current block will be accessed after this read: */ | |
if( ( ulRelBlockPos + ulCount ) >= ( uint32_t ) pxFile->pxIOManager->usSectorSize ) | |
{ | |
/* After this read, ulFilePointer will point to the next block/sector. */ | |
xLastRead = pdTRUE; | |
} | |
else | |
{ | |
/* It is not the last read within this block/sector. */ | |
xLastRead = pdFALSE; | |
} | |
if( ( pxFile->ucState & FF_BUFSTATE_VALID ) == 0 ) | |
{ | |
xError = FF_BlockRead( pxFile->pxIOManager, ulItemLBA, 1, pxFile->pucBuffer, pdFALSE ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
pxFile->ucState = FF_BUFSTATE_VALID; | |
} | |
} | |
if( ( pxFile->ucState & FF_BUFSTATE_VALID ) != 0 ) | |
{ | |
memcpy( pucBuffer, pxFile->pucBuffer + ulRelBlockPos, ulCount ); | |
pxFile->ulFilePointer += ulCount; | |
ulBytesRead = ulCount; | |
if( ( xLastRead == pdTRUE ) && ( ( pxFile->ucState & FF_BUFSTATE_WRITTEN ) != 0 ) ) | |
{ | |
/* If the data was changed (file in 'update' mode), store the changes: */ | |
xError = FF_BlockWrite( pxFile->pxIOManager, ulItemLBA, 1, pxFile->pucBuffer, pdFALSE ); | |
} | |
} | |
else | |
{ | |
ulBytesRead = 0ul; | |
} | |
if( xLastRead == pdTRUE ) | |
{ | |
/* As the next FF_Read() will go passed the current block, invalidate the buffer now. */ | |
pxFile->ucState = FF_BUFSTATE_INVALID; | |
} | |
} | |
#else | |
{ | |
FF_Buffer_t *pxBuffer; | |
/* Reading in the standard way, using FF_Buffer_t. */ | |
pxBuffer = FF_GetBuffer( pxFile->pxIOManager, ulItemLBA, FF_MODE_READ ); | |
if( pxBuffer == NULL ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_DEVICE_DRIVER_FAILED | FF_READ ); | |
ulBytesRead = 0ul; | |
} | |
else | |
{ | |
memcpy( pucBuffer, pxBuffer->pucBuffer + ulRelBlockPos, ulCount ); | |
/* Releasing a buffer in FF_MODE_READ mode will not lead to an error, | |
because no disk access is needed. */ | |
xError = FF_ReleaseBuffer( pxFile->pxIOManager, pxBuffer ); | |
pxFile->ulFilePointer += ulCount; | |
ulBytesRead = ulCount; | |
} | |
} | |
#endif | |
*pxError = xError; | |
return ulBytesRead; | |
} /* FF_ReadPartial() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Equivalent to fread() | |
* | |
* @param pxFile FF_FILE object that was created by FF_Open(). | |
* @param ulElementSize The size of an element to read. | |
* @param ulCount The number of elements to read. | |
* @param buffer A pointer to a buffer of adequate size to be filled with the requested data. | |
* | |
* @return Number of bytes read. | |
* | |
* FF_Read() and FF_Write() work very similar. They both complete their task in 5 steps: | |
* 1. Read bytes up to a sector border: FF_ReadPartial() | |
* 2. Read sectors up to cluster border: FF_BlockRead() | |
* 3. Read complete clusters: FF_ReadClusters() | |
* 4. Read remaining sectors: FF_BlockRead() | |
* 5. Read remaining bytes: FF_ReadPartial() | |
**/ | |
int32_t FF_Read( FF_FILE *pxFile, uint32_t ulElementSize, uint32_t ulCount, uint8_t *pucBuffer ) | |
{ | |
uint32_t ulBytesLeft = ulElementSize * ulCount; | |
uint32_t ulBytesRead = 0; | |
uint32_t ulBytesToRead; | |
FF_IOManager_t *pxIOManager; | |
uint32_t ulRelBlockPos; | |
uint32_t ulItemLBA; | |
int32_t lResult; | |
uint32_t ulSectors; | |
uint32_t ulRelClusterPos; | |
uint32_t ulBytesPerCluster; | |
FF_Error_t xError; | |
if( pxFile == NULL ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_NULL_POINTER | FF_READ ); | |
} | |
else | |
{ | |
/* Check validity of the handle and the current position within the file. */ | |
xError = FF_CheckValid( pxFile ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
if( ( pxFile->ucMode & FF_MODE_READ ) == 0 ) | |
{ | |
/* File was not opened with READ mode access. */ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_NOT_OPENED_IN_READ_MODE | FF_READ ); | |
} | |
else if( pxFile->ulFilePointer >= pxFile->ulFileSize ) | |
{ | |
/* The end-of-file is reached. The error READ_ZERO will not be | |
returned, it is just used to avoid further processing. */ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_READ_ZERO | FF_READ ); | |
} | |
else if( ( pxFile->ulFilePointer + ulBytesLeft ) > pxFile->ulFileSize ) | |
{ | |
/* Note that many bytes can be read. */ | |
ulBytesLeft = pxFile->ulFileSize - pxFile->ulFilePointer; | |
} | |
} | |
else | |
{ | |
/* The file handle is not valid. */ | |
} | |
} /* else pxFile != NULL */ | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
pxIOManager = pxFile->pxIOManager; | |
/* And calculate the Logical Block Address. */ | |
ulItemLBA = FF_SetCluster( pxFile, &xError ); | |
/* Get the position within a block. */ | |
ulRelBlockPos = FF_getMinorBlockEntry( pxIOManager, pxFile->ulFilePointer, 1 ); | |
/* Open a do {} while( 0 ) loop to allow easy breaks: */ | |
do | |
{ | |
if( ( ulRelBlockPos + ulBytesLeft ) <= ( uint32_t ) pxIOManager->usSectorSize ) | |
{ | |
/*---------- A small read within the current block only. */ | |
ulBytesRead = FF_ReadPartial( pxFile, ulItemLBA, ulRelBlockPos, ulBytesLeft, pucBuffer, &xError ); | |
break; | |
} | |
/*---------- Read (memcpy) to a Sector Boundary. */ | |
if( ulRelBlockPos != 0 ) | |
{ | |
/* Not on a sector boundary, at this point the LBA is known. */ | |
ulBytesToRead = pxIOManager->usSectorSize - ulRelBlockPos; | |
ulBytesRead = FF_ReadPartial( pxFile, ulItemLBA, ulRelBlockPos, ulBytesToRead, pucBuffer, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
ulBytesLeft -= ulBytesRead; | |
pucBuffer += ulBytesRead; | |
} | |
/*---------- Read sectors, up to a Cluster Boundary. */ | |
ulBytesPerCluster = ( pxIOManager->xPartition.ulSectorsPerCluster * pxIOManager->usSectorSize ); | |
ulRelClusterPos = pxFile->ulFilePointer % ( ulBytesPerCluster * pxIOManager->xPartition.ucBlkFactor ); | |
if( ( ulRelClusterPos != 0 ) && ( ( ulRelClusterPos + ulBytesLeft ) >= ulBytesPerCluster ) ) | |
{ | |
/* Need to get to cluster boundary. */ | |
ulItemLBA = FF_SetCluster( pxFile, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
ulSectors = pxIOManager->xPartition.ulSectorsPerCluster - ( ulRelClusterPos / pxIOManager->usSectorSize ); | |
xError = FF_BlockRead( pxIOManager, ulItemLBA, ulSectors, pucBuffer, pdFALSE ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
ulBytesToRead = ulSectors * pxIOManager->usSectorSize; | |
ulBytesLeft -= ulBytesToRead; | |
pucBuffer += ulBytesToRead; | |
ulBytesRead += ulBytesToRead; | |
pxFile->ulFilePointer += ulBytesToRead; | |
} | |
/*---------- Read entire clusters. */ | |
if( ulBytesLeft >= ulBytesPerCluster ) | |
{ | |
uint32_t ulClusters; | |
FF_SetCluster( pxFile, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
ulClusters = ulBytesLeft / ulBytesPerCluster; | |
xError = FF_ReadClusters( pxFile, ulClusters, pucBuffer ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
ulBytesToRead = ulBytesPerCluster * ulClusters; | |
pxFile->ulFilePointer += ulBytesToRead; | |
ulBytesLeft -= ulBytesToRead; | |
pucBuffer += ulBytesToRead; | |
ulBytesRead += ulBytesToRead; | |
} | |
/*---------- Read Remaining Blocks. */ | |
while( ulBytesLeft >= ( uint32_t ) pxIOManager->usSectorSize ) | |
{ | |
ulSectors = ulBytesLeft / pxIOManager->usSectorSize; | |
{ | |
/* HT: I'd leave these pPart/ulOffset for readability */ | |
/* and shorter code lines */ | |
FF_Partition_t *pPart = &( pxIOManager->xPartition ); | |
uint32_t ulOffset = ( pxFile->ulFilePointer / pxIOManager->usSectorSize ) % pPart->ulSectorsPerCluster; | |
uint32_t ulRemain = pPart->ulSectorsPerCluster - ulOffset; | |
if( ulSectors > ulRemain ) | |
{ | |
ulSectors = ulRemain; | |
} | |
} | |
ulItemLBA = FF_SetCluster( pxFile, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
xError = FF_BlockRead( pxIOManager, ulItemLBA, ulSectors, pucBuffer, pdFALSE ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
ulBytesToRead = ulSectors * pxIOManager->usSectorSize; | |
pxFile->ulFilePointer += ulBytesToRead; | |
ulBytesLeft -= ulBytesToRead; | |
pucBuffer += ulBytesToRead; | |
ulBytesRead += ulBytesToRead; | |
} | |
/*---------- Read (memcpy) Remaining Bytes */ | |
if( ulBytesLeft == 0 ) | |
{ | |
break; | |
} | |
ulItemLBA = FF_SetCluster( pxFile, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
/* Bytes to read are within a block and less than a block size. */ | |
FF_ReadPartial( pxFile, ulItemLBA, 0, ulBytesLeft, pucBuffer, &xError ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
ulBytesRead += ulBytesLeft; | |
} | |
} | |
while( pdFALSE ); | |
} /* if( FF_isERR( xError ) == pdFALSE ) */ | |
if( FF_GETERROR( xError ) == FF_ERR_FILE_READ_ZERO ) | |
{ | |
lResult = 0; | |
} | |
else if( FF_isERR( xError ) ) | |
{ | |
lResult = xError; | |
} | |
else | |
{ | |
lResult = ( int32_t )( ulBytesRead / ulElementSize ); | |
} | |
return lResult; | |
} /* FF_Read() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Equivalent to fgetc() | |
* | |
* @param pxFile FF_FILE object that was created by FF_Open(). | |
* | |
* @return The character that was read (cast as a 32-bit interger). -1 on EOF. | |
* @return FF_Error_t code. (Check with if(FF_isERR(xRetVal)) {}). | |
* @return -1 EOF (end of file). | |
* | |
**/ | |
int32_t FF_GetC( FF_FILE *pxFile ) | |
{ | |
uint32_t ulItemLBA; | |
uint8_t ucReturnedChar; | |
uint32_t ulRelBlockPos; | |
FF_Error_t xResult; | |
if( pxFile == NULL ) | |
{ | |
xResult = FF_ERR_NULL_POINTER | FF_GETC; /* Ensure this is a signed error. */ | |
} | |
else if( ( pxFile->ucMode & FF_MODE_READ ) == 0 ) | |
{ | |
xResult = FF_ERR_FILE_NOT_OPENED_IN_READ_MODE | FF_GETC; | |
} | |
else if( pxFile->ulFilePointer >= pxFile->ulFileSize ) | |
{ | |
/* The end-of-file is reached. The error READ_ZERO will not be | |
returned, it is just used to avoid further processing. */ | |
xResult = FF_ERR_FILE_READ_ZERO | FF_READ; | |
} | |
else | |
{ | |
ulRelBlockPos = FF_getMinorBlockEntry( pxFile->pxIOManager, pxFile->ulFilePointer, 1 ); | |
ulItemLBA = FF_SetCluster( pxFile, &xResult ); | |
if( FF_isERR( xResult ) == pdFALSE ) | |
{ | |
FF_ReadPartial( pxFile, ulItemLBA, ulRelBlockPos, 1, &ucReturnedChar, &xResult ); | |
if( FF_isERR( xResult ) == pdFALSE ) | |
{ | |
xResult = ( int32_t ) ( ( uint32_t ) ucReturnedChar ); | |
} | |
} | |
} | |
return ( int32_t ) xResult; | |
} /* FF_GetC() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Gets a Line from a Text File, but no more than ulLimit characters. The line will be NULL terminated. | |
* | |
* The behaviour of this function is undefined when called on a binary file. | |
* It should just read in ulLimit bytes of binary, and ZERO terminate the line. | |
* | |
* This function works for both UNIX line feeds, and Windows CRLF type files. | |
* | |
* @param pxFile The FF_FILE object pointer. | |
* @param szLine The character buffer where the line should be stored. | |
* @param ulLimit This should be the max number of characters that szLine can hold. | |
* | |
* @return The number of characters read from the line, on success. | |
* @return 0 when no more lines are available, or when ulLimit is 0. | |
* @return FF_ERR_NULL_POINTER if pxFile or szLine are NULL; | |
* | |
**/ | |
int32_t FF_GetLine( FF_FILE *pxFile, char *pcLine, uint32_t ulLimit ) | |
{ | |
int32_t iChar = 0; | |
BaseType_t xIndex; | |
FF_Error_t xResult = FF_ERR_NONE; | |
if( ( pxFile == NULL ) || ( pcLine == NULL ) ) | |
{ | |
xResult = FF_ERR_NULL_POINTER | FF_GETLINE; | |
} | |
else | |
{ | |
for( xIndex = 0; xIndex < ( BaseType_t ) ( ulLimit - 1 ); ++xIndex ) | |
{ | |
iChar = FF_GetC( pxFile ); | |
if( FF_isERR( iChar ) == pdFALSE ) | |
{ | |
pcLine[ xIndex ] = ( char ) iChar; | |
if( iChar == '\n' ) | |
{ | |
/* Read until the first linefeed. Move xIndex forward so the | |
null terminator does not overwrite the \n. xIndex must be less | |
thank ( ulLimit - 1 ), so incrementing it here cannot make it | |
greater than ulLimit - 1, so the NULL can be inserted without | |
overflowing the buffer. */ | |
xIndex++; | |
break; | |
} | |
} | |
else | |
{ | |
if( ( FF_GETERROR( iChar ) == FF_ERR_FILE_READ_ZERO ) && ( xIndex > 0 ) ) | |
{ | |
/* Although FF_GetC() returns an End Of File, | |
the last few characters will be returned first. */ | |
iChar = xIndex; | |
} | |
break; | |
} | |
} | |
/* Make sure that the resulting string always ends with a zero: */ | |
pcLine[ xIndex ] = '\0'; | |
/*_RB_ In some paths this will be the second time FF_isERR() is called | |
on the same value. */ | |
if( FF_isERR( iChar ) == pdFALSE ) | |
{ | |
/* Return the number of bytes read. */ | |
xResult = xIndex; | |
} | |
else | |
{ | |
/* Return iChar as an error code (see FF_GetC()). */ | |
xResult = iChar; | |
} | |
} | |
return xResult; | |
} /* FF_GetLine() */ | |
/*-----------------------------------------------------------*/ | |
static int32_t FF_WritePartial( FF_FILE *pxFile, uint32_t ulItemLBA, uint32_t ulRelBlockPos, uint32_t ulCount, | |
const uint8_t *pucBuffer, FF_Error_t *pxError ) | |
{ | |
FF_Error_t xError; | |
uint32_t ulBytesWritten; | |
#if( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) | |
{ | |
BaseType_t xLastRead; | |
if( ( ulRelBlockPos + ulCount ) >= ( uint32_t ) pxFile->pxIOManager->usSectorSize ) | |
{ | |
/* After this read, ulFilePointer will point to the next block/sector. */ | |
xLastRead = pdTRUE; | |
} | |
else | |
{ | |
/* It is not the last read within this block/sector. */ | |
xLastRead = pdFALSE; | |
} | |
if( ( ( pxFile->ucState & FF_BUFSTATE_VALID ) == 0 ) && | |
( ( ulRelBlockPos != 0 ) || ( pxFile->ulFilePointer < pxFile->ulFileSize ) ) ) | |
{ | |
xError = FF_BlockRead( pxFile->pxIOManager, ulItemLBA, 1, pxFile->pucBuffer, pdFALSE ); | |
/* pxFile->ucState will be set later on. */ | |
} | |
else | |
{ | |
xError = FF_ERR_NONE; | |
/* the buffer is valid or a whole block/sector will be written, so it is | |
not necessary to read the contents first. */ | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
memcpy( pxFile->pucBuffer + ulRelBlockPos, pucBuffer, ulCount ); | |
if( xLastRead == pdTRUE ) | |
{ | |
xError = FF_BlockWrite( pxFile->pxIOManager, ulItemLBA, 1, pxFile->pucBuffer, pdFALSE ); | |
pxFile->ucState = FF_BUFSTATE_INVALID; | |
} | |
else | |
{ | |
pxFile->ucState |= FF_BUFSTATE_WRITTEN | FF_BUFSTATE_VALID; | |
} | |
} | |
else | |
{ | |
pxFile->ucState = FF_BUFSTATE_INVALID; | |
} | |
} | |
#else | |
{ | |
FF_Buffer_t *pxBuffer; | |
if( ( ulRelBlockPos == 0 ) && ( pxFile->ulFilePointer >= pxFile->ulFileSize ) ) | |
{ | |
/* An entire sector will be written. */ | |
pxBuffer = FF_GetBuffer( pxFile->pxIOManager, ulItemLBA, FF_MODE_WR_ONLY ); | |
} | |
else | |
{ | |
/* A partial write will be done, make sure to read the contents before | |
changing anything. */ | |
pxBuffer = FF_GetBuffer( pxFile->pxIOManager, ulItemLBA, FF_MODE_WRITE ); | |
} | |
if( pxBuffer == NULL ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_DEVICE_DRIVER_FAILED | FF_WRITE ); | |
} | |
else | |
{ | |
/* Here we copy to the sector boundary. */ | |
memcpy( ( pxBuffer->pucBuffer + ulRelBlockPos ), pucBuffer, ulCount ); | |
xError = FF_ReleaseBuffer( pxFile->pxIOManager, pxBuffer ); | |
} | |
} | |
#endif | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
pxFile->ulFilePointer += ulCount; | |
ulBytesWritten = ulCount; | |
if( pxFile->ulFilePointer > pxFile->ulFileSize ) | |
{ | |
pxFile->ulFileSize = pxFile->ulFilePointer; | |
} | |
} | |
else | |
{ | |
ulBytesWritten = 0ul; | |
} | |
*pxError = xError; | |
return ulBytesWritten; | |
} /* FF_WritePartial() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Writes data to a File. | |
* | |
* @param pxFile FILE Pointer. | |
* @param ulElementSize Size of an Element of Data to be copied. (in bytes). | |
* @param ulCount Number of Elements of Data to be copied. (ulElementSize * ulCount must not exceed ((2^31)-1) bytes. (2GB). For best performance, multiples of 512 bytes or Cluster sizes are best. | |
* @param pucBuffer Byte-wise pucBuffer containing the data to be written. | |
* | |
* FF_Read() and FF_Write() work very similar. They both complete their task in 5 steps: | |
* 1. Write bytes up to a sector border: FF_WritePartial() | |
* 2. Write sectors up to cluster border: FF_BlockWrite() | |
* 3. Write complete clusters: FF_WriteClusters() | |
* 4. Write remaining sectors: FF_BlockWrite() | |
* 5. Write remaining bytes: FF_WritePartial() | |
* @return | |
**/ | |
int32_t FF_Write( FF_FILE *pxFile, uint32_t ulElementSize, uint32_t ulCount, uint8_t *pucBuffer ) | |
{ | |
uint32_t ulBytesLeft = ulElementSize * ulCount; | |
uint32_t nBytesWritten = 0; | |
uint32_t nBytesToWrite; | |
FF_IOManager_t *pxIOManager; | |
uint32_t ulRelBlockPos; | |
uint32_t ulItemLBA; | |
int32_t lResult; | |
uint32_t ulSectors; | |
uint32_t ulRelClusterPos; | |
uint32_t ulBytesPerCluster; | |
FF_Error_t xError; | |
if( pxFile == NULL ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_NULL_POINTER | FF_READ ); | |
} | |
else | |
{ | |
/* Check validity of the handle and the current position within the file. */ | |
xError = FF_CheckValid( pxFile ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
if( ( pxFile->ucMode & FF_MODE_WRITE ) == 0 ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_NOT_OPENED_IN_WRITE_MODE | FF_WRITE ); | |
} | |
/* Make sure a write is after the append point. */ | |
else if( ( pxFile->ucMode & FF_MODE_APPEND ) != 0 ) | |
{ | |
if( pxFile->ulFilePointer < pxFile->ulFileSize ) | |
{ | |
xError = FF_Seek( pxFile, 0, FF_SEEK_END ); | |
} | |
} | |
} | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
pxIOManager = pxFile->pxIOManager; | |
/* Open a do{} while( 0 ) loop to allow the use of breaks */ | |
do | |
{ | |
/* Extend File for at least ulBytesLeft! | |
Handle file-space allocation | |
+ 1 byte because the code assumes there is always a next cluster */ | |
xError = FF_ExtendFile( pxFile, pxFile->ulFilePointer + ulBytesLeft + 1 ); | |
if( FF_isERR( xError ) ) | |
{ | |
/* On every error, break from the while( 0 ) loop. */ | |
break; | |
} | |
ulRelBlockPos = FF_getMinorBlockEntry( pxIOManager, pxFile->ulFilePointer, 1 ); /* Get the position within a block. */ | |
ulItemLBA = FF_SetCluster( pxFile, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
if( ( ulRelBlockPos + ulBytesLeft ) <= ( uint32_t ) pxIOManager->usSectorSize ) | |
{ | |
/* Bytes to write are within a block and and do not go passed the current block. */ | |
nBytesWritten = FF_WritePartial( pxFile, ulItemLBA, ulRelBlockPos, ulBytesLeft, pucBuffer, &xError ); | |
break; | |
} | |
/*---------- Write (memcpy) to a Sector Boundary. */ | |
if( ulRelBlockPos != 0 ) | |
{ | |
/* Not writing on a sector boundary, at this point the LBA is known. */ | |
nBytesToWrite = pxIOManager->usSectorSize - ulRelBlockPos; | |
nBytesWritten = FF_WritePartial( pxFile, ulItemLBA, ulRelBlockPos, nBytesToWrite, pucBuffer, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
ulBytesLeft -= nBytesWritten; | |
pucBuffer += nBytesWritten; | |
} | |
/*---------- Write sectors, up to a Cluster Boundary. */ | |
ulBytesPerCluster = ( pxIOManager->xPartition.ulSectorsPerCluster * pxIOManager->usSectorSize ); | |
ulRelClusterPos = FF_getClusterPosition( pxIOManager, pxFile->ulFilePointer, 1 ); | |
if( ( ulRelClusterPos != 0 ) && ( ( ulRelClusterPos + ulBytesLeft ) >= ulBytesPerCluster ) ) | |
{ | |
/* Need to get to cluster boundary */ | |
ulItemLBA = FF_SetCluster( pxFile, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
ulSectors = pxIOManager->xPartition.ulSectorsPerCluster - ( ulRelClusterPos / pxIOManager->usSectorSize ); | |
xError = FF_BlockWrite( pxIOManager, ulItemLBA, ulSectors, pucBuffer, pdFALSE ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
nBytesToWrite = ulSectors * pxIOManager->usSectorSize; | |
ulBytesLeft -= nBytesToWrite; | |
pucBuffer += nBytesToWrite; | |
nBytesWritten += nBytesToWrite; | |
pxFile->ulFilePointer += nBytesToWrite; | |
if( pxFile->ulFilePointer > pxFile->ulFileSize ) | |
{ | |
pxFile->ulFileSize = pxFile->ulFilePointer; | |
} | |
} | |
/*---------- Write entire Clusters. */ | |
if( ulBytesLeft >= ulBytesPerCluster ) | |
{ | |
uint32_t ulClusters; | |
FF_SetCluster( pxFile, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
ulClusters = ( ulBytesLeft / ulBytesPerCluster ); | |
xError = FF_WriteClusters( pxFile, ulClusters, pucBuffer ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
nBytesToWrite = ulBytesPerCluster * ulClusters; | |
ulBytesLeft -= nBytesToWrite; | |
pucBuffer += nBytesToWrite; | |
nBytesWritten += nBytesToWrite; | |
pxFile->ulFilePointer += nBytesToWrite; | |
if( pxFile->ulFilePointer > pxFile->ulFileSize ) | |
{ | |
pxFile->ulFileSize = pxFile->ulFilePointer; | |
} | |
} | |
/*---------- Write Remaining Blocks */ | |
while( ulBytesLeft >= ( uint32_t ) pxIOManager->usSectorSize ) | |
{ | |
ulSectors = ulBytesLeft / pxIOManager->usSectorSize; | |
{ | |
/* HT: I'd leave these pPart/ulOffset for readability... */ | |
FF_Partition_t *pPart = &( pxIOManager->xPartition ); | |
uint32_t ulOffset = ( pxFile->ulFilePointer / pxIOManager->usSectorSize ) % pPart->ulSectorsPerCluster; | |
uint32_t ulRemain = pPart->ulSectorsPerCluster - ulOffset; | |
if( ulSectors > ulRemain ) | |
{ | |
ulSectors = ulRemain; | |
} | |
} | |
ulItemLBA = FF_SetCluster( pxFile, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
xError = FF_BlockWrite( pxIOManager, ulItemLBA, ulSectors, pucBuffer, pdFALSE ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
nBytesToWrite = ulSectors * pxIOManager->usSectorSize; | |
ulBytesLeft -= nBytesToWrite; | |
pucBuffer += nBytesToWrite; | |
nBytesWritten += nBytesToWrite; | |
pxFile->ulFilePointer += nBytesToWrite; | |
if( pxFile->ulFilePointer > pxFile->ulFileSize ) | |
{ | |
pxFile->ulFileSize = pxFile->ulFilePointer; | |
} | |
} | |
/*---------- Write (memcpy) Remaining Bytes */ | |
if( ulBytesLeft == 0 ) | |
{ | |
break; | |
} | |
ulItemLBA = FF_SetCluster( pxFile, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
FF_WritePartial( pxFile, ulItemLBA, 0, ulBytesLeft, pucBuffer, &xError ); | |
nBytesWritten += ulBytesLeft; | |
} | |
while( pdFALSE ); | |
} | |
if( FF_isERR( xError ) ) | |
{ | |
lResult = xError; | |
} | |
else | |
{ | |
lResult = ( int32_t )( nBytesWritten / ulElementSize ); | |
} | |
return lResult; | |
} /* FF_Write() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Writes a char to a FILE. | |
* | |
* @param pxFile FILE Pointer. | |
* @param ucValue Char to be placed in the file. | |
* | |
* @return Returns the value written to the file, or a value less than 0. | |
* | |
**/ | |
int32_t FF_PutC( FF_FILE *pxFile, uint8_t ucValue ) | |
{ | |
uint32_t ulItemLBA; | |
uint32_t ulRelBlockPos; | |
FF_Error_t xResult; | |
if( pxFile == NULL ) | |
{ /* Ensure we don't have a Null file pointer on a Public interface. */ | |
xResult = FF_ERR_NULL_POINTER | FF_PUTC; | |
} | |
else if( ( pxFile->ucMode & FF_MODE_WRITE ) == 0 ) | |
{ | |
xResult = FF_ERR_FILE_NOT_OPENED_IN_WRITE_MODE | FF_PUTC; | |
} | |
else | |
{ | |
xResult = FF_ERR_NONE; | |
do | |
{ | |
/* Make sure a write is after the append point. */ | |
if( ( pxFile->ucMode & FF_MODE_APPEND ) != 0 ) | |
{ | |
if( pxFile->ulFilePointer < pxFile->ulFileSize ) | |
{ | |
xResult = FF_Seek( pxFile, 0, FF_SEEK_END ); | |
if( FF_isERR( xResult ) ) | |
{ | |
break; | |
} | |
} | |
} | |
ulRelBlockPos = FF_getMinorBlockEntry( pxFile->pxIOManager, pxFile->ulFilePointer, 1 ); | |
/* Handle File Space Allocation. */ | |
/* We'll write 1 byte and always have a next cluster reserved. */ | |
xResult = FF_ExtendFile( pxFile, pxFile->ulFilePointer + 2 ); | |
if( FF_isERR( xResult ) ) | |
{ | |
break; | |
} | |
ulItemLBA = FF_SetCluster( pxFile, &xResult ); | |
if( FF_isERR( xResult ) ) | |
{ | |
break; | |
} | |
FF_WritePartial( pxFile, ulItemLBA, ulRelBlockPos, 1, &ucValue, &xResult ); | |
if( FF_isERR( xResult ) == pdFALSE ) | |
{ | |
xResult = ( FF_Error_t ) ucValue; | |
} | |
} while( pdFALSE ); | |
} | |
return xResult; | |
} /* FF_PutC() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Equivalent to fseek() | |
* | |
* @param pxFile FF_FILE object that was created by FF_Open(). | |
* @param ulOffset An integer (+/-) to seek to, from the specified origin. | |
* @param xOrigin Where to seek from. (FF_SEEK_SET seek from start, FF_SEEK_CUR seek from current position, or FF_SEEK_END seek from end of file). | |
* | |
* @return 0 on Sucess, | |
* @return -2 if offset results in an invalid position in the file. | |
* @return FF_ERR_NULL_POINTER if a FF_FILE pointer was not received. | |
* @return -3 if an invalid origin was provided. | |
* | |
**/ | |
FF_Error_t FF_Seek( FF_FILE *pxFile, int32_t lOffset, BaseType_t xOrigin ) | |
{ | |
FF_Error_t xError; | |
uint32_t ulPosition = 0ul; | |
xError = FF_CheckValid( pxFile ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = FF_FlushCache( pxFile->pxIOManager ); | |
#if( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) | |
{ | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
/* Here we must ensure that if the user tries to seek, and we had data in the file's | |
write buffer that this is written to disk. */ | |
if( ( pxFile->ucState & FF_BUFSTATE_WRITTEN ) != 0 ) | |
{ | |
xError = FF_BlockWrite( pxFile->pxIOManager, FF_FileLBA( pxFile ), 1, pxFile->pucBuffer, pdFALSE ); | |
} | |
pxFile->ucState = FF_BUFSTATE_INVALID; | |
} | |
} | |
#endif /* ffconfigOPTIMISE_UNALIGNED_ACCESS */ | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
if( xOrigin == FF_SEEK_SET ) | |
{ | |
ulPosition = ( uint32_t )lOffset; | |
} | |
else if( xOrigin == FF_SEEK_CUR ) | |
{ | |
if( lOffset >= ( int32_t ) 0 ) | |
{ | |
ulPosition = pxFile->ulFilePointer + ( ( uint32_t ) lOffset ); | |
} | |
else | |
{ | |
ulPosition = pxFile->ulFilePointer - ( ( uint32_t ) ( -lOffset ) ); | |
} | |
} | |
else if( xOrigin == FF_SEEK_END ) | |
{ | |
/* 'FF_SEEK_END' only allows zero or negative values. */ | |
if( lOffset <= ( int32_t ) 0 ) | |
{ | |
ulPosition = pxFile->ulFileSize - ( ( uint32_t ) ( -lOffset ) ); | |
} | |
} | |
else | |
{ | |
xError = ( FF_Error_t ) ( FF_SEEK | FF_ERR_FILE_SEEK_INVALID_ORIGIN ); | |
/* To supress a compiler warning. */ | |
ulPosition = ( uint32_t ) 0u; | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
if( ulPosition <= ( uint32_t ) pxFile->ulFileSize ) | |
{ | |
if( ulPosition != ( uint32_t ) pxFile->ulFilePointer ) | |
{ | |
pxFile->ulFilePointer = ulPosition; | |
FF_SetCluster( pxFile, &xError ); | |
} | |
} | |
else | |
{ | |
xError = ( FF_Error_t ) ( FF_SEEK | FF_ERR_FILE_SEEK_INVALID_POSITION ); | |
} | |
} | |
} | |
} | |
return xError; | |
} /* FF_Seek() */ | |
/*-----------------------------------------------------------*/ | |
#if( ffconfigREMOVABLE_MEDIA != 0 ) | |
/** | |
* @public | |
* @brief Invalidate all file handles belonging to pxIOManager | |
* | |
* @param pIoMan FF_IOManager_t object that was created by FF_CreateIOManger(). | |
* | |
* @return 0 if no handles were open | |
* @return >0 the amount of handles that were invalidated | |
* @return <0 probably an invalid FF_IOManager_t pointer | |
* | |
**/ | |
int32_t FF_Invalidate( FF_IOManager_t *pxIOManager ) | |
{ | |
int32_t xResult; | |
FF_FILE *pxFileChain; | |
if( pxIOManager == NULL ) | |
{ | |
xResult = FF_ERR_NULL_POINTER | FF_INVALIDATE; | |
} | |
else | |
{ | |
xResult = 0; | |
FF_PendSemaphore( pxIOManager->pvSemaphore ); | |
{ | |
pxIOManager->ucFlags |= FF_IOMAN_DEVICE_IS_EXTRACTED; | |
/* Semaphore is required, or linked list might change */ | |
pxFileChain = ( FF_FILE * ) pxIOManager->FirstFile; | |
if( pxFileChain != NULL ) | |
{ | |
/* Count elements in FirstFile */ | |
do | |
{ | |
pxFileChain->ulValidFlags |= FF_VALID_FLAG_INVALID; | |
xResult++; | |
pxFileChain = pxFileChain->pxNext; | |
} | |
while( pxFileChain != NULL ); | |
} | |
} | |
FF_ReleaseSemaphore( pxIOManager->pvSemaphore ); | |
} | |
return xResult; | |
} /* FF_Invalidate() */ | |
#endif /* ffconfigREMOVABLE_MEDIA */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Check validity of file handle | |
* | |
* @param pxFile FF_FILE object that was created by FF_Open(). | |
* | |
* @return 0 on sucess. | |
* @return FF_ERR_NULL_POINTER if a null pointer was provided. | |
* @return FF_ERR_FILE_BAD_HANDLE if handle is not recognized | |
* @return FF_ERR_FILE_MEDIA_REMOVED please call FF_Close | |
* | |
**/ | |
FF_Error_t FF_CheckValid( FF_FILE *pxFile ) | |
{ | |
FF_FILE *pxFileChain; | |
FF_Error_t xError; | |
if( ( pxFile == NULL ) || ( pxFile->pxIOManager == NULL ) ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_NULL_POINTER | FF_CHECKVALID ); | |
} | |
else | |
{ | |
FF_PendSemaphore( pxFile->pxIOManager->pvSemaphore ); | |
{ | |
pxFileChain = ( FF_FILE * ) pxFile->pxIOManager->FirstFile; | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_BAD_HANDLE | FF_CHECKVALID ); | |
while( pxFileChain != NULL ) | |
{ | |
if( pxFileChain == pxFile ) | |
{ | |
#if( ffconfigREMOVABLE_MEDIA != 0 ) | |
if( ( pxFileChain->ulValidFlags & FF_VALID_FLAG_INVALID ) != 0 ) | |
{ | |
/* The medium has been removed while this file handle was open. */ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_MEDIA_REMOVED | FF_CHECKVALID ); | |
} | |
else | |
#endif | |
{ | |
/* Found the handle, so it is a valid / existing handle. */ | |
xError = FF_ERR_NONE; | |
} | |
break; | |
} | |
pxFileChain = pxFileChain->pxNext; | |
} | |
} | |
FF_ReleaseSemaphore( pxFile->pxIOManager->pvSemaphore ); | |
} | |
return xError; | |
} /* FF_CheckValid() */ | |
/*-----------------------------------------------------------*/ | |
#if( ffconfigTIME_SUPPORT != 0 ) | |
/** | |
* @public | |
* @brief Set the time-stamp(s) of a file entry | |
* | |
* @param pxFile FF_FILE object that was created by FF_Open(). | |
* @param pxTime FF_SystemTime_t the time stamp | |
* @param uxWhat UBaseType_t a combination of enum ETimeMask | |
* | |
* @return 0 or FF_Error_t | |
* | |
**/ | |
FF_Error_t FF_SetFileTime( FF_FILE *pxFile, FF_SystemTime_t *pxTime, UBaseType_t uxWhat ) | |
{ | |
FF_DirEnt_t xOriginalEntry; | |
FF_Error_t xError; | |
xError = FF_CheckValid( pxFile ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
if( pxFile->ulValidFlags & FF_VALID_FLAG_DELETED ) | |
{ /*if (pxFile->FileDeleted) */ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_NOT_FOUND | FF_SETFILETIME ); | |
} | |
else if( ( pxFile->ucMode & ( FF_MODE_WRITE | FF_MODE_APPEND ) ) == 0 ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_NOT_OPENED_IN_WRITE_MODE | FF_SETFILETIME ); | |
} | |
else | |
{ | |
/* Update the Dirent! */ | |
xError = FF_GetEntry( pxFile->pxIOManager, pxFile->usDirEntry, pxFile->ulDirCluster, &xOriginalEntry ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
if( uxWhat & ETimeCreate ) | |
{ | |
xOriginalEntry.xCreateTime = *pxTime; /*/< Date and Time Created. */ | |
} | |
if( uxWhat & ETimeMod ) | |
{ | |
xOriginalEntry.xModifiedTime = *pxTime; /*/< Date and Time Modified. */ | |
} | |
if( uxWhat & ETimeAccess ) | |
{ | |
xOriginalEntry.xAccessedTime = *pxTime; /*/< Date of Last Access. */ | |
} | |
xError = FF_PutEntry( pxFile->pxIOManager, pxFile->usDirEntry, pxFile->ulDirCluster, &xOriginalEntry, NULL ); | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = FF_FlushCache( pxFile->pxIOManager ); /* Ensure all modfied blocks are flushed to disk! */ | |
} | |
} | |
} | |
return xError; | |
} /* FF_SetFileTime() */ | |
#endif /* ffconfigTIME_SUPPORT */ | |
/*-----------------------------------------------------------*/ | |
#if( ffconfigTIME_SUPPORT != 0 ) | |
/** | |
* @public | |
* @brief Set the time-stamp(s) of a file entry (by name) | |
* | |
* @param pxIOManager FF_IOManager_t device handle | |
* @param pcPath int8_t/FF_T_WCHAR name of the file | |
* @param pxTime FF_SystemTime_t the time stamp | |
* @param uxWhat UBaseType_t a combination of enum ETimeMask | |
* | |
* @return 0 or FF_Error_t | |
* | |
**/ | |
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) | |
FF_Error_t FF_SetTime ( FF_IOManager_t * pxIOManager, const FF_T_WCHAR * pcPath, FF_SystemTime_t *pxTime, UBaseType_t uxWhat ) | |
#else | |
FF_Error_t FF_SetTime ( FF_IOManager_t * pxIOManager, const char *pcPath, FF_SystemTime_t *pxTime, UBaseType_t uxWhat ) | |
#endif /* ffconfigUNICODE_UTF16_SUPPORT */ | |
{ | |
FF_DirEnt_t xOriginalEntry; | |
FF_Error_t xError; | |
uint32_t ulFileCluster; | |
BaseType_t xIndex; | |
FF_FindParams_t xFindParams; | |
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) | |
FF_T_WCHAR pcFileName[ffconfigMAX_FILENAME]; | |
#else | |
char pcFileName[ffconfigMAX_FILENAME]; | |
#endif /* ffconfigUNICODE_UTF16_SUPPORT */ | |
xIndex = ( BaseType_t ) STRLEN( pcPath ); | |
memset( &xFindParams, '\0', sizeof( xFindParams ) ); | |
while( xIndex != 0 ) | |
{ | |
if( pcPath[ xIndex ] == '\\' || pcPath[ xIndex ] == '/' ) | |
{ | |
break; | |
} | |
xIndex--; | |
} | |
STRNCPY( pcFileName, ( pcPath + xIndex + 1 ), ffconfigMAX_FILENAME ); | |
if( xIndex == 0 ) | |
{ | |
xIndex = 1; | |
} | |
xFindParams.ulDirCluster = FF_FindDir( pxIOManager, pcPath, ( uint16_t ) xIndex, &xError ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
if( xFindParams.ulDirCluster == 0 ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_NOT_FOUND | FF_SETTIME ); | |
} | |
else | |
{ | |
ulFileCluster = FF_FindEntryInDir( pxIOManager, &xFindParams, pcFileName, 0, &xOriginalEntry, &xError ); | |
if( ( FF_isERR( xError ) == pdFALSE ) || ( FF_GETERROR( xError ) == FF_ERR_DIR_END_OF_DIR ) ) | |
{ | |
if( ulFileCluster == 0ul ) | |
{ | |
/*FF_PRINTF ("FF_SetTime: Can not find '%s'\n", pcFileName); */ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_NOT_FOUND | FF_SETTIME ); | |
} | |
} | |
} | |
} | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
/* Update the Dirent! */ | |
if( uxWhat & ETimeCreate ) | |
{ | |
xOriginalEntry.xCreateTime = *pxTime; /*/< Date and Time Created. */ | |
} | |
if( uxWhat & ETimeMod ) | |
{ | |
xOriginalEntry.xModifiedTime = *pxTime; /*/< Date and Time Modified. */ | |
} | |
if( uxWhat & ETimeAccess ) | |
{ | |
xOriginalEntry.xAccessedTime = *pxTime; /*/< Date of Last Access. */ | |
} | |
xError = FF_PutEntry( pxIOManager, xOriginalEntry.usCurrentItem - 1, xFindParams.ulDirCluster, &xOriginalEntry, NULL ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = FF_FlushCache( pxIOManager ); /* Ensure all modified blocks are flushed to disk! */ | |
} | |
} | |
return xError; | |
} /* FF_SetTime() */ | |
#endif /* ffconfigTIME_SUPPORT */ | |
/*-----------------------------------------------------------*/ | |
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) | |
FF_Error_t FF_SetPerm( FF_IOManager_t * pxIOManager, const FF_T_WCHAR * pcPath, UBaseType_t aPerm ) | |
#else | |
FF_Error_t FF_SetPerm( FF_IOManager_t * pxIOManager, const char *pcPath, UBaseType_t aPerm ) | |
#endif | |
{ | |
FF_DirEnt_t xOriginalEntry; | |
FF_Error_t xError; | |
uint32_t ulFileCluster; | |
BaseType_t xIndex; | |
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) | |
FF_T_WCHAR pcFileName[ffconfigMAX_FILENAME]; | |
#else | |
char pcFileName[ffconfigMAX_FILENAME]; | |
#endif | |
FF_FindParams_t xFindParams; | |
xIndex = ( BaseType_t ) STRLEN( pcPath ); | |
memset( &xFindParams, '\0', sizeof( xFindParams ) ); | |
while( xIndex != 0 ) | |
{ | |
if( pcPath[ xIndex ] == '\\' || pcPath[ xIndex ] == '/' ) | |
{ | |
break; | |
} | |
xIndex--; | |
} | |
STRNCPY( pcFileName, ( pcPath + xIndex + 1 ), ffconfigMAX_FILENAME ); | |
if( xIndex == 0 ) | |
{ | |
xIndex = 1; | |
} | |
/* Open a do {} while( pdFALSE ) loop to allow the use of break statements. */ | |
do | |
{ | |
xFindParams.ulDirCluster = FF_FindDir( pxIOManager, pcPath, ( uint16_t ) xIndex, &xError ); | |
if( xError ) | |
{ | |
break; | |
} | |
if( !xFindParams.ulDirCluster ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_NOT_FOUND | FF_SETTIME ); | |
break; | |
} | |
ulFileCluster = FF_FindEntryInDir( pxIOManager, &xFindParams, pcFileName, 0, &xOriginalEntry, &xError ); | |
if( FF_isERR( xError ) ) | |
{ | |
break; | |
} | |
if( ulFileCluster == 0ul ) | |
{ | |
/*FF_PRINTF ("FF_SetTime: Can not find '%s'\n", pcFileName); */ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_NOT_FOUND | FF_SETTIME ); | |
break; | |
} | |
/* #define FF_FAT_ATTR_READONLY 0x01 */ | |
/* #define FF_FAT_ATTR_HIDDEN 0x02 */ | |
/* #define FF_FAT_ATTR_SYSTEM 0x04 */ | |
/* #define FF_FAT_ATTR_VOLID 0x08 */ | |
/* #define FF_FAT_ATTR_DIR 0x10 */ | |
/* #define FF_FAT_ATTR_ARCHIVE 0x20 */ | |
/* #define FF_FAT_ATTR_LFN 0x0F */ | |
#define FF_FAT_ATTR_USER ( ( uint8_t ) FF_FAT_ATTR_READONLY | FF_FAT_ATTR_HIDDEN | FF_FAT_ATTR_SYSTEM | FF_FAT_ATTR_ARCHIVE ) | |
/* Update the Dirent! */ | |
xOriginalEntry.ucAttrib &= ~FF_FAT_ATTR_USER; | |
xOriginalEntry.ucAttrib |= ( aPerm & FF_FAT_ATTR_USER ); | |
xError = FF_PutEntry( pxIOManager, xOriginalEntry.usCurrentItem - 1, xFindParams.ulDirCluster, &xOriginalEntry, NULL ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = FF_FlushCache( pxIOManager ); /* Ensure all modfied blocks are flushed to disk! */ | |
} | |
} | |
while( pdFALSE ); | |
return xError; | |
} /* FF_SetPerm() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Equivalent to fclose() | |
* | |
* @param pxFile FF_FILE object that was created by FF_Open(). | |
* | |
* @return 0 on sucess. | |
* @return -1 if a null pointer was provided. | |
* | |
**/ | |
FF_Error_t FF_Close( FF_FILE *pxFile ) | |
{ | |
FF_FILE *pxFileChain; | |
FF_DirEnt_t xOriginalEntry; | |
FF_Error_t xError; | |
/* Opening a do {} while( 0 ) loop to allow the use of the break statement. */ | |
do | |
{ | |
if( pxFile == NULL ) | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_NULL_POINTER | FF_CLOSE ); | |
break; | |
} | |
/* It is important to check that user doesn't supply invalid | |
handle or a handle invalid because of "media removed" */ | |
xError = FF_CheckValid( pxFile ); | |
#if( ffconfigREMOVABLE_MEDIA != 0 ) | |
{ | |
if( FF_GETERROR( xError ) == FF_ERR_FILE_MEDIA_REMOVED ) | |
{ | |
FF_PendSemaphore( pxFile->pxIOManager->pvSemaphore ); | |
{ | |
pxFileChain = ( FF_FILE * ) pxFile->pxIOManager->FirstFile; | |
if( pxFileChain == pxFile ) | |
{ | |
pxFile->pxIOManager->FirstFile = pxFile->pxNext; | |
} | |
else | |
{ | |
while( pxFileChain ) | |
{ | |
if( pxFileChain->pxNext == pxFile ) | |
{ | |
pxFileChain->pxNext = pxFile->pxNext; | |
break; | |
} | |
pxFileChain = pxFileChain->pxNext; /* Forgot this one */ | |
} | |
} | |
} /* Semaphore released, linked list was shortened! */ | |
FF_ReleaseSemaphore( pxFile->pxIOManager->pvSemaphore ); | |
#if( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) | |
{ | |
ffconfigFREE( pxFile->pucBuffer ); | |
} | |
#endif /* ffconfigOPTIMISE_UNALIGNED_ACCESS */ | |
ffconfigFREE( pxFile ); /* So at least we have freed the pointer. */ | |
xError = FF_ERR_NONE; | |
break; | |
} | |
} | |
#endif /* ffconfigREMOVABLE_MEDIA */ | |
if( FF_isERR( xError ) ) | |
{ | |
/* FF_ERR_FILE_BAD_HANDLE or FF_ERR_NULL_POINTER */ | |
break; | |
} | |
/* So here we have a normal valid file handle. */ | |
/* Sometimes FreeRTOS+FAT will leave a trailing cluster on the end of a cluster chain. | |
To ensure we're compliant we shall now check for this condition and truncate it. */ | |
if( ( ( pxFile->ulValidFlags & FF_VALID_FLAG_DELETED ) == 0 ) && | |
( ( pxFile->ucMode & ( FF_MODE_WRITE | FF_MODE_APPEND | FF_MODE_CREATE ) ) != 0 ) ) | |
{ | |
uint32_t ulClusterSize; | |
/* File is not deleted and it was opened for writing or updating */ | |
ulClusterSize = pxFile->pxIOManager->xPartition.usBlkSize * pxFile->pxIOManager->xPartition.ulSectorsPerCluster; | |
if( ( ( pxFile->ulFileSize % ulClusterSize ) == 0 ) && ( pxFile->ulObjectCluster != 0ul ) ) | |
{ | |
/* The file's length is a multiple of cluster size. This means | |
that an extra cluster has been reserved, which wasn't necessary. */ | |
xError = FF_Truncate( pxFile, pdTRUE ); | |
} | |
/* Get the directory entry and update it to show the new file size */ | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = FF_GetEntry( pxFile->pxIOManager, pxFile->usDirEntry, pxFile->ulDirCluster, &xOriginalEntry ); | |
/* Now update the directory entry */ | |
if( ( FF_isERR( xError ) == pdFALSE ) && | |
( ( pxFile->ulFileSize != xOriginalEntry.ulFileSize ) || ( pxFile->ulFileSize == 0UL ) ) ) | |
{ | |
if( pxFile->ulFileSize == 0UL ) | |
{ | |
xOriginalEntry.ulObjectCluster = 0; | |
} | |
xOriginalEntry.ulFileSize = pxFile->ulFileSize; | |
xError = FF_PutEntry( pxFile->pxIOManager, pxFile->usDirEntry, pxFile->ulDirCluster, &xOriginalEntry, NULL ); | |
} | |
} | |
} | |
/* Handle Linked list! */ | |
FF_PendSemaphore( pxFile->pxIOManager->pvSemaphore ); | |
{ /* Semaphore is required, or linked list could become corrupted. */ | |
pxFileChain = ( FF_FILE * ) pxFile->pxIOManager->FirstFile; | |
if( pxFileChain == pxFile ) | |
{ | |
pxFile->pxIOManager->FirstFile = pxFile->pxNext; | |
} | |
else | |
{ | |
while( pxFileChain ) | |
{ | |
if( pxFileChain->pxNext == pxFile ) | |
{ | |
/* Found it, remove it from the list. */ | |
pxFileChain->pxNext = pxFile->pxNext; | |
break; | |
} | |
pxFileChain = pxFileChain->pxNext; | |
} | |
} | |
} /* Semaphore released, linked list was shortened! */ | |
FF_ReleaseSemaphore( pxFile->pxIOManager->pvSemaphore ); | |
#if( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) | |
{ | |
if( pxFile->pucBuffer != NULL ) | |
{ | |
/* Ensure any unaligned points are pushed to the disk! */ | |
if( pxFile->ucState & FF_BUFSTATE_WRITTEN ) | |
{ | |
FF_Error_t xTempError; | |
xTempError = FF_BlockWrite( pxFile->pxIOManager, FF_FileLBA( pxFile ), 1, pxFile->pucBuffer, pdFALSE ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = xTempError; | |
} | |
} | |
ffconfigFREE( pxFile->pucBuffer ); | |
} | |
} | |
#endif | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = FF_FlushCache( pxFile->pxIOManager ); /* Ensure all modified blocks are flushed to disk! */ | |
} | |
ffconfigFREE( pxFile ); | |
} | |
while( pdFALSE ); | |
return xError; | |
} /* FF_Close() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Make Filesize equal to the FilePointer and truncates the file to this position | |
* | |
* @param pxFile FF_FILE object that was created by FF_Open(). | |
* | |
* @return 0 on sucess. | |
* @return negative if some error occurred | |
* | |
**/ | |
FF_Error_t FF_SetEof( FF_FILE *pxFile ) | |
{ | |
FF_Error_t xError; | |
/* Check if the file was not deleted and if it was opened with write permissions: */ | |
if( ( ( pxFile->ulValidFlags & FF_VALID_FLAG_DELETED ) == 0 ) && | |
( ( pxFile->ucMode & ( FF_MODE_WRITE | FF_MODE_APPEND | FF_MODE_CREATE ) ) != 0 ) ) | |
{ | |
pxFile->ulFileSize = pxFile->ulFilePointer; | |
if( pxFile->ulObjectCluster != 0ul ) | |
{ | |
xError = FF_Truncate( pxFile, pdFALSE ); | |
} | |
else | |
{ | |
xError = FF_ERR_NONE; | |
} | |
} | |
else | |
{ | |
xError = ( FF_Error_t ) ( FF_ERR_FILE_NOT_OPENED_IN_WRITE_MODE | FF_SETEOF ); | |
} | |
return xError; | |
} /* FF_SetEof() */ | |
/*-----------------------------------------------------------*/ | |
/** | |
* @public | |
* @brief Truncate a file to 'pxFile->ulFileSize' | |
* | |
* @param pxFile FF_FILE object that was created by FF_Open(). | |
* | |
* @return 0 on sucess. | |
* @return negative if some error occurred | |
* | |
**/ | |
static FF_Error_t FF_Truncate( FF_FILE *pxFile, BaseType_t bClosing ) | |
{ | |
FF_Error_t xError; | |
FF_IOManager_t *pxIOManager = pxFile->pxIOManager; | |
uint32_t ulClusterSize; | |
uint32_t ulClusterCount; | |
uint32_t ulClustersNeeded; | |
/* The number of bytes contained in a cluster. */ | |
ulClusterSize = pxIOManager->xPartition.usBlkSize * pxIOManager->xPartition.ulSectorsPerCluster; | |
/* See how many clusters have been allocated. */ | |
ulClusterCount = FF_GetChainLength( pxIOManager, pxFile->ulObjectCluster, NULL, &xError ); | |
/* Calculate the actual number of clusters needed, rounding up */ | |
ulClustersNeeded = ( pxFile->ulFileSize + ulClusterSize - 1 ) / ulClusterSize; | |
if( bClosing != pdFALSE ) | |
{ | |
/* The handle will be closed after truncating. This function is called | |
because Filesize is an exact multiple of ulClusterSize. */ | |
ulClustersNeeded = pxFile->ulFileSize / ulClusterSize; | |
} | |
else | |
{ | |
/* This function is called to make the file size equal to the current | |
position within the file. Always keep an extra cluster to write to. */ | |
ulClustersNeeded = ( pxFile->ulFileSize + ulClusterSize ) / ulClusterSize; | |
} | |
/* First change the FAT chain. */ | |
if( ( FF_isERR( xError ) == pdFALSE ) && ( ulClusterCount > ulClustersNeeded ) ) | |
{ | |
if( ulClustersNeeded == 0ul ) | |
{ | |
FF_LockFAT( pxIOManager ); | |
{ | |
/* In FF_Truncate() */ | |
xError = FF_UnlinkClusterChain( pxIOManager, pxFile->ulObjectCluster, 0 ); | |
} | |
FF_UnlockFAT( pxIOManager ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
FF_DirEnt_t xOriginalEntry; | |
/* The directory denotes the address of the first data cluster of every file. | |
Now change it to 'ulAddrCurrentCluster': */ | |
xError = FF_GetEntry( pxIOManager, pxFile->usDirEntry, pxFile->ulDirCluster, &xOriginalEntry ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xOriginalEntry.ulObjectCluster = 0ul; | |
xError = FF_PutEntry( pxIOManager, pxFile->usDirEntry, pxFile->ulDirCluster, &xOriginalEntry, NULL ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
pxFile->ulObjectCluster = 0ul; | |
pxFile->ulChainLength = 0ul; | |
pxFile->ulCurrentCluster = 0ul; | |
pxFile->ulEndOfChain = 0ul; | |
} | |
} | |
} | |
} | |
else | |
{ | |
FF_LockFAT( pxIOManager ); | |
{ | |
uint32_t ulTruncateCluster = FF_TraverseFAT( pxIOManager, pxFile->ulObjectCluster, ulClustersNeeded - 1, &xError ); | |
if( FF_isERR( xError ) == pdFALSE ) | |
{ | |
xError = FF_UnlinkClusterChain( pxIOManager, ulTruncateCluster, 1 ); | |
} | |
} | |
FF_UnlockFAT( pxIOManager ); | |
} | |
} | |
return xError; | |
} /* FF_Truncate() */ | |
/*-----------------------------------------------------------*/ |