amt630hv160-sdk-release/amt630hv160-freertos-beta/FreeRTOS-Plus/FreeRTOS-FAT/ff_file.c

/*
 * FreeRTOS+FAT V2.3.3
 * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
 *
 * 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
 * https://github.com/FreeRTOS
 *
 */

/**
 *	@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 );

static FF_Error_t FF_ExtendFile( FF_FILE * pxFile,
								 uint32_t ulSize );

/*-----------------------------------------------------------*/

/**
 *	@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 /* if ( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) */
            {
                /* Remove compiler warnings. */
                ( void ) pxIOManager;
            }
        #endif /* if ( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) */
    }

    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( pxFile->ulFilePointer == pxFile->ulFileSize )
		{
			/* Writing at the end of a file, while new clusters have just been added.
			 * Make sure that the fields 'ulCurrentCluster' and 'ulAddrCurrentCluster' are
			 * set correctly.
			 */
			FF_Error_t xTempError = FF_ERR_NONE;
			uint32_t ulNewCluster = FF_getClusterChainNumber( pxIOManager, pxFile->ulFilePointer, 1 );

			FF_LockFAT( pxIOManager );
			{
				pxFile->ulAddrCurrentCluster = FF_TraverseFAT( pxIOManager, pxFile->ulObjectCluster, ulNewCluster, &( xTempError ) );
				pxFile->ulCurrentCluster = ulNewCluster;
			}
			FF_UnlockFAT( pxIOManager );

			if( FF_isERR( xError ) == pdFALSE )
			{
				xError = xTempError;
			}
		}
    } /* 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 > 1U )
        {
            ulSequentialClusters =
                FF_GetSequentialClusters( pxFile->pxIOManager, pxFile->ulAddrCurrentCluster, ulCount - 1, &xError );

            if( FF_isERR( xError ) )
            {
                break;
            }
        }
		else
		{
			/* Handling the last cluster which is a single one. */
		}

        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 /* if ( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) */
        {
            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 /* if ( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) */

    *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 /* if ( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) */
        {
            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 ( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) */

    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 ( ffconfigOPTIMISE_UNALIGNED_ACCESS != 0 ) */

        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() */
/*-----------------------------------------------------------*/