/*
 * FreeRTOS+FAT build 191128 - Note:  FreeRTOS+FAT is still in the lab!
 * Copyright (C) 2018 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
 * Authors include James Walmsley, Hein Tibosch and Richard Barry
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * https://www.FreeRTOS.org
 *
 */

/**
 *	@file		ff_dir.c
 *	@ingroup	DIR
 *
 *	@defgroup	DIR Handles Directory Traversal
 *	@brief		Handles DIR access and traversal.
 *
 *	Provides FindFirst() and FindNext() Interfaces
 **/

#include "ff_headers.h"

#include <stdio.h>

#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
#include <wchar.h>
#endif

#if defined( WIN32 )
	#define wcsicmp _wcsicmp
#else
	#define wcsicmp wcscasecmp
	#include <ctype.h>
#endif

/* Calculate a simple LFN checmsum. */
static uint8_t FF_CreateChkSum( const uint8_t *pa_pShortName );

static BaseType_t FF_ShortNameExists( FF_IOManager_t *pxIOManager, uint32_t ulDirCluster, char *pcShortName, FF_Error_t *pxError );

#if( ffconfigSHORTNAME_CASE != 0 )
	/* For short-name entries, NT/XP etc store case information in byte 0x0c
	 * Use this to show proper case of "README.txt" or "source.H".
	 */
	#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
		static void FF_CaseShortName( FF_T_WCHAR *pcName, uint8_t attrib );
	#else
		static void FF_CaseShortName( char *pcName, uint8_t attrib );
	#endif
#endif /* ffconfigSHORTNAME_CASE */

#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )

	/* For unicode, the short name can be expanded to wchar
	 * by inserting zero's.
	 */
	static void FF_ShortNameExpand( FF_T_WCHAR * );

#endif

/*
 * Transform a name as stored on disk "README__TXT"
 * to a nul-terminated string: "README.TXT", "FILE001".
 * A dot is only added if an extension is present.
 */
static void FF_ProcessShortName( char *pcName );

#if( ffconfigTIME_SUPPORT != 0 )
	static void FF_PlaceTime( uint8_t *pucEntryBuffer, uint32_t Offset, FF_SystemTime_t *pxTime );
	static void FF_PlaceDate( uint8_t *pucEntryBuffer, uint32_t Offset, FF_SystemTime_t *pxTime );
	static void FF_GetTime( FF_SystemTime_t *pxTime, const uint8_t *pucEntryBuffer, uint32_t ulOffset );
	static void FF_GetDate( FF_SystemTime_t *pxTime, const uint8_t *pucEntryBuffer, uint32_t ulOffset );
#endif /* ffconfigTIME_SUPPORT */
static FF_Error_t FF_Traverse( FF_IOManager_t *pxIOManager, uint32_t ulEntry, FF_FetchContext_t *pxContext );
static int32_t FF_FindFreeDirent( FF_IOManager_t *pxIOManager, FF_FindParams_t *pxFindParams, uint16_t usSequential );

#if( ffconfigLFN_SUPPORT != 0 )
	static int8_t FF_CreateLFNEntry( uint8_t *pucEntryBuffer, uint8_t *pcName, UBaseType_t uxNameLength, UBaseType_t uxLFN, uint8_t ucCheckSum );
#endif /* ffconfigLFN_SUPPORT */

static BaseType_t FF_ValidShortChar( char cChar );

#if( ffconfigLFN_SUPPORT != 0 )
	#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
		static FF_Error_t FF_CreateLFNs( FF_IOManager_t *pxIOManager, uint32_t ulDirCluster, FF_T_WCHAR *pcName, uint8_t ucCheckSum, uint16_t usEntry );
	#else
		static FF_Error_t FF_CreateLFNs( FF_IOManager_t *pxIOManager, uint32_t ulDirCluster, char *pcName, uint8_t ucCheckSum, uint16_t usEntry );
	#endif
#endif

#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	static void FF_MakeNameCompliant( FF_T_WCHAR *pcName );
#else
	static void FF_MakeNameCompliant( char *pcName );
#endif

#if ( FF_NOSTRCASECMP == 0 )
	static portINLINE unsigned char prvToLower( unsigned char c )
	{
	unsigned char cReturnChar;
		if( c >= 'A' && c <= 'Z' )
		{
			cReturnChar = c + 0x20;
		}
		else
		{
			cReturnChar = c;
		}

		return cReturnChar;
	}

	int strcasecmp( const char *pcString1, const char *pcString2 )
	{
		unsigned char c1,c2;
		do
		{
			c1 = *pcString1++;
			c2 = *pcString2++;
			c1 = ( unsigned char ) prvToLower( ( unsigned char ) c1 );
			c2 = ( unsigned char ) prvToLower( ( unsigned char ) c2 );
		}
		while( ( c1 == c2 ) && ( c1 != '\0' ) );

		return ( int ) c1 - c2;
	}	/* strcasecmp() */
#endif
/*-----------------------------------------------------------*/

static uint8_t FF_CreateChkSum( const uint8_t *pa_pShortName )
{
uint8_t	cNameLen;
uint8_t	ChkSum = 0;

	for( cNameLen = 11; cNameLen != 0; cNameLen-- )
	{
		ChkSum = ( uint8_t )
			( ( ( ChkSum & 1 ) ? 0x80 : 0 ) + ( ChkSum >> 1 ) + *( pa_pShortName++ ) );
	}

	return ChkSum;
}	/* FF_CreateChkSum() */
/*-----------------------------------------------------------*/

/* _HT_ Does not need a wchar version because a short name is treated  a normal string of bytes */
static BaseType_t FF_ShortNameExists( FF_IOManager_t *pxIOManager, uint32_t ulDirCluster, char *pcShortName, FF_Error_t *pxError )
{
BaseType_t xIndex;
const uint8_t *pucEntryBuffer = NULL; /* initialisation not necessary, just for the compiler */
uint8_t ucAttrib;
FF_FetchContext_t xFetchContext;
char pcMyShortName[ FF_SIZEOF_DIRECTORY_ENTRY ];
BaseType_t xResult = -1;

#if( ffconfigHASH_CACHE != 0 )
	uint32_t ulHash;
#endif

	*pxError = FF_ERR_NONE;

	#if( ffconfigHASH_CACHE != 0 )
	{
		if( !FF_DirHashed( pxIOManager, ulDirCluster ) )
		{
			/* Hash the directory. */
			FF_HashDir( pxIOManager, ulDirCluster );
		}

		#if ffconfigHASH_FUNCTION == CRC16
		{
			ulHash = ( uint32_t ) FF_GetCRC16( ( uint8_t * ) pcShortName, strlen( pcShortName ) );
		}
		#else /* ffconfigHASH_FUNCTION == CRC8 */
		{
			ulHash = ( uint32_t ) FF_GetCRC8( ( uint8_t * ) pcShortName, strlen( pcShortName ) );
		}
		#endif
		{
			/* FF_CheckDirentHash result: 0 not found, 1 found, -1 directory not hashed */
			xResult = FF_CheckDirentHash( pxIOManager, ulDirCluster, ulHash );
		}
	}
	#endif

	if( xResult < 0 )
	{
		xResult = pdFALSE;
		*pxError = FF_InitEntryFetch( pxIOManager, ulDirCluster, &xFetchContext );

		if( FF_isERR( *pxError ) == pdFALSE )
		{
			for( xIndex = 0; xIndex < FF_MAX_ENTRIES_PER_DIRECTORY; xIndex++ )
			{
				/* Call FF_FetchEntryWithContext only once for every 512-byte block */
				if( ( xIndex == 0 ) ||
					( pucEntryBuffer >= xFetchContext.pxBuffer->pucBuffer + ( FF_SIZEOF_SECTOR - FF_SIZEOF_DIRECTORY_ENTRY ) ) )
				{
					*pxError = FF_FetchEntryWithContext( pxIOManager, ( uint32_t ) xIndex, &xFetchContext, NULL );
					if( FF_isERR( *pxError ) )
					{
						break;
					}
					pucEntryBuffer = xFetchContext.pxBuffer->pucBuffer;
				}
				else
				{
					/* Advance 32 bytes to get the next directory entry. */
					pucEntryBuffer += FF_SIZEOF_DIRECTORY_ENTRY;
				}

				if( FF_isEndOfDir( pucEntryBuffer ) )
				{
					break;
				}
				if( FF_isDeleted( pucEntryBuffer ) == pdFALSE )
				{
					ucAttrib = FF_getChar( pucEntryBuffer, FF_FAT_DIRENT_ATTRIB );
					if( ( ucAttrib & FF_FAT_ATTR_LFN ) != FF_FAT_ATTR_LFN )
					{
						memcpy( pcMyShortName, pucEntryBuffer, sizeof( pcMyShortName ) );
						FF_ProcessShortName( pcMyShortName );
						if( strcmp( ( const char * )pcShortName, ( const char * )pcMyShortName ) == 0 )
						{
							xResult = pdTRUE;
							break;
						}
					}
				}
			} /* for ( xIndex = 0; xIndex < FF_MAX_ENTRIES_PER_DIRECTORY; xIndex++ ) */
		}
		*pxError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext );
	}

    return xResult;
}	/* FF_ShortNameExists() */
/*-----------------------------------------------------------*/

/* _HT_ When adding many files to a single directory, FF_FindEntryInDir was sometimes */
/* _HT_ called 3 times before inserting a single file. With these changes it is called one time only */
/* _HT_ pxFindParams caches some information: */
/* _HT_ 1: the first free entry 2: whether the short-name version already exists */
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
uint32_t FF_FindEntryInDir( FF_IOManager_t *pxIOManager, FF_FindParams_t *pxFindParams, const FF_T_WCHAR *pcName, uint8_t pa_Attrib, FF_DirEnt_t *pxDirEntry, FF_Error_t *pxError )
#else
uint32_t FF_FindEntryInDir( FF_IOManager_t *pxIOManager, FF_FindParams_t *pxFindParams, const char *pcName, uint8_t pa_Attrib, FF_DirEnt_t *pxDirEntry, FF_Error_t *pxError )
#endif
{
FF_FetchContext_t xFetchContext;
/* const pointer to read from pBuffer */
const uint8_t *src = NULL;
/* As we're walking through a directory, we might as well
find the first free entry to help FF_FindFreeDirent( )
The result will be stored in 'pxFindParams->lFreeEntry' */
BaseType_t	entriesNeeded;
BaseType_t	freeCount = 0;
FF_Error_t xError;
/* If the file name fits into a short file name
then the existence of that short file name will be checked as well. */
BaseType_t	testShortname;
uint32_t xResult = 0ul;
#if( ffconfigUNICODE_UTF8_SUPPORT == 1 )
	int32_t	utf8Error;
#endif

#if( ffconfigLFN_SUPPORT != 0 )
	#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
		FF_T_WCHAR	*pcCurPtr;		/* Pointer to store a LFN. */
		FF_T_WCHAR	*pcLastPtr = pxDirEntry->pcFileName + sizeof( pxDirEntry->pcFileName );
	#else
		char	*pcCurPtr;		/* Pointer to store a LFN. */
		char	*pcLastPtr = pxDirEntry->pcFileName + sizeof( pxDirEntry->pcFileName );
	#endif /* ffconfigUNICODE_UTF16_SUPPORT */

	uint16_t lfnItem = 0;
	uint8_t ucCheckSum = 0;
	BaseType_t xLFNCount = 0;
	BaseType_t xLFNTotal = 0;
	uint8_t lastAttrib;

	BaseType_t xIndex;
#endif /* ffconfigLFN_SUPPORT */

	#if( ffconfigLFN_SUPPORT != 0 )
	{
		#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
			BaseType_t	NameLen = ( BaseType_t ) wcslen( ( const char * )pcName );
		#else
			BaseType_t	NameLen = ( BaseType_t ) strlen( ( const char * )pcName );
		#endif
		/* Find enough places for the LFNs and the ShortName. */
		entriesNeeded = ( uint8_t )( ( NameLen + 12 ) / 13 ) + 1;
	}
	#else
	{
		entriesNeeded = 1;
	}
	#endif /* ffconfigLFN_SUPPORT */

	if( ( pxFindParams->ulFlags & FIND_FLAG_FITS_SHORT_OK ) == FIND_FLAG_FITS_SHORT_OK )
	{
		testShortname = pdTRUE;
	}
	else
	{
		testShortname = pdFALSE;
	}

	pxDirEntry->ucAttrib = 0;

	if( ( pxFindParams->ulFlags & FIND_FLAG_CREATE_FLAG ) != 0 )
	{
		/* A file is to be created: keep track of the first free entry big enough
		to hold this file name. */
		pxFindParams->lFreeEntry = -1;
	}
	else
	{
		pxFindParams->lFreeEntry = 0;
	}

	xError = FF_InitEntryFetch( pxIOManager, pxFindParams->ulDirCluster, &xFetchContext );

	if( FF_isERR( xError ) == pdFALSE )
	{
		for( pxDirEntry->usCurrentItem = 0; pxDirEntry->usCurrentItem < FF_MAX_ENTRIES_PER_DIRECTORY; pxDirEntry->usCurrentItem++ )
		{
			if( ( src == NULL ) ||
				( src >= xFetchContext.pxBuffer->pucBuffer + ( FF_SIZEOF_SECTOR - FF_SIZEOF_DIRECTORY_ENTRY ) ) )
			{
				xError = FF_FetchEntryWithContext( pxIOManager, pxDirEntry->usCurrentItem, &xFetchContext, NULL );

				if( FF_isERR( xError ) != pdFALSE )
				{
					break;
				}
				src = xFetchContext.pxBuffer->pucBuffer;
			}
			else
			{
				/* Advance 32 bytes. */
				src += FF_SIZEOF_DIRECTORY_ENTRY;
			}

			if( FF_isEndOfDir( src ) )
			{
				/* 0x00 end-of-dir. */
				break;
			}

			if( FF_isDeleted( src ) )
			{
				/* Entry not used or deleted. */
				pxDirEntry->ucAttrib = 0;
				if( ( pxFindParams->lFreeEntry < 0 ) && ( ++freeCount == entriesNeeded ) )
				{
					/* Remember the beginning entry in the sequential sequence. */
					pxFindParams->lFreeEntry = ( pxDirEntry->usCurrentItem - ( entriesNeeded - 1 ) );
				}
				continue;
			}

			/* The current entry is in use, so reset the free-entry-counter */
			freeCount = 0;
			#if( ffconfigLFN_SUPPORT != 0 )
			{
				lastAttrib = pxDirEntry->ucAttrib;
			}
			#endif

			pxDirEntry->ucAttrib = FF_getChar( src, FF_FAT_DIRENT_ATTRIB );

			if( ( pxDirEntry->ucAttrib & FF_FAT_ATTR_LFN ) == FF_FAT_ATTR_LFN )
			{
				/* LFN Processing. */
				#if( ffconfigLFN_SUPPORT != 0 )
				{
					if( ( xLFNCount == 0 ) || ( lastAttrib & FF_FAT_ATTR_LFN ) != FF_FAT_ATTR_LFN )
					{
						xLFNTotal = xLFNCount = ( BaseType_t )( src[ 0 ] & ~0x40 );
						lfnItem = pxDirEntry->usCurrentItem;
						ucCheckSum = FF_getChar( src, FF_FAT_LFN_CHECKSUM );
						pcLastPtr[ -1 ] = '\0';
					}

					if( xLFNCount != 0 )
					{
						xLFNCount--;
						pcCurPtr = pxDirEntry->pcFileName + ( xLFNCount * 13 );

						/*
							This section needs to extract the name and do the comparison
							dependent on UNICODE settings in the FreeRTOSFATConfig.h file.
						*/
						#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
						{
							/* Add UTF-16 Routine here. */
							/* Copy first 5 UTF-16 chars ( 10 bytes ). */
							memcpy( pcCurPtr, &src[ FF_FAT_LFN_NAME_1 ], 10 );
							/* Increment Filename pointer 5 utf16 chars. */
							pcCurPtr += 5;

							/* Copy next 6 chars ( 12 bytes ). */
							memcpy( pcCurPtr, &src[ FF_FAT_LFN_NAME_2 ], 12 );
							pcCurPtr += 6;

							/* You're getting the idea by now! */
							memcpy( pcCurPtr, &src[ FF_FAT_LFN_NAME_3 ], 4 );
							pcCurPtr += 2;
						}	/* ffconfigUNICODE_UTF16_SUPPORT */
						#elif( ffconfigUNICODE_UTF8_SUPPORT != 0 )
						{
							/* UTF-8 Routine here. */
							for( xIndex = 0; ( xIndex < 5 ) && ( pcCurPtr < pcLastPtr ); xIndex++ )
							{
								/* Was there a surrogate sequence? -- Add handling here. */
								utf8Error = FF_Utf16ctoUtf8c( ( uint8_t * ) pcCurPtr, ( uint16_t * ) &src[ FF_FAT_LFN_NAME_1 + ( 2 * xIndex ) ], pcLastPtr - pcCurPtr );
								if( utf8Error > 0 )
								{
									pcCurPtr += utf8Error;
								}
								else
								{
									if( FF_GETERROR( utf8Error ) == FF_ERR_UNICODE_INVALID_SEQUENCE )
									{
										/* Handle potential surrogate sequence across entries. */
									}
								}
							}

							for( xIndex = 0; xIndex < 6 && pcCurPtr < pcLastPtr; xIndex++ )
							{
								/* Was there a surrogate sequence? -- To add handling here. */
								utf8Error = FF_Utf16ctoUtf8c( ( uint8_t * ) pcCurPtr, ( uint16_t * ) &src[ FF_FAT_LFN_NAME_2 + ( 2 * xIndex ) ], pcLastPtr - pcCurPtr );
								if( utf8Error > 0 )
								{
									pcCurPtr += utf8Error;
								}
								else
								{
									if( FF_GETERROR( utf8Error ) == FF_ERR_UNICODE_INVALID_SEQUENCE )
									{
										/* Handle potential surrogate sequence across entries. */
									}
								}
							}

							for( xIndex = 0; xIndex < 2 && pcCurPtr < pcLastPtr; xIndex++ )
							{
								/* Was there a surrogate sequence? -- To add handling here. */
								utf8Error = FF_Utf16ctoUtf8c( ( uint8_t * ) pcCurPtr, ( uint16_t * ) &src[ FF_FAT_LFN_NAME_3 + ( 2 * xIndex ) ], pcLastPtr - pcCurPtr );
								if( utf8Error > 0 )
								{
									pcCurPtr += utf8Error;
								}
								else
								{
									if( FF_GETERROR( utf8Error ) == FF_ERR_UNICODE_INVALID_SEQUENCE )
									{
										/* Handle potential surrogate sequence across entries. */
									}
								}
							}
						}	/* ffconfigUNICODE_UTF8_SUPPORT */
						#else
						{	/* use ASCII notation. */
							for( xIndex = 0; ( xIndex < 10 ) && ( pcCurPtr < pcLastPtr ); xIndex += 2 )
							{
								*( pcCurPtr++ ) = src[ FF_FAT_LFN_NAME_1 + xIndex ];
							}
							for( xIndex = 0; ( xIndex < 12 )  && ( pcCurPtr < pcLastPtr ); xIndex += 2 )
							{
								*( pcCurPtr++ ) = src[ FF_FAT_LFN_NAME_2 + xIndex ];
							}

							for( xIndex = 0; ( xIndex < 4 ) && ( pcCurPtr < pcLastPtr ); xIndex += 2 )
							{
								*( pcCurPtr++ ) = src[ FF_FAT_LFN_NAME_3 + xIndex ];
							}
						}
						#endif /* ( ffconfigUNICODE_UTF16_SUPPORT == 0 ) && !( ffconfigUNICODE_UTF8_SUPPORT == 0 ) */
						if( ( xLFNCount == xLFNTotal - 1 ) && ( pcCurPtr < pcLastPtr ) )
						{
							*pcCurPtr = '\0';	/* Important when name len is multiple of 13. */
						}
					} /* if( xLFNCount ) */
				}
				#endif /* ffconfigLFN_SUPPORT */
				continue;
			}

			if( ( pxDirEntry->ucAttrib & FF_FAT_ATTR_VOLID ) == FF_FAT_ATTR_VOLID )
			{
				#if( ffconfigLFN_SUPPORT != 0 )
				{
					xLFNTotal = 0;
				}
				#endif /* ffconfigLFN_SUPPORT */
				continue;
			}

		#if( ffconfigLFN_SUPPORT != 0 )
			if( ( xLFNTotal == 0 ) || ( ucCheckSum != FF_CreateChkSum( src ) ) )
		#endif /* ffconfigLFN_SUPPORT */
			{
				/* This entry has only a short name, or the checksum isn't correct
				 * Use the short name for comparison */
				memcpy( pxDirEntry->pcFileName, src, 11 );
				FF_ProcessShortName( ( char * ) pxDirEntry->pcFileName );
				#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
				{
					/* FileName now contains a 8-bit short name
					Expand it to a FF_T_WCHAR string. */
					FF_ShortNameExpand( pxDirEntry->pcFileName );
				}
				#endif /* ffconfigUNICODE_UTF16_SUPPORT */
				#if( ffconfigLFN_SUPPORT != 0)
				{
					xLFNTotal = 0;
				}
				#endif /* ffconfigLFN_SUPPORT */
			}

			/* This function FF_FindEntryInDir( ) is either called with
			 * pa_Attrib==0 or with pa_Attrib==FF_FAT_ATTR_DIR
			 * In the last case the caller is looking for a directory */
			if( ( pxDirEntry->ucAttrib & pa_Attrib ) == pa_Attrib )
			{
				if( testShortname )
				{
					/* Both strings are stored in the directory format
					 * e.g. "README  TXT", without a dot */
					if( memcmp( src, pxFindParams->pcEntryBuffer, 11 ) == 0 )
					{
						pxFindParams->ulFlags |= FIND_FLAG_SHORTNAME_CHECKED | FIND_FLAG_SHORTNAME_FOUND;
					}
				}

			#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
				if( wcsicmp( ( const char * )pcName, ( const char * )pxDirEntry->pcFileName ) == 0 )
			#else
				if( FF_stricmp( ( const char * )pcName, ( const char * )pxDirEntry->pcFileName ) == 0 )
			#endif /* ffconfigUNICODE_UTF16_SUPPORT */
				{
					/* Finally get the complete information. */
				#if( ffconfigLFN_SUPPORT != 0 )
					if( xLFNTotal )
					{
						xError = FF_PopulateLongDirent( pxIOManager, pxDirEntry, ( uint16_t ) lfnItem, &xFetchContext );
						if( FF_isERR( xError ) )
						{
							break;
						}
					}
					else
				#endif /* ffconfigLFN_SUPPORT */
					{
						FF_PopulateShortDirent( pxIOManager, pxDirEntry, src );
						/* HT: usCurrentItem wasn't increased here. */
						pxDirEntry->usCurrentItem++;
					}
					/* Object found, the cluster number will be returned. */
					xResult = pxDirEntry->ulObjectCluster;
					break;
				}
			}
			#if( ffconfigLFN_SUPPORT != 0 )
			{
				xLFNTotal = 0;
			}
			#endif
		}	/* for( ; pxDirEntry->usCurrentItem < FF_MAX_ENTRIES_PER_DIRECTORY; pxDirEntry->usCurrentItem++ ) */

		{
		FF_Error_t xTempError;
			xTempError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext );
			if( FF_isERR( xError ) == pdFALSE )
			{
				xError = xTempError;
			}
		}
	} /* if( FF_isERR( xError ) == pdFALSE ) */

	if( FF_isERR( xError ) == pdFALSE )
	{
		/* If a free entry wasn't found yet, put it to the current (last) item */
		if( pxFindParams->lFreeEntry < 0 )
		{
			pxFindParams->lFreeEntry = pxDirEntry->usCurrentItem;
		}

		/* If we were checking the existence of the short-name
		set the Checked flag now */
		if( testShortname )
		{
			pxFindParams->ulFlags |= FIND_FLAG_SHORTNAME_CHECKED;
		}
	}

	if( pxError != NULL )
	{
		*pxError = xError;
	}

	return xResult;
}	/* FF_FindEntryInDir() */
/*-----------------------------------------------------------*/


/**
 *	@private
 **/
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
uint32_t FF_FindDir( FF_IOManager_t *pxIOManager, const FF_T_WCHAR *pcPath, uint16_t pathLen, FF_Error_t *pxError )
#else
uint32_t FF_FindDir( FF_IOManager_t *pxIOManager, const char *pcPath, uint16_t pathLen, FF_Error_t *pxError )
#endif
{
uint16_t it = 0;         /* Re-entrancy Variables for FF_strtok( ). */
BaseType_t last = pdFALSE;
FF_DirEnt_t xMyDirectory;
FF_FindParams_t  xFindParams;
FF_Error_t xError;
BaseType_t xFound;

#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	FF_T_WCHAR mytoken[ ffconfigMAX_FILENAME ];
	FF_T_WCHAR *token;
#else
	char mytoken[ ffconfigMAX_FILENAME ];
	char *pcToken;
#endif

#if( ffconfigPATH_CACHE != 0 )
	BaseType_t xIndex;
#endif

	memset( &xFindParams, '\0', sizeof( xFindParams ) );
	xFindParams.ulDirCluster = pxIOManager->xPartition.ulRootDirCluster;

	xError = FF_ERR_NONE;

    if( pathLen <= 1 )
	{
		/* Must be the root directory.
		'xFindParams.ulDirCluster' will be returned containing 'pxIOManager->xPartition.ulRootDirCluster'. */
		xFound = pdTRUE;
    }
	else
	{
		/* Only the root directory '/' shall have a trailing slash in its name. */
		if( ( pcPath[ pathLen - 1 ] == '\\' ) || ( pcPath[ pathLen - 1 ] == '/' ) )
		{
			pathLen--;
		}
		xFound = pdFALSE;

		#if( ffconfigPATH_CACHE != 0 )	/* Is the requested pcPath in the PATH CACHE? */
		{
			FF_PendSemaphore( pxIOManager->pvSemaphore );	/* Thread safety on shared object! */
			{
				for( xIndex = 0; xIndex < ffconfigPATH_CACHE_DEPTH; xIndex++ )
				{
				#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
					if( wcslen( pxIOManager->xPartition.pxPathCache[ xIndex ].pcPath ) == ( size_t )pathLen )
				#else
					if( strlen( pxIOManager->xPartition.pxPathCache[ xIndex ].pcPath ) == ( size_t )pathLen )
				#endif
					{
						if( FF_strmatch( pxIOManager->xPartition.pxPathCache[ xIndex ].pcPath, pcPath, pathLen ) )
						{
							xFindParams.ulDirCluster = pxIOManager->xPartition.pxPathCache[ xIndex ].ulDirCluster;
							xFound = pdTRUE;
							break;
						}
					}
				}
			}
			FF_ReleaseSemaphore( pxIOManager->pvSemaphore );
		}
		#endif /* ffconfigPATH_CACHE */
	}
	if( xFound == pdFALSE )
	{
		pcToken = FF_strtok( pcPath, mytoken, &it, &last, pathLen );

		do
		{
			xMyDirectory.usCurrentItem = 0;
			xFindParams.ulDirCluster = FF_FindEntryInDir( pxIOManager, &xFindParams, pcToken, ( uint8_t ) FF_FAT_ATTR_DIR, &xMyDirectory, &xError );

			if( xFindParams.ulDirCluster == 0ul )
			{
				break;
			}

			pcToken = FF_strtok( pcPath, mytoken, &it, &last, pathLen );

		} while( pcToken != NULL );
		if( ( pcToken != NULL ) &&
			( ( FF_isERR( xError ) == pdFALSE ) || ( FF_GETERROR( xError ) == FF_ERR_DIR_END_OF_DIR ) ) )
		{
			xError = ( FF_Error_t ) ( FF_FINDDIR | FF_ERR_FILE_INVALID_PATH );
		}
		#if( ffconfigPATH_CACHE != 0 )	/* Update the PATH CACHE with a new PATH. */
		{
			/* Only cache if the dir was actually found! */
			if( ( FF_isERR( xError ) == pdFALSE ) && ( xFindParams.ulDirCluster != 0ul ) )
			{
				FF_PendSemaphore( pxIOManager->pvSemaphore );
				{
					if( pathLen < ffconfigMAX_FILENAME )	/* Ensure the PATH won't cause a buffer overrun. */
					{
						#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
						{
							memcpy( pxIOManager->xPartition.pxPathCache[ pxIOManager->xPartition.ulPCIndex ].pcPath, pcPath, pathLen * sizeof( FF_T_WCHAR ) );
						}
						#else
						{
							memcpy( pxIOManager->xPartition.pxPathCache[ pxIOManager->xPartition.ulPCIndex ].pcPath, pcPath, pathLen );
						}
						#endif

						pxIOManager->xPartition.pxPathCache[ pxIOManager->xPartition.ulPCIndex ].pcPath[ pathLen ] = '\0';
						pxIOManager->xPartition.pxPathCache[ pxIOManager->xPartition.ulPCIndex ].ulDirCluster = xFindParams.ulDirCluster;

						pxIOManager->xPartition.ulPCIndex += 1;
						if( pxIOManager->xPartition.ulPCIndex >= ffconfigPATH_CACHE_DEPTH )
						{
							pxIOManager->xPartition.ulPCIndex = 0;
						}
					}
				}
				FF_ReleaseSemaphore( pxIOManager->pvSemaphore );
			}
		}
		#endif /* ffconfigPATH_CACHE */
	} /* if( pathLen > 1 ) */

	if( pxError != NULL )
	{
		*pxError = xError;
	}

    return xFindParams.ulDirCluster;
}	/* FF_FindDir() */
/*-----------------------------------------------------------*/


#if( ffconfigSHORTNAME_CASE != 0 )
	/**
	 *	@private
	 *  For short-name entries, NT/XP etc store case information in byte 0x0c
	 *  Use this to show proper case of "README.txt" or "source.H"
	 **/
	#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	static void FF_CaseShortName( FF_T_WCHAR *pcName, uint8_t attrib )
	#else
	static void FF_CaseShortName( char *pcName, uint8_t attrib )
	#endif
	{
	uint8_t testAttrib = FF_FAT_CASE_ATTR_BASE;

		for ( ; *pcName != '\0'; pcName++ )
		{
			if( *pcName == '.' )
			{
				testAttrib = FF_FAT_CASE_ATTR_EXT;
			}
			else if ( ( attrib & testAttrib ) != 0 )
			{
				if( ( *pcName >= 'A' ) && ( *pcName <= 'Z' ) )
				{
					*pcName += 0x20;
				}
			}
			else if( ( *pcName >= 'a' ) && ( *pcName <= 'z' ) )
			{
				*pcName -= 0x20;
			}
		}
	}
#endif /* ffconfigSHORTNAME_CASE */
/*-----------------------------------------------------------*/

#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	/**
	 *	@private
	 *	Expand a short-name, adding a zero after each character
	 **/

	static void FF_ShortNameExpand( FF_T_WCHAR *pFileName )
	{
		int8_t *pSource = ( ( int8_t * ) pFileName ) + 13;
		int8_t *pTarget = ( ( int8_t * ) pFileName ) + 26;
		/* "aaaaaaaa.eee": 12 characters plus a zero makes 13
		 * Copy from the right to the left */
		while( pTarget > ( int8_t * ) pFileName )
		{
			pTarget[ -1 ] = 0;
			pTarget[ -2 ] = *( --pSource );
			pTarget -= 2;
		}
	}
#endif /* ffconfigUNICODE_UTF16_SUPPORT */
/*-----------------------------------------------------------*/

/**
 *	@private
 **/

static void FF_ProcessShortName( char *pcName )
{
	char	pcShortName[ 13 ];
	char	*pcTarget = pcName;
	int		iSource;
	memcpy( pcShortName, pcName, 11 );

	for( iSource = 0; iSource < 11; iSource++ )
	{
		if( pcShortName[ iSource ] == 0x20 )
		{
			if( iSource >= 8 )
			{
				break;
			}
			iSource = 7;
		}
		else
		{
			if( iSource == 8 )
			{
				*( pcTarget++ ) = '.';
			}
			*( pcTarget++ ) = pcShortName[ iSource ];
		}
	}
	*pcTarget = '\0';
}
/*-----------------------------------------------------------*/


#if( ffconfigTIME_SUPPORT != 0 )
	static void FF_PlaceTime( uint8_t *pucEntryBuffer, uint32_t Offset, FF_SystemTime_t *pxTime )
	{
		uint16_t myShort;

		/* HT time changes:
		E.g. Unzip needs to use original time rather than
		the result of FF_GetSystemTime */

		myShort = 0;
		myShort |= ( ( pxTime->Hour    << 11 ) & 0xF800 );
		myShort |= ( ( pxTime->Minute  <<  5 ) & 0x07E0 );
		myShort |= ( ( pxTime->Second   /  2 ) & 0x001F );
		FF_putShort( pucEntryBuffer, ( uint16_t ) Offset, myShort );
	}
#endif /* ffconfigTIME_SUPPORT */
/*-----------------------------------------------------------*/


#if( ffconfigTIME_SUPPORT != 0 )
	static void FF_PlaceDate( uint8_t *pucEntryBuffer, uint32_t Offset, FF_SystemTime_t *pxTime )
	{
		uint16_t myShort;

		/* HT time changes:
		Unzip needs to use original date rather than
		the current date, so make it a parameter. */
		myShort = 0;
		myShort |= ( ( ( pxTime->Year- 1980 )  <<  9 ) & 0xFE00 ) ;
		myShort |= ( ( pxTime->Month <<  5 ) & 0x01E0 );
		myShort |= ( pxTime->Day & 0x001F );
		FF_putShort( pucEntryBuffer, ( uint16_t ) Offset, myShort );
	}
#endif /*  ffconfigTIME_SUPPORT */
/*-----------------------------------------------------------*/


#if( ffconfigTIME_SUPPORT != 0 )
	static void FF_GetTime( FF_SystemTime_t *pxTime, const uint8_t *pucEntryBuffer, uint32_t Offset )
	{
		uint16_t myShort;
		myShort = FF_getShort( pucEntryBuffer, ( uint16_t ) Offset );
		pxTime->Hour		= ( ( ( myShort & 0xF800 ) >> 11 ) & 0x001F );
		pxTime->Minute	= ( ( ( myShort & 0x07E0 ) >>  5 ) & 0x003F );
		pxTime->Second	= 2 * ( myShort & 0x01F );
	}
#endif /*  ffconfigTIME_SUPPORT */
/*-----------------------------------------------------------*/


#if( ffconfigTIME_SUPPORT != 0 )
	static void FF_GetDate( FF_SystemTime_t *pxTime, const uint8_t *pucEntryBuffer, uint32_t Offset )
	{
		uint16_t myShort;
		myShort = FF_getShort( pucEntryBuffer, ( uint16_t ) Offset );
		pxTime->Year		= 1980 + ( ( ( myShort & 0xFE00 ) >> 9 ) & 0x07F );
		pxTime->Month	= ( ( ( myShort & 0x01E0 ) >> 5 ) & 0x000F );
		pxTime->Day		= myShort & 0x01F;
	}
#endif /*  ffconfigTIME_SUPPORT */
/*-----------------------------------------------------------*/

void FF_PopulateShortDirent( FF_IOManager_t *pxIOManager, FF_DirEnt_t *pxDirEntry, const uint8_t *pucEntryBuffer )
{
	memcpy( pxDirEntry->pcFileName, pucEntryBuffer, 11 );	/* Copy the filename into the Dirent object. */
#if( ffconfigLFN_SUPPORT != 0 ) && ( ffconfigINCLUDE_SHORT_NAME != 0 )
	memcpy( pxDirEntry->pcShortName, pucEntryBuffer, 11 );
	pxDirEntry->pcShortName[ 11 ] = '\0';
	FF_ProcessShortName( pxDirEntry->pcShortName );	/* For debuggers only. */
#endif
	FF_ProcessShortName( ( char * ) pxDirEntry->pcFileName );		/* Format the shortname, for pleasant viewing. */

#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	/* FileName contains a 8-bit short name
	 * Expand it to a FF_T_WCHAR string */
	FF_ShortNameExpand( pxDirEntry->pcFileName );
#endif

	( void )pxIOManager;	/* Silence a compiler warning, about not referencing pxIOManager. */

#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	FF_tolower( pxDirEntry->pcFileName, ( uint32_t )wcslen( pxDirEntry->pcFileName ) );
#else
	FF_tolower( pxDirEntry->pcFileName, ( uint32_t )strlen( pxDirEntry->pcFileName ) );
#endif

	/* Get the item's Cluster address. */
	pxDirEntry->ulObjectCluster =
		( ( uint32_t )FF_getShort( pucEntryBuffer, FF_FAT_DIRENT_CLUS_HIGH ) << 16 ) |
		  ( uint32_t )FF_getShort( pucEntryBuffer, FF_FAT_DIRENT_CLUS_LOW );
#if( ffconfigTIME_SUPPORT != 0 )
	/* Get the creation Time & Date. */
	FF_GetTime( &pxDirEntry->xCreateTime, pucEntryBuffer, FF_FAT_DIRENT_CREATE_TIME );
	FF_GetDate( &pxDirEntry->xCreateTime, pucEntryBuffer, FF_FAT_DIRENT_CREATE_DATE );
	/* Get the modified Time & Date
	HT Here xCreateTime became xModifiedTime: */
	FF_GetTime( &pxDirEntry->xModifiedTime, pucEntryBuffer, FF_FAT_DIRENT_LASTMOD_TIME );
	FF_GetDate( &pxDirEntry->xModifiedTime, pucEntryBuffer, FF_FAT_DIRENT_LASTMOD_DATE );
	/* Get the last accessed Date. */
	FF_GetDate( &pxDirEntry->xAccessedTime, pucEntryBuffer, FF_FAT_DIRENT_LASTACC_DATE );
	pxDirEntry->xAccessedTime.Hour		= 0;
	pxDirEntry->xAccessedTime.Minute	= 0;
	pxDirEntry->xAccessedTime.Second	= 0;
#endif
	/* Get the filesize. */
	pxDirEntry->ulFileSize = FF_getLong( pucEntryBuffer, ( uint16_t )( FF_FAT_DIRENT_FILESIZE ) );
	/* Get the attribute. */
	pxDirEntry->ucAttrib = FF_getChar( pucEntryBuffer, ( uint16_t )( FF_FAT_DIRENT_ATTRIB ) );
}
/*-----------------------------------------------------------*/


/* Initialises a context object for FF_FetchEntryWithContext(  */
FF_Error_t FF_InitEntryFetch( FF_IOManager_t *pxIOManager, uint32_t ulDirCluster, FF_FetchContext_t *pxContext )
{
	FF_Error_t xError;

	memset( pxContext, 0, sizeof( FF_FetchContext_t ) );

	/* Get the total length of the chain. */
	pxContext->ulChainLength = FF_GetChainLength( pxIOManager, ulDirCluster, NULL, &xError );

	if( FF_isERR( xError ) == pdFALSE )
	{
		pxContext->ulDirCluster = ulDirCluster;
		pxContext->ulCurrentClusterLCN = ulDirCluster;

		if( pxIOManager->xPartition.ucType != FF_T_FAT32 )
		{
			/* Handle Root Dirs that don't have cluster chains! */
			if( pxContext->ulDirCluster == pxIOManager->xPartition.ulRootDirCluster )
			{
				/* This is a RootDIR, special consideration needs to be made, because it doesn't have a Cluster chain! */
				pxContext->ulChainLength = pxIOManager->xPartition.ulRootDirSectors / pxIOManager->xPartition.ulSectorsPerCluster;
				if( pxContext->ulChainLength == 0 )		/* Some media has ulRootDirSectors < ulSectorsPerCluster. This is wrong, as it should be atleast 1 cluster! */
				{
					pxContext->ulChainLength = 1;
				}
			}
		}
	}

	return xError;
}	/* FF_InitEntryFetch() */
/*-----------------------------------------------------------*/

FF_Error_t FF_CleanupEntryFetch( FF_IOManager_t *pxIOManager, FF_FetchContext_t *pxContext )
{
	FF_Error_t xError = FF_ERR_NONE;
	if( pxContext->pxBuffer )
	{
		xError = FF_ReleaseBuffer( pxIOManager, pxContext->pxBuffer );
		pxContext->pxBuffer = NULL;
	}

	return xError;
}	/* FF_CleanupEntryFetch() */
/*-----------------------------------------------------------*/

/**
 *	@private
 *	@brief	Find the cluster for a given Entry within a directory
 *  @brief	Make an exception for the root directory ( non FAT32 only ):
 *  @brief	Just calculate the cluster ( don't consult the actual FAT )
 *
 *	@param	pxIOManager FF_IOManager_t object that was created by FF_CreateIOManger( ).
 *	@param	ulEntry     The sequence number of the entry of interest
 *  @param	pxContext   Context of current search
 *
 *	@Return	FF_ERR_NONE on success
 *	@Return	Possible error returned by FF_TraverseFAT( ) or END_OF_DIR
 *
 *  Side effects:
 *    - pxContext->ulCurrentClusterNum : relative cluster number ( 0 <= Num < ulChainLength )
 *    - pxContext->ulCurrentClusterLCN : fysical cluster on the partition
 **/

static FF_Error_t FF_Traverse( FF_IOManager_t *pxIOManager, uint32_t ulEntry, FF_FetchContext_t *pxContext )
{
uint32_t ulClusterNum = FF_getClusterChainNumber( pxIOManager, ulEntry, ( uint16_t ) FF_SIZEOF_DIRECTORY_ENTRY );
FF_Error_t xError = FF_ERR_NONE;

	/* Check if we're past the last cluster ( ulChainLength is also valid for root sectors ). */
	if( ( ulClusterNum + 1 ) > pxContext->ulChainLength )
	{
		xError = FF_ERR_DIR_END_OF_DIR | FF_TRAVERSE;	/* End of Dir was reached! */
	}
	else if( ( pxIOManager->xPartition.ucType != FF_T_FAT32 ) &&
		( pxContext->ulDirCluster == pxIOManager->xPartition.ulRootDirCluster ) )
	{
		/* Double-check if the entry number isn't too high. */
		if( ulEntry > ( ( pxIOManager->xPartition.ulRootDirSectors * pxIOManager->xPartition.usBlkSize ) / FF_SIZEOF_DIRECTORY_ENTRY ) )
		{
			xError = ( FF_Error_t ) ( FF_ERR_DIR_END_OF_DIR | FF_FETCHENTRYWITHCONTEXT );
		}
		else
		{
			pxContext->ulCurrentClusterLCN = pxContext->ulDirCluster;
		}
	}
	else if( ulClusterNum != pxContext->ulCurrentClusterNum )
	{
		/* Traverse the fat gently! */
		if( ulClusterNum > pxContext->ulCurrentClusterNum )
		{
			/* Start traverse from the current entry. */
			pxContext->ulCurrentClusterLCN = FF_TraverseFAT( pxIOManager, pxContext->ulCurrentClusterLCN, ( ulClusterNum - pxContext->ulCurrentClusterNum ), &xError );
		}
		else
		{
			/* Start traverse from the beginning. */
			pxContext->ulCurrentClusterLCN = FF_TraverseFAT( pxIOManager, pxContext->ulDirCluster, ulClusterNum, &xError );
		}
	}
	if( FF_isERR( xError ) == pdFALSE )
	{
		pxContext->ulCurrentClusterNum = ulClusterNum;
	}

	return xError;
}	/* FF_Traverse() */
/*-----------------------------------------------------------*/

FF_Error_t FF_FetchEntryWithContext( FF_IOManager_t *pxIOManager, uint32_t ulEntry, FF_FetchContext_t *pxContext, uint8_t *pEntryBuffer )
{
	uint32_t ulItemLBA;
	uint32_t ulRelItem;
	FF_Error_t xError;

	xError = FF_Traverse( pxIOManager, ulEntry, pxContext );

	if( FF_isERR( xError ) == pdFALSE )
	{
		ulRelItem     = FF_getMinorBlockEntry ( pxIOManager, ulEntry, ( uint32_t )FF_SIZEOF_DIRECTORY_ENTRY );

		ulItemLBA = FF_Cluster2LBA ( pxIOManager, pxContext->ulCurrentClusterLCN ) +
			FF_getMajorBlockNumber( pxIOManager, ulEntry, ( uint32_t ) FF_SIZEOF_DIRECTORY_ENTRY );
		if( ( pxIOManager->xPartition.ucType != FF_T_FAT32 ) &&
			( pxContext->ulDirCluster == pxIOManager->xPartition.ulRootDirCluster ) )
		{
			ulItemLBA += ( ulEntry / ( ( pxIOManager->xPartition.usBlkSize * pxIOManager->xPartition.ulSectorsPerCluster ) /
				FF_SIZEOF_DIRECTORY_ENTRY ) * pxIOManager->xPartition.ulSectorsPerCluster );
		}

		ulItemLBA = FF_getRealLBA ( pxIOManager, ulItemLBA ) + FF_getMinorBlockNumber( pxIOManager, ulRelItem, ( uint32_t )FF_SIZEOF_DIRECTORY_ENTRY );

		if( ( pxContext->pxBuffer == NULL ) ||
			( pxContext->pxBuffer->ulSector != ulItemLBA ) ||
			( ( pxContext->pxBuffer->ucMode & FF_MODE_WRITE ) != 0 ) )
		{
			if( pxContext->pxBuffer != NULL )
			{
				xError = FF_ReleaseBuffer( pxIOManager, pxContext->pxBuffer );
				pxContext->pxBuffer = NULL;
			}

			if( FF_isERR( xError ) == pdFALSE )
			{
				pxContext->pxBuffer = FF_GetBuffer( pxIOManager, ulItemLBA, FF_MODE_READ );
				if( pxContext->pxBuffer == NULL )
				{
					xError = ( FF_Error_t ) ( FF_ERR_DEVICE_DRIVER_FAILED | FF_FETCHENTRYWITHCONTEXT );
				}
			}
		}

		if ( ( pEntryBuffer != NULL ) && ( pxContext->pxBuffer != NULL ) )
		{
			memcpy( pEntryBuffer, pxContext->pxBuffer->pucBuffer + ( ulRelItem * FF_SIZEOF_DIRECTORY_ENTRY ), FF_SIZEOF_DIRECTORY_ENTRY );
		}
	}

    return xError;
}	/* FF_FetchEntryWithContext() */
/*-----------------------------------------------------------*/


FF_Error_t FF_PushEntryWithContext( FF_IOManager_t *pxIOManager, uint32_t ulEntry, FF_FetchContext_t *pxContext, uint8_t *pEntryBuffer )
{
	uint32_t	ulItemLBA;
	uint32_t	ulRelItem;
	FF_Error_t	xError;

	xError = FF_Traverse( pxIOManager, ulEntry, pxContext );
	if( FF_isERR( xError ) == pdFALSE )
	{
		ulRelItem     = FF_getMinorBlockEntry ( pxIOManager, ulEntry, ( uint32_t ) FF_SIZEOF_DIRECTORY_ENTRY );

		ulItemLBA = FF_Cluster2LBA ( pxIOManager, pxContext->ulCurrentClusterLCN ) + FF_getMajorBlockNumber( pxIOManager, ulEntry, ( uint32_t ) FF_SIZEOF_DIRECTORY_ENTRY );
		if( ( pxIOManager->xPartition.ucType != FF_T_FAT32 ) &&
			( pxContext->ulDirCluster == pxIOManager->xPartition.ulRootDirCluster ) )
		{
			ulItemLBA += ( ulEntry /
				( ( pxIOManager->xPartition.usBlkSize * pxIOManager->xPartition.ulSectorsPerCluster ) / FF_SIZEOF_DIRECTORY_ENTRY ) * pxIOManager->xPartition.ulSectorsPerCluster );
		}

		ulItemLBA = FF_getRealLBA ( pxIOManager, ulItemLBA ) + FF_getMinorBlockNumber( pxIOManager, ulRelItem, ( uint32_t )FF_SIZEOF_DIRECTORY_ENTRY );

		if( ( pxContext->pxBuffer == NULL ) ||
			( pxContext->pxBuffer->ulSector != ulItemLBA ) ||
			( ( pxContext->pxBuffer->ucMode & FF_MODE_WRITE ) == 0 ) )
		{
			if( pxContext->pxBuffer != NULL )
			{
				xError = FF_ReleaseBuffer( pxIOManager, pxContext->pxBuffer );
				pxContext->pxBuffer = NULL;
			}
			if( FF_isERR( xError ) == pdFALSE )
			{
				pxContext->pxBuffer = FF_GetBuffer( pxIOManager, ulItemLBA, FF_MODE_WRITE );
				if( pxContext->pxBuffer == NULL )
				{
					xError = ( FF_Error_t ) ( FF_ERR_DEVICE_DRIVER_FAILED | FF_FETCHENTRYWITHCONTEXT );
				}
			}
		}

		/* Now change the entry: */
		if( pxContext->pxBuffer != NULL )
		{
			memcpy( pxContext->pxBuffer->pucBuffer + ( ulRelItem * FF_SIZEOF_DIRECTORY_ENTRY ), pEntryBuffer, FF_SIZEOF_DIRECTORY_ENTRY );
		}
	}

    return xError;
}	/* FF_PushEntryWithContext() */
/*-----------------------------------------------------------*/


/**
 *	@private
 **/
FF_Error_t FF_GetEntry( FF_IOManager_t *pxIOManager, uint16_t usEntry, uint32_t ulDirCluster, FF_DirEnt_t *pxDirEntry )
{
/* A 32 byte directory entry. */
uint8_t ucEntryBuffer[ FF_SIZEOF_DIRECTORY_ENTRY ];
FF_FetchContext_t	xFetchContext;
FF_Error_t				xError;

#if( ffconfigLFN_SUPPORT == 0 )
	BaseType_t xLFNCount;
#endif
	xError = FF_InitEntryFetch( pxIOManager, ulDirCluster, &xFetchContext );

	if( FF_isERR( xError ) == pdFALSE )
	{
		xError = FF_FetchEntryWithContext( pxIOManager, usEntry, &xFetchContext, ucEntryBuffer );

		if( ( FF_isERR( xError ) == pdFALSE ) &&
			( FF_isDeleted( ucEntryBuffer ) == pdFALSE ) )
		{
			if( FF_isEndOfDir( ucEntryBuffer ) != pdFALSE )
			{
				xError = ( FF_Error_t ) ( FF_ERR_DIR_END_OF_DIR | FF_GETENTRY );
			}
			else
			{
				pxDirEntry->ucAttrib = FF_getChar( ucEntryBuffer, ( uint16_t )( FF_FAT_DIRENT_ATTRIB ) );

				if( ( pxDirEntry->ucAttrib & FF_FAT_ATTR_LFN ) == FF_FAT_ATTR_LFN )
				{
			#if( ffconfigLFN_SUPPORT != 0 )
					xError = FF_PopulateLongDirent( pxIOManager, pxDirEntry, usEntry, &xFetchContext );
			#else
					/* LFN Processing. */
					xLFNCount = ( BaseType_t )( ucEntryBuffer[0] & ~0x40 );
					pxDirEntry->usCurrentItem += ( xLFNCount - 1 );
			#endif
				}
				else if( ( pxDirEntry->ucAttrib & FF_FAT_ATTR_VOLID ) != FF_FAT_ATTR_VOLID )
				{
					FF_PopulateShortDirent( pxIOManager, pxDirEntry, ucEntryBuffer );
					pxDirEntry->usCurrentItem += 1;
				}
			}
		}
		{
		FF_Error_t xTempError;
			xTempError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext );
			if( FF_isERR( xError ) == pdFALSE )
			{
				xError = xTempError;
			}
		}
	}

	return xError;
}	/* FF_GetEntry() */
/*-----------------------------------------------------------*/


FF_Error_t FF_PopulateLongDirent( FF_IOManager_t *pxIOManager, FF_DirEnt_t *pxDirEntry, uint16_t usEntry, FF_FetchContext_t *pxFetchContext )
{
/* First get the entire name as UTF-16 from the LFN's.
Then transform into the API's native string format. */

FF_Error_t xError;
BaseType_t xNumLFNs;
uint8_t	ucCheckSum;
/* A 32 byte directory entry. */
uint8_t	pucEntryBuffer[ FF_SIZEOF_DIRECTORY_ENTRY ];
char pcShortName[ 13 ];

#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	UBaseType_t	uiLfnLength = 0;
#endif

#if( ffconfigUNICODE_UTF16_SUPPORT == 0 )
	BaseType_t	xIndex, y;
#endif

#if( ffconfigUNICODE_UTF16_SUPPORT == 0 ) && ( ffconfigUNICODE_UTF8_SUPPORT == 0 )
	char	*pcLastPtr = pxDirEntry->pcFileName + sizeof( pxDirEntry->pcFileName );
	char	*pcCurPtr;
#endif

#if( ffconfigUNICODE_UTF8_SUPPORT != 0 )
	uint16_t nLfnBegin;
	uint16_t	usUtf8Len = 0;
#endif /* ffconfigUNICODE_UTF8_SUPPORT */

	do
	{
		xError = FF_FetchEntryWithContext( pxIOManager, usEntry++, pxFetchContext, pucEntryBuffer );
		if( FF_isERR( xError ) )
		{
			/* After breaking from this do {} while ( pdFALSE ) loop, xResult will be returned. */
			break;
		}

		xNumLFNs = ( BaseType_t )( pucEntryBuffer[0] & ~0x40 );
		ucCheckSum = FF_getChar( pucEntryBuffer, FF_FAT_LFN_CHECKSUM );

		#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
		{
			/* UTF-16 Can simply get segments of the UTF-16 sequence
			going forward in the directory entries ( but reversed order ). */
			while( xNumLFNs > 0 )
			{
				/* Avoid stack intensive use of a UTF-16 buffer. Stream direct to FileName dirent field in correct format. */
				/* memcpy direct! -UTF-16 support. */
				memcpy( pxDirEntry->pcFileName + ( ( xNumLFNs - 1 ) * 13 ) + 0,  &( pucEntryBuffer[ FF_FAT_LFN_NAME_1] ), 10 );
				memcpy( pxDirEntry->pcFileName + ( ( xNumLFNs - 1 ) * 13 ) + 5,  &( pucEntryBuffer[ FF_FAT_LFN_NAME_2] ), 12 );
				memcpy( pxDirEntry->pcFileName + ( ( xNumLFNs - 1 ) * 13 ) + 11, &( pucEntryBuffer[ FF_FAT_LFN_NAME_3] ), 4 );
				uiLfnLength += 13;

				xError = FF_FetchEntryWithContext( pxIOManager, usEntry++, pxFetchContext, pucEntryBuffer );
				if( FF_isERR( xError ) )
				{
					break;
				}
				xNumLFNs--;
			}
			if( FF_isERR( xError ) )
			{
				break;
			}
			pxDirEntry->pcFileName[ uiLfnLength ] = '\0';
		}
		#endif /* ffconfigUNICODE_UTF16_SUPPORT */

		#if ( ffconfigUNICODE_UTF8_SUPPORT != 0 )
		{
			/* UTF-8 Sequence, we can only convert this from the beginning, must receive entries in reverse. */
			nLfnBegin = usEntry - 1;

			for( xIndex = 0; xIndex < xNumLFNs; xIndex++ )
			{
				xError = FF_FetchEntryWithContext( pxIOManager, ( nLfnBegin + ( xNumLFNs - 1 ) - xIndex ), pxFetchContext, pucEntryBuffer );
				if( FF_isERR( xError ) )
				{
					break;
				}

				/* Now have the first part of the UTF-16 sequence. Stream into a UTF-8 sequence. */
				for( y = 0; y < 5; y++ )
				{
					xError = FF_Utf16ctoUtf8c( ( uint8_t * )&pxDirEntry->pcFileName[ usUtf8Len ],
						( uint16_t * )&pucEntryBuffer[ FF_FAT_LFN_NAME_1 + ( y * 2 ) ], sizeof( pxDirEntry->pcFileName ) - usUtf8Len );
					if( xError > 0 )
					{
						usUtf8Len += ( uint16_t )xError;
					}
				}

				for( y = 0; y < 6; y++ )
				{
					xError = FF_Utf16ctoUtf8c( ( uint8_t * )&pxDirEntry->pcFileName[ usUtf8Len ],
						( uint16_t * )&pucEntryBuffer[ FF_FAT_LFN_NAME_2 + ( y * 2 ) ], sizeof( pxDirEntry->pcFileName ) - usUtf8Len );
					if( xError > 0 )
					{
						usUtf8Len += ( uint16_t )xError;
					}
				}

				for( y = 0; y < 2; y++ )
				{
					xError = FF_Utf16ctoUtf8c( ( uint8_t * )&pxDirEntry->pcFileName[ usUtf8Len ],
						( uint16_t * )&pucEntryBuffer[ FF_FAT_LFN_NAME_3 +  ( y * 2 ) ], sizeof( pxDirEntry->pcFileName ) - usUtf8Len );
					if( xError > 0 )
					{
						usUtf8Len += ( uint16_t ) xError;
					}
				}
				usEntry++;
			}
			if( FF_isERR( xError ) )
			{
				break;
			}

			pxDirEntry->pcFileName[ usUtf8Len ] = '\0';

			/* Put Entry context to correct position. */
			xError = FF_FetchEntryWithContext( pxIOManager, usEntry-1, pxFetchContext, pucEntryBuffer );
			if( FF_isERR( xError ) )
			{
				break;
			}
		}
		#endif /* ( ffconfigUNICODE_UTF8_SUPPORT != 0 ) */

		#if( ffconfigUNICODE_UTF16_SUPPORT == 0 ) && ( ffconfigUNICODE_UTF8_SUPPORT == 0 )	/* No Unicode, simple ASCII. */
		{
			pcLastPtr[ -1 ] = '\0';
			y = xNumLFNs;
			while( xNumLFNs-- )
			{
				pcCurPtr = pxDirEntry->pcFileName + ( xNumLFNs * 13 );
				for( xIndex = 0; ( xIndex < 10 ) && ( pcCurPtr < pcLastPtr ); xIndex += 2 )
				{
					*( pcCurPtr++ ) = pucEntryBuffer[ FF_FAT_LFN_NAME_1 + xIndex ];
				}

				for( xIndex = 0; ( xIndex < 12 ) && ( pcCurPtr < pcLastPtr ); xIndex += 2 )
				{
					*( pcCurPtr++ ) = pucEntryBuffer[ FF_FAT_LFN_NAME_2 + xIndex ];
				}

				for( xIndex = 0; ( xIndex < 4 ) && ( pcCurPtr < pcLastPtr ); xIndex += 2 )
				{
					*( pcCurPtr++ ) = pucEntryBuffer[ FF_FAT_LFN_NAME_3 + xIndex ];
				}
				if( ( xNumLFNs == ( y - 1 ) ) && ( pcCurPtr < pcLastPtr ) )
				{
					*pcCurPtr = '\0';
				}
				xError = FF_FetchEntryWithContext( pxIOManager, usEntry++, pxFetchContext, pucEntryBuffer );
				if( FF_isERR( xError ) )
				{
					break;
				}
			}
			if( FF_isERR( xError ) )
			{
				break;
			}
		}
		#endif /* ( ffconfigUNICODE_UTF16_SUPPORT == 0 ) && ( ffconfigUNICODE_UTF8_SUPPORT == 0 ) */

		/* Process the Shortname. -- LFN Transformation is now complete.
		Process the ShortName Entry. */

		/* if SHORTNAMES must be included, simple byte copy into shortname buffer. */
		#if( ffconfigLFN_SUPPORT != 0 ) && ( ffconfigINCLUDE_SHORT_NAME != 0 )
		{
			memcpy( pxDirEntry->pcShortName, pucEntryBuffer, 11 );
			pxDirEntry->pcShortName[ 11 ] = '\0';
			FF_ProcessShortName( pxDirEntry->pcShortName );
		}
		#endif /* ( != 0 ffconfigLFN_SUPPORT ) && ( ffconfigINCLUDE_SHORT_NAME != 0 ) */

		memcpy( pcShortName, pucEntryBuffer, 11 );
		FF_ProcessShortName( pcShortName );
		if( ucCheckSum != FF_CreateChkSum( pucEntryBuffer ) )
		{
			strcpy( pxDirEntry->pcFileName, pcShortName );
			#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
			{
				FF_ShortNameExpand( pxDirEntry->pcFileName );
			}
			#endif /* ffconfigUNICODE_UTF16_SUPPORT */
		}

		/* Finally fill in the other details. */
		pxDirEntry->ulObjectCluster =
			( ( uint32_t )FF_getShort( pucEntryBuffer, FF_FAT_DIRENT_CLUS_HIGH ) << 16 ) |
			  ( uint32_t )FF_getShort( pucEntryBuffer, FF_FAT_DIRENT_CLUS_LOW );

		#if( ffconfigTIME_SUPPORT != 0 )
		{
			/* Get the creation Time & Date. */
			FF_GetTime( &pxDirEntry->xCreateTime, pucEntryBuffer, FF_FAT_DIRENT_CREATE_TIME );
			FF_GetDate( &pxDirEntry->xCreateTime, pucEntryBuffer, FF_FAT_DIRENT_CREATE_DATE );
			/* Get the modified Time & Date. */
			/* HT Here xCreateTime has become xModifiedTime, as it should: */
			FF_GetTime( &pxDirEntry->xModifiedTime, pucEntryBuffer, FF_FAT_DIRENT_LASTMOD_TIME );
			FF_GetDate( &pxDirEntry->xModifiedTime, pucEntryBuffer, FF_FAT_DIRENT_LASTMOD_DATE );
			/* Get the last accessed Date. */
			FF_GetDate( &pxDirEntry->xAccessedTime, pucEntryBuffer, FF_FAT_DIRENT_LASTACC_DATE );
			/* HT Why should these times be zero'd ? */
			pxDirEntry->xAccessedTime.Hour		= 0;
			pxDirEntry->xAccessedTime.Minute	= 0;
			pxDirEntry->xAccessedTime.Second	= 0;
		}
		#endif /* ffconfigTIME_SUPPORT */

		/* Get the filesize. */
		pxDirEntry->ulFileSize = FF_getLong( pucEntryBuffer, ( uint16_t ) ( FF_FAT_DIRENT_FILESIZE ) );
		/* Get the attribute. */
		pxDirEntry->ucAttrib = FF_getChar( pucEntryBuffer, ( uint16_t ) ( FF_FAT_DIRENT_ATTRIB ) );

		pxDirEntry->usCurrentItem = usEntry;
	}
	while ( pdFALSE );

	return xError;
}	/* FF_PopulateLongDirent() */
/*-----------------------------------------------------------*/

/**
 *	@public
 *	@brief	Find's the first directory entry for the provided path.
 *
 *	All values recorded in pxDirEntry must be preserved to and between calls to
 *	FF_FindNext( ).
 *
 *	If ffconfigFINDAPI_ALLOW_WILDCARDS is defined, then path will have the following behaviour:
 *
 *	path = "\" 					- Open the root dir, and iterate through all items.
 *	path = "\*.c"				- Open the root dir, showing only files matching *.c wildcard.
 *	path = "\sub1\newdir"		- Get the DIRENT for the newdir directory in /sub1/ if one exists.
 *	path = "\sub1\newdir\"		- Open the directory /sub1/newdir/ and iterate through all items.
 *	path = "\sub1\newdir\*.c"	- Open the directory /sub1/newdir/ and iterate through all items matching the *.c wildcard.
 *
 *	It is important to distinguish the differences in behaviour between opening a Find operation
 *	on a path like /sub1 and /sub1/. ( /sub1 gets the sub1 dirent from the / dir, whereas /sub/ opens the sub1 dir ).
 *
 *	Note, as compatible with other similar APIs, FreeRTOS+FAT also accepts \sub1\* for the same behaviour as
 *	/sub1/.
 *
 *	@param	pxIOManager FF_IOManager_t object that was created by FF_CreateIOManger( ).
 *	@param	pxDirEntry	FF_DirEnt_t object to store the entry information.
 *	@param	path		String to of the path to the Dir being listed.
 *
 *	@Return	0 on success
 *	@Return	FF_ERR_DEVICE_DRIVER_FAILED if device access failed.
 *	@Return -2 if Dir was not found.
 *
 **/
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
FF_Error_t FF_FindFirst( FF_IOManager_t *pxIOManager, FF_DirEnt_t *pxDirEntry, const FF_T_WCHAR *pcPath )
#else
FF_Error_t FF_FindFirst( FF_IOManager_t *pxIOManager, FF_DirEnt_t *pxDirEntry, const char *pcPath )
#endif
{
FF_Error_t xError;
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	uint16_t	PathLen = ( uint16_t ) wcslen( pcPath );
#else
	uint16_t	PathLen = ( uint16_t ) strlen( pcPath );
#endif

#if( ffconfigFINDAPI_ALLOW_WILDCARDS != 0 )
	BaseType_t xIndex = 0;
	#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
		const FF_T_WCHAR *pcWildCard;	/* Check for a Wild-card. */
	#else
		const char *pcWildCard;	/* Check for a Wild-card. */
	#endif
#endif

	memset( pxDirEntry, 0, sizeof( FF_DirEnt_t ) );

	if( pxIOManager == NULL )
	{
		xError = ( FF_Error_t ) ( FF_ERR_NULL_POINTER | FF_FINDFIRST );
	}
#if( ffconfigREMOVABLE_MEDIA != 0 )
	else if( ( pxIOManager->ucFlags & FF_IOMAN_DEVICE_IS_EXTRACTED ) != 0 )
	{
		xError = ( FF_Error_t ) ( FF_ERR_IOMAN_DRIVER_NOMEDIUM | FF_FINDFIRST );
	}
#endif /* ffconfigREMOVABLE_MEDIA */
	else
	{
		#if( ffconfigFINDAPI_ALLOW_WILDCARDS != 0 )
		{
			pxDirEntry->pcWildCard[0] = '\0';	/* WildCard blank if its not a wildCard. */

			pcWildCard = &pcPath[ PathLen - 1 ];

			if( PathLen != 0 )
			{
				/* Open the dir of the last token. */
				while( ( *pcWildCard != '\\' ) && ( *pcWildCard != '/' ) )
				{
					xIndex++;
					pcWildCard--;
					if( PathLen == xIndex )
					{
						break;
					}
				}
			}

			pxDirEntry->ulDirCluster = FF_FindDir( pxIOManager, pcPath, PathLen - xIndex, &xError );
			if( FF_isERR( xError ) == pdFALSE )
			{
				if( pxDirEntry->ulDirCluster != 0 )
				{
					/* Valid Dir found, copy the wildCard to filename! */
			#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
					wcsncpy( pxDirEntry->pcWildCard, ++pcWildCard, ffconfigMAX_FILENAME );
			#else
					strncpy( pxDirEntry->pcWildCard, ++pcWildCard, ffconfigMAX_FILENAME );
			#endif
					if( pxDirEntry->pcWildCard[ xIndex - 1 ] == ':' )
					{
						pxDirEntry->xInvertWildCard = pdTRUE;
						pxDirEntry->pcWildCard[ xIndex - 1 ] = '\0';
					}
				}
			}
		}
		#else /* ffconfigFINDAPI_ALLOW_WILDCARDS */
		{
			/* Get the directory cluster, if it exists. */
			pxDirEntry->ulDirCluster = FF_FindDir( pxIOManager, pcPath, PathLen, &xError );
		}
		#endif /* ffconfigFINDAPI_ALLOW_WILDCARDS */

		if( FF_isERR( xError ) == pdFALSE )
		{
			if( pxDirEntry->ulDirCluster == 0 )
			{
				xError = ( FF_Error_t ) ( FF_ERR_DIR_INVALID_PATH | FF_FINDFIRST );
			}
			else
			{
				/* Initialise the Fetch Context. */
				xError = FF_InitEntryFetch( pxIOManager, pxDirEntry->ulDirCluster, &( pxDirEntry->xFetchContext ) );
				if( FF_isERR( xError ) == pdFALSE )
				{
					pxDirEntry->usCurrentItem = 0;
					xError = FF_FindNext( pxIOManager, pxDirEntry );
				}
			}
		}
	}

	return xError;
}	/* FF_FindFirst() */
/*-----------------------------------------------------------*/

/**
 *	@public
 *	@brief	Get's the next Entry based on the data recorded in the FF_DirEnt_t object.
 *
 *	All values recorded in pxDirEntry must be preserved to and between calls to
 *	FF_FindNext( ). Please see @see FF_FindFirst( ) for find initialisation.
 *
 *	@param	pxIOManager		FF_IOManager_t object that was created by FF_CreateIOManger( ).
 *	@param	pxDirEntry		FF_DirEnt_t object to store the entry information. ( As initialised by FF_FindFirst( )).
 *
 *	@Return FF_ERR_DEVICE_DRIVER_FAILED is device access failed.
 *
 **/
FF_Error_t FF_FindNext( FF_IOManager_t *pxIOManager, FF_DirEnt_t *pxDirEntry )
{
FF_Error_t xError;
BaseType_t xLFNCount;
const uint8_t *pucEntryBuffer = NULL;
#if( ffconfigFINDAPI_ALLOW_WILDCARDS != 0 )
	BaseType_t	b;
#endif

	if( pxIOManager == NULL )
	{
		xError = ( FF_Error_t ) ( FF_ERR_NULL_POINTER | FF_FINDNEXT );
	}
#if( ffconfigREMOVABLE_MEDIA != 0 )
	else if( ( pxIOManager->ucFlags & FF_IOMAN_DEVICE_IS_EXTRACTED ) != 0 )
	{
		xError = ( FF_Error_t ) ( FF_ERR_IOMAN_DRIVER_NOMEDIUM | FF_FINDNEXT );
	}
#endif /* ffconfigREMOVABLE_MEDIA */
	else
	{
		xError = FF_ERR_NONE;
		for( ; pxDirEntry->usCurrentItem < FF_MAX_ENTRIES_PER_DIRECTORY; pxDirEntry->usCurrentItem++ )
		{
			if( ( pucEntryBuffer == NULL ) ||
				( pucEntryBuffer >= ( pxDirEntry->xFetchContext.pxBuffer->pucBuffer + ( FF_SIZEOF_SECTOR - FF_SIZEOF_DIRECTORY_ENTRY ) ) ) )
			{
				xError = FF_FetchEntryWithContext( pxIOManager, pxDirEntry->usCurrentItem, &( pxDirEntry->xFetchContext ), NULL );

				if( FF_isERR( xError ) )
				{
					break;
				}

				if( pucEntryBuffer == NULL )
				{
					pucEntryBuffer = pxDirEntry->xFetchContext.pxBuffer->pucBuffer +
						( FF_SIZEOF_DIRECTORY_ENTRY * ( pxDirEntry->usCurrentItem % ( FF_SIZEOF_SECTOR/FF_SIZEOF_DIRECTORY_ENTRY ) ) );
				}
				else
				{
					pucEntryBuffer = pxDirEntry->xFetchContext.pxBuffer->pucBuffer;
				}
			}
			else
			{
				pucEntryBuffer += FF_SIZEOF_DIRECTORY_ENTRY;
			}

			if( FF_isDeleted( pucEntryBuffer ) != pdFALSE )
			{
				/* The entry is not in use or deleted. */
				continue;
			}

			if( FF_isEndOfDir( pucEntryBuffer ) )
			{
				/* End of directory, generate a pseudo error 'DIR_END_OF_DIR'. */
				xError = ( FF_Error_t ) ( FF_ERR_DIR_END_OF_DIR | FF_FINDNEXT );
				break;
			}

			pxDirEntry->ucAttrib = FF_getChar( pucEntryBuffer, ( uint16_t ) ( FF_FAT_DIRENT_ATTRIB ) );

			if( ( pxDirEntry->ucAttrib & FF_FAT_ATTR_LFN ) == FF_FAT_ATTR_LFN )
			{
				/* LFN Processing. */
				xLFNCount = ( BaseType_t )( pucEntryBuffer[0] & ~0x40 );
				/* Get the shortname and check if it is marked deleted. */
				#if( ffconfigLFN_SUPPORT != 0 )
				{
				/* Reserve 32 bytes to hold one directory entry. */
				uint8_t	Buffer[ FF_SIZEOF_DIRECTORY_ENTRY ];

					/* Fetch the shortname, and get it's checksum, or for a deleted item with
					orphaned LFN entries. */
					xError = FF_FetchEntryWithContext( pxIOManager, ( uint32_t ) ( pxDirEntry->usCurrentItem + xLFNCount ), &pxDirEntry->xFetchContext, Buffer );
					if( FF_isERR( xError ) )
					{
						break;
					}

					if( FF_isDeleted( Buffer ) == pdFALSE )
					{
						xError = FF_PopulateLongDirent( pxIOManager, pxDirEntry, pxDirEntry->usCurrentItem, &pxDirEntry->xFetchContext );
						if( FF_isERR( xError ) )
						{
							break;
						}
						#if( ffconfigINCLUDE_SHORT_NAME != 0 )
						{
							pxDirEntry->ucAttrib |= FF_FAT_ATTR_IS_LFN;
						}
						#endif

						#if( ffconfigFINDAPI_ALLOW_WILDCARDS != 0 )
						{
						#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
							if( wcscmp( pxDirEntry->pcWildCard, L"" ) )
						#else
							if( pxDirEntry->pcWildCard[0] )
						#endif
							{
								b = FF_wildcompare( pxDirEntry->pcWildCard, pxDirEntry->pcFileName );
								if( pxDirEntry->xInvertWildCard != pdFALSE )
								{
									b = !b;
								}
								if( b != 0 )
								{
									break;
								}

								/* 'usCurrentItem' has already incremented by FF_PopulateLongDirent(),
								this loop will incremente it again. */
								pxDirEntry->usCurrentItem -= 1;

								/* xFetchContext/usCurrentItem have changed.  Update
								'pucEntryBuffer' to point to the current buffer position. */
								pucEntryBuffer = pxDirEntry->xFetchContext.pxBuffer->pucBuffer +
									( FF_SIZEOF_DIRECTORY_ENTRY * ( pxDirEntry->usCurrentItem % ( FF_SIZEOF_SECTOR/FF_SIZEOF_DIRECTORY_ENTRY ) ) );
							}
							else
							{
								break;
							}
						}
						#else	/* ffconfigFINDAPI_ALLOW_WILDCARDS == 0 */
						{
							/* usCurrentItem has been incremented by FF_PopulateLongDirent().
							Entry will be returned. */
							break;
						}
						#endif
					}
				}
				#else /* ffconfigLFN_SUPPORT */
				{
					/* Increment 'usCurrentItem' with (xLFNCount-1),
					the loop will do an extra increment. */
					pxDirEntry->usCurrentItem += ( xLFNCount - 1 );
				}
				#endif /* ffconfigLFN_SUPPORT */
			} /* ( ( pxDirEntry->ucAttrib & FF_FAT_ATTR_LFN ) == FF_FAT_ATTR_LFN ) */
			else if( ( pxDirEntry->ucAttrib & FF_FAT_ATTR_VOLID ) != FF_FAT_ATTR_VOLID )
			{
				/* If it's not a LFN entry, neither a Volume ID, it is a normal short name entry. */
				FF_PopulateShortDirent( pxIOManager, pxDirEntry, pucEntryBuffer );
				#if( ffconfigSHORTNAME_CASE != 0 )
				{
					/* Apply NT/XP+ bits to get correct case. */
					FF_CaseShortName( pxDirEntry->pcFileName, FF_getChar( pucEntryBuffer, FF_FAT_CASE_OFFS ) );
				}
				#endif

				#if( ffconfigFINDAPI_ALLOW_WILDCARDS != 0 )
				{
					if( pxDirEntry->pcWildCard[ 0 ] )
					{
						b = FF_wildcompare( pxDirEntry->pcWildCard, pxDirEntry->pcFileName );
						if( pxDirEntry->xInvertWildCard != pdFALSE )
						{
							b = !b;
						}
						if( b != 0 )
						{
							pxDirEntry->usCurrentItem += 1;
							break;
						}
					}
					else
					{
						pxDirEntry->usCurrentItem += 1;
						break;
					}
				}
				#else /* ffconfigFINDAPI_ALLOW_WILDCARDS */
				{
					pxDirEntry->usCurrentItem += 1;
					break;
				}
				#endif
			}
		} /* for ( ; pxDirEntry->usCurrentItem < FF_MAX_ENTRIES_PER_DIRECTORY; pxDirEntry->usCurrentItem++ ) */

		if( pxDirEntry->usCurrentItem == FF_MAX_ENTRIES_PER_DIRECTORY )
		{
			xError = ( FF_Error_t ) ( FF_ERR_DIR_END_OF_DIR | FF_FINDNEXT );
		}

		{
		FF_Error_t xTempError;
			xTempError = FF_CleanupEntryFetch( pxIOManager, &pxDirEntry->xFetchContext );

			if( FF_isERR( xError ) == pdFALSE )
			{
				xError = xTempError;
			}
		}
	}

	return xError;
}	/* FF_FindNext() */
/*-----------------------------------------------------------*/


/*
	Returns >= 0 for a free dirent entry.
	Returns <  0 with and xError code if anything goes wrong.
*/
static int32_t FF_FindFreeDirent( FF_IOManager_t *pxIOManager, FF_FindParams_t *pxFindParams, uint16_t usSequential )
{
const uint8_t *pucEntryBuffer = NULL;
uint16_t freeCount = 0;
UBaseType_t uxEntry = 0;
BaseType_t xEntryFound = pdFALSE;
FF_Error_t xError;
uint32_t DirLength;
FF_FetchContext_t xFetchContext;
uint32_t ulDirCluster = pxFindParams->ulDirCluster;

	xError = FF_InitEntryFetch( pxIOManager, ulDirCluster, &xFetchContext );

	if( FF_isERR( xError ) == pdFALSE )
	{
		uxEntry = pxFindParams->lFreeEntry >= 0 ? pxFindParams->lFreeEntry : 0;
		for ( ; uxEntry < FF_MAX_ENTRIES_PER_DIRECTORY; uxEntry++ )
		{
			if( ( pucEntryBuffer == NULL ) ||
				( pucEntryBuffer >= xFetchContext.pxBuffer->pucBuffer + ( FF_SIZEOF_SECTOR - FF_SIZEOF_DIRECTORY_ENTRY ) ) )
			{
				xError = FF_FetchEntryWithContext( pxIOManager, uxEntry, &xFetchContext, NULL );
				if( FF_GETERROR( xError ) == FF_ERR_DIR_END_OF_DIR )
				{

					xError = FF_ExtendDirectory( pxIOManager, ulDirCluster );
					/* The value of xEntryFound will be ignored in case there was an error. */
					xEntryFound = pdTRUE;
					break;
				}
				else if( FF_isERR( xError ) )
				{
					break;
				}
				if( pucEntryBuffer == NULL )
				{
					pucEntryBuffer = xFetchContext.pxBuffer->pucBuffer +
						( FF_SIZEOF_DIRECTORY_ENTRY * ( uxEntry % ( FF_SIZEOF_SECTOR / FF_SIZEOF_DIRECTORY_ENTRY ) ) );
				}
				else
				{
					pucEntryBuffer = xFetchContext.pxBuffer->pucBuffer;
				}
			}
			else
			{
				/* Advance 32 bytes to point to the next directory entry. */
				pucEntryBuffer += FF_SIZEOF_DIRECTORY_ENTRY;
			}
			if( FF_isEndOfDir( pucEntryBuffer ) )	/* If its the end of the Dir, then FreeDirents from here. */
			{
				/* Check if the directory has enough space */
				DirLength = xFetchContext.ulChainLength;
				if( ( uxEntry + usSequential ) >
					( ( DirLength * ( ( UBaseType_t )pxIOManager->xPartition.ulSectorsPerCluster * pxIOManager->xPartition.usBlkSize ) ) / FF_SIZEOF_DIRECTORY_ENTRY ) )
				{
					xError = FF_ExtendDirectory( pxIOManager, ulDirCluster );
				}
				xEntryFound = pdTRUE;
				break;
			}
			if( FF_isDeleted( pucEntryBuffer ) )
			{
				if( ++freeCount == usSequential )
				{
					xError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext );
					xEntryFound = pdTRUE;
					uxEntry = ( uxEntry - ( usSequential - 1 ) );/* Return the beginning entry in the sequential sequence. */
					break;
				}
			}
			else
			{
				freeCount = 0;
			}
		}	/* for ( uxEntry = 0; uxEntry < FF_MAX_ENTRIES_PER_DIRECTORY; uxEntry++ ) */

		{
		FF_Error_t xTempError;

			xTempError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext );
			if( FF_isERR( xError ) == pdFALSE )
			{
				xError = xTempError;
			}
		}

	}

	if( FF_isERR( xError ) == pdFALSE )
	{
		if( xEntryFound != pdFALSE )
		{
			/* No error has occurred and a free directory entry has been found. */
			xError = uxEntry;
		}
		else
		{
			xError = ( FF_Error_t ) ( FF_ERR_DIR_DIRECTORY_FULL | FF_FINDFREEDIRENT );
		}
	}

	return xError;
}	/* FF_FindFreeDirent() */
/*-----------------------------------------------------------*/

/* _HT_ Now FF_PutEntry has a new optional parameter *pucContents */
/* _HT_ so it can be used FF_MkDir( ) to save some code when adding . and .. entries  */
FF_Error_t FF_PutEntry( FF_IOManager_t *pxIOManager, uint16_t usEntry, uint32_t ulDirCluster, FF_DirEnt_t *pxDirEntry, uint8_t *pucContents )
{
FF_Error_t xError;
/* Reserve 32 bytes to hold one directory entry. */
uint8_t	pucEntryBuffer[ FF_SIZEOF_DIRECTORY_ENTRY ];
FF_FetchContext_t xFetchContext;

	/* HT: use the standard access routine to get the same logic for root dirs. */
	xError = FF_InitEntryFetch( pxIOManager, ulDirCluster, &xFetchContext );
	if( FF_isERR( xError ) == pdFALSE )
	{
		xError = FF_FetchEntryWithContext( pxIOManager, usEntry, &xFetchContext, pucEntryBuffer );
		if( FF_isERR( xError ) == pdFALSE )
		{
			/* Cleanup probably not necessary here?
			FF_PushEntryWithContext checks for R/W flag. */
			xError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext );
			if( FF_isERR( xError ) == pdFALSE )
			{
				if ( pucContents != NULL )
				{
					memcpy ( pucEntryBuffer, pucContents, sizeof( pucEntryBuffer ) );
				}
				FF_putChar( pucEntryBuffer,  FF_FAT_DIRENT_ATTRIB,    ( uint32_t ) pxDirEntry->ucAttrib );
				FF_putShort( pucEntryBuffer, FF_FAT_DIRENT_CLUS_HIGH, ( uint32_t ) ( pxDirEntry->ulObjectCluster >> 16 ) );
				FF_putShort( pucEntryBuffer, FF_FAT_DIRENT_CLUS_LOW,  ( uint32_t ) ( pxDirEntry->ulObjectCluster ) );
				FF_putLong( pucEntryBuffer,  FF_FAT_DIRENT_FILESIZE,  pxDirEntry->ulFileSize );
				#if( ffconfigTIME_SUPPORT != 0 )
				{
					FF_GetSystemTime( &pxDirEntry->xAccessedTime );	/*/< Date of Last Access. */
					FF_PlaceTime( pucEntryBuffer, FF_FAT_DIRENT_LASTACC_DATE, &pxDirEntry->xAccessedTime );
					FF_PlaceDate( pucEntryBuffer, FF_FAT_DIRENT_LASTACC_DATE, &pxDirEntry->xAccessedTime );	/* Last accessed date. */
					FF_PlaceTime( pucEntryBuffer, FF_FAT_DIRENT_CREATE_TIME,  &pxDirEntry->xCreateTime );
					FF_PlaceDate( pucEntryBuffer, FF_FAT_DIRENT_CREATE_DATE,  &pxDirEntry->xCreateTime );
					FF_PlaceTime( pucEntryBuffer, FF_FAT_DIRENT_LASTMOD_TIME, &pxDirEntry->xModifiedTime );
					FF_PlaceDate( pucEntryBuffer, FF_FAT_DIRENT_LASTMOD_DATE, &pxDirEntry->xModifiedTime );
				}
				#endif	/* ffconfigTIME_SUPPORT */
				xError = FF_PushEntryWithContext( pxIOManager, usEntry, &xFetchContext, pucEntryBuffer );
			}
		}
	}

	FF_CleanupEntryFetch( pxIOManager, &xFetchContext );

	return xError;
}	/* FF_PutEntry() */
/*-----------------------------------------------------------*/

static BaseType_t FF_ValidShortChar( char cChar )
{
	return ( cChar >= 'A' && cChar <= 'Z' ) ||
		( cChar >= 'a' && cChar <= 'z' ) ||	/* lower-case can be stored using NT/XP attribute. */
		( cChar >= '0' && cChar <= '9' ) ||
		strchr ( "$%-_@~`!(){}^#&", cChar ) != NULL;
}	/* FF_ValidShortChar() */
/*-----------------------------------------------------------*/

#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
void FF_CreateShortName( FF_FindParams_t *pxFindParams, const FF_T_WCHAR *pcLongName )
#else
void FF_CreateShortName( FF_FindParams_t *pxFindParams, const char *pcLongName )
#endif
{
BaseType_t xIndex, xPosition, xLastDot;
uint16_t NameLen;

#if( ffconfigSHORTNAME_CASE != 0 )
	uint8_t testAttrib = FF_FAT_CASE_ATTR_BASE;
#endif

	/* Examples:
	 * "readme.TXT" will get the attribute FF_FAT_CASE_ATTR_BASE
	 * "README.txt" will get the attribute FF_FAT_CASE_ATTR_EXT
	 * "Readme.txt" can not be store as a short name */

	pxFindParams->ucCaseAttrib = 0;		/* May get the value FF_FAT_CASE_ATTR_BASE or FF_FAT_CASE_ATTR_EXT */
	pxFindParams->ucFirstTilde = 6;		/* The numerical position of the ~ */
	pxFindParams->ulFlags |= FIND_FLAG_SHORTNAME_SET | FIND_FLAG_FITS_SHORT | FIND_FLAG_SIZE_OK;

	#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	{
		NameLen = ( uint16_t ) wcslen( pcLongName );
	}
	#else
	{
		NameLen = ( uint16_t ) strlen( pcLongName );
	}
	#endif

	/* Does pcLongName fit a shortname? */

	for( xIndex = 0, xPosition = 0, xLastDot = NameLen; xIndex < NameLen; xIndex++ )
	{
		if( pcLongName[ xIndex ] != '.' )
		{
			xPosition++;
		}
		else
		{
			xLastDot = xIndex;
		}
	}
	/* For example:
	"FILENAME.EXT": NameLen = 12, xLastDot = 8, xPosition = 11
	".cproject"   : NameLen =  9, xLastDot = 0, xPosition =  8
	*/

	if( ( NameLen > 12 ) ||				/* If name is longer than 12 characters (8.3). */
		( NameLen - xPosition > 1 ) ||	/* If it contains more than 1 dot. */
		( NameLen - xLastDot > 4 ) ||	/* If the file name extension is longer than 3 characters. */
		( xLastDot > 8 ) )				/* If the file name base is too long. */
	{
		pxFindParams->ulFlags &= ~FIND_FLAG_SIZE_OK;
	}

	for( xIndex = 0, xPosition = 0; xIndex < 11; xPosition++ )
	{
		char ch = pcLongName[ xPosition ];
		if( !ch )
			break;
		if( ( xIndex == 0 ) && ( ch == '.' ) )
		{
			pxFindParams->ulFlags &= ~FIND_FLAG_FITS_SHORT;
			continue;
		}
		if( xPosition == xLastDot )
		{
			/* Remember where we put the first space. */
			if ( pxFindParams->ucFirstTilde > xIndex )
			{
				pxFindParams->ucFirstTilde = xIndex;
			}
			while ( xIndex < 8 )
			{
				pxFindParams->pcEntryBuffer[ xIndex++ ] = 0x20;
			}
			#if( ffconfigSHORTNAME_CASE != 0 )
			{
				testAttrib = FF_FAT_CASE_ATTR_EXT;
			}
			#endif
		}
		else
		{
			if( xIndex == 8 )
			{
				if( xPosition <= xLastDot )
				{
					xPosition = xLastDot;
					ch = ( int8_t ) pcLongName[ xPosition ];
					if( ch == '\0' )
					{
						break;
					}
					ch = ( int8_t ) pcLongName[ ++xPosition ];
					#if( ffconfigSHORTNAME_CASE != 0 )
					{
						testAttrib = FF_FAT_CASE_ATTR_EXT;
					}
					#endif
				}
			}
			if( !FF_ValidShortChar ( ch ) )
			{
				pxFindParams->ulFlags &= ~FIND_FLAG_FITS_SHORT;
				continue;
			}
			#if( ffconfigSHORTNAME_CASE != 0 )
			{
				if( ( ch >= 'a' ) && ( ch <= 'z' ) )
				{
					ch -= 0x20;
					if ( testAttrib )
					{
						pxFindParams->ucCaseAttrib |= testAttrib;
					}
					else
					{
						pxFindParams->ulFlags &= ~FIND_FLAG_FITS_SHORT;	/* We had capital: does not fit. */
					}
				}
				else if( ( ch >= 'A' ) && ( ch <= 'Z' ) )
				{
					if( ( pxFindParams->ucCaseAttrib & testAttrib ) != 0 )
					{
						pxFindParams->ulFlags &= ~FIND_FLAG_FITS_SHORT;	/* We had lower-case: does not fit. */
					}
					testAttrib = 0;
				}
			}
			#else
			{
				if( ( ch >= 'a' ) && ( ch <= 'z' ) )
				{
					ch -= 0x20;
				}
			}
			#endif /* ffconfigSHORTNAME_CASE */
			pxFindParams->pcEntryBuffer[ xIndex++ ] = ch;
		}
	}

	if( ( xLastDot == 0 ) && ( xIndex < 6 ) )
	{
		/* This is a file name like ".info" or ".root" */
		pxFindParams->ucFirstTilde = xIndex;
	}

	while ( xIndex < 11 )
	{
		pxFindParams->pcEntryBuffer[ xIndex++ ] = 0x20;
	}

	if( ( xLastDot < pxFindParams->ucFirstTilde ) && ( xLastDot > 0 ) )
	{
		pxFindParams->ucFirstTilde = xLastDot;
	}

	if( NameLen < pxFindParams->ucFirstTilde )	/* Names like "Abc" will become "~Abc". */
	{
		pxFindParams->ucFirstTilde = ( uint8_t ) NameLen;
	}
}	/* FF_CreateShortName() */
/*-----------------------------------------------------------*/

int32_t FF_FindShortName( FF_IOManager_t *pxIOManager, FF_FindParams_t *pxFindParams )
{
char pcMyShortName[ 13 ];
FF_DirEnt_t xMyDirectory;
FF_Error_t xResult = 0;
BaseType_t xIndex, x, y;
uint16_t NameLen;
char pcNumberBuf[ 12 ];
uint32_t ulCluster;

#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	FF_T_WCHAR	pcFileName[ 13 ];
#else
	char	*pcFileName = pcMyShortName;
#endif	/* ffconfigUNICODE_UTF16_SUPPORT */

#if( ipconfigQUICK_SHORT_FILENAME_CREATION != 0 )
	uint16_t usShortHash;
	uint32_t ulRand = 0ul;
#endif

	memcpy( pcMyShortName, pxFindParams->pcEntryBuffer, 11 );
	FF_ProcessShortName( pcMyShortName );
	if( ( pxFindParams->ulFlags & FIND_FLAG_FITS_SHORT_OK ) == FIND_FLAG_FITS_SHORT_OK )
	{
		/* This entry will not get a LFN entry because it fits
		 * perfectly into a host name */
		if( ( pxFindParams->ulFlags & FIND_FLAG_SHORTNAME_CHECKED ) != 0 )
		{
			if( ( pxFindParams->ulFlags & FIND_FLAG_SHORTNAME_FOUND ) != 0 )
			{
				xResult = ( FF_Error_t ) ( FF_ERR_DIR_OBJECT_EXISTS | FF_CREATESHORTNAME );
			}
			else
			{
				xResult = pxFindParams->ucCaseAttrib | 0x01;
			}
		}
		else
		{
			#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
			{
				memcpy( pcFileName, pcMyShortName, sizeof( pcMyShortName ) );
				FF_ShortNameExpand( pcFileName );
			}
			#endif
			ulCluster = FF_FindEntryInDir( pxIOManager, pxFindParams, pcFileName, 0x00, &xMyDirectory, &xResult );

			/* END_OF_DIR is not a fatal error, it only means that the entry was not found. */
			if( ( FF_isERR( xResult ) == pdFALSE ) || ( FF_GETERROR( xResult ) == FF_ERR_DIR_END_OF_DIR ) )
			{
				if( ulCluster == 0UL )
				{
					xResult = pxFindParams->ucCaseAttrib | 0x01;
				}
				else
				{
					xResult = ( FF_Error_t ) ( FF_ERR_DIR_OBJECT_EXISTS | FF_CREATESHORTNAME );
				}
			}
			else
			{
				/* There was an error, which will be returned. */
			}
		}
	}
	else
	{
		for( xIndex = ( ( pxFindParams->ulFlags & FIND_FLAG_SIZE_OK ) ? 0 : 1 ); ; xIndex++ )
		{
			if( xIndex != 0 )
			{
				#if( ipconfigQUICK_SHORT_FILENAME_CREATION != 0 )
				{
					/* In the first round, check if the original name can be used
					Makefile will be stored as "makefile" and not as "makefi~1". */

					/* This method saves a lot of time when creating directories with
					many similar file names: when the short name version of a LFN already
					exists, try at most 3 entries with a tilde:
						README~1.TXT
						README~2.TXT
						README~3.TXT
					After that create entries with pseudo-random 4-digit hex digits:
						REA~E7BB.TXT
						REA~BA32.TXT
						REA~D394.TXT
					*/
					if( xIndex <= 4 )
					{
						snprintf( pcNumberBuf, sizeof( pcNumberBuf ), "%d", ( int ) xIndex );
					}
					else
					{
						if( ulRand == 0ul )
						{
							ulRand = pxIOManager->xPartition.ulLastFreeCluster;
							usShortHash = FF_GetCRC16( ( uint8_t *)&ulRand, sizeof( ulRand ) );
						}
						else
						{
							usShortHash = FF_GetCRC16( ( uint8_t *)&usShortHash, sizeof( usShortHash ) );
						}
						snprintf( pcNumberBuf, sizeof( pcNumberBuf ), "%04X", ( int ) usShortHash );
					}
				}
				#else
				{
					snprintf( pcNumberBuf, sizeof( pcNumberBuf ), "%d", ( int ) xIndex );
				}
				#endif

				NameLen = ( uint16_t ) strlen( pcNumberBuf );
				x = 7 - NameLen;
				if ( x > pxFindParams->ucFirstTilde )
				{
					x = pxFindParams->ucFirstTilde;
				}
				pxFindParams->pcEntryBuffer[ x++ ] = '~';
				for( y = 0; y < NameLen; y++ )
				{
					pxFindParams->pcEntryBuffer[ x + y ] = pcNumberBuf[ y ];
				}
			}
			memcpy( pcMyShortName, pxFindParams->pcEntryBuffer, 11 );
			FF_ProcessShortName( pcMyShortName );
			if( FF_ShortNameExists( pxIOManager, pxFindParams->ulDirCluster, pcMyShortName, &xResult ) == pdFALSE )
			{
				break;
			}
			if( xIndex >= FF_MAX_ENTRIES_PER_DIRECTORY )
			{
				xResult = ( FF_Error_t ) ( FF_ERR_DIR_DIRECTORY_FULL | FF_CREATESHORTNAME );
				break;
			}
		}
		/* Add a tail and special number until we're happy :D. */
	}

	return xResult;
}	/* FF_FindShortName () */
/*-----------------------------------------------------------*/


#if( ffconfigLFN_SUPPORT != 0 )
	static int8_t FF_CreateLFNEntry( uint8_t *pucEntryBuffer, uint8_t *pcName, UBaseType_t uxNameLength, UBaseType_t uxLFN, uint8_t ucCheckSum )
	{
		/*
		 *	HT for JW:
		 *	Changed *pcName from 16- to of 8-bits
		 *	The caller of this function doesn't need an expensive
		 *	uint16_t usUtf16Name[ffconfigMAX_FILENAME + 1];
		 *  in case UNICODE isn't used
		 *  Also did quite a bit of optimisation here
		 *  and tested well
		 */
		UBaseType_t uxIndex, x;

		memset( pucEntryBuffer, 0, FF_SIZEOF_DIRECTORY_ENTRY );

		FF_putChar( pucEntryBuffer, FF_FAT_LFN_ORD, ( uint8_t )( ( uxLFN & ~0x40 ) ) );
		FF_putChar( pucEntryBuffer, FF_FAT_DIRENT_ATTRIB, ( uint8_t ) FF_FAT_ATTR_LFN );
		FF_putChar( pucEntryBuffer, FF_FAT_LFN_CHECKSUM, ( uint8_t ) ucCheckSum );

		/* Name_1. */
		uxIndex = 0;
		for( x = FF_FAT_LFN_NAME_1; uxIndex < 5u; uxIndex++, x += 2 )
		{
			if( uxIndex < uxNameLength )
			{
				pucEntryBuffer[ x ] = *( pcName++ );
				#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) || ( ffconfigUNICODE_UTF8_SUPPORT != 0 )
				{
					pucEntryBuffer[ x + 1 ] = *( pcName++ );
				}
				#endif
			}
			else if ( uxIndex > uxNameLength )
			{
				pucEntryBuffer[ x] = 0xFF;
				pucEntryBuffer[ x + 1 ] = 0xFF;
			}
		}

		/* Name_2. */
		for( x = FF_FAT_LFN_NAME_2; uxIndex < 11u; uxIndex++, x += 2 )
		{
			if( uxIndex < uxNameLength )
			{
				pucEntryBuffer[ x ] = *( pcName++ );
				#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) || ( ffconfigUNICODE_UTF8_SUPPORT != 0 )
				{
					pucEntryBuffer[ x + 1 ] = *( pcName++ );
				}
				#endif
			}
			else if( uxIndex > uxNameLength )
			{
				pucEntryBuffer[ x ] = 0xFF;
				pucEntryBuffer[ x + 1 ] = 0xFF;
			}
		}

		/* Name_3. */
		for( x = FF_FAT_LFN_NAME_3; uxIndex < 13u; uxIndex++, x += 2 )
		{
			if( uxIndex < uxNameLength )
			{
				pucEntryBuffer[ x ] = *( pcName++ );
				#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) || ( ffconfigUNICODE_UTF8_SUPPORT != 0 )
				{
					pucEntryBuffer[ x + 1 ] = *( pcName++ );
				}
				#endif
			}
			else if( uxIndex > uxNameLength )
			{
				pucEntryBuffer[ x ] = 0xFF;
				pucEntryBuffer[ x + 1 ] = 0xFF;
			}
		}

		return FF_ERR_NONE;
	}	/* FF_CreateLFNEntry() */
#endif /* ffconfigLFN_SUPPORT */
/*-----------------------------------------------------------*/

#if( ffconfigLFN_SUPPORT != 0 )
	#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	static FF_Error_t FF_CreateLFNs( FF_IOManager_t *pxIOManager, uint32_t ulDirCluster, FF_T_WCHAR *pcName, uint8_t ucCheckSum, uint16_t usEntry )
	#else
	static FF_Error_t FF_CreateLFNs( FF_IOManager_t *pxIOManager, uint32_t ulDirCluster, char *pcName, uint8_t ucCheckSum, uint16_t usEntry )
	#endif
	{
	FF_Error_t xError = FF_ERR_NONE;
	BaseType_t xNumLFNs;
	BaseType_t xEndPos;
	BaseType_t xIndex, y;
	FF_FetchContext_t xFetchContext;
	uint8_t pucEntryBuffer[ FF_SIZEOF_DIRECTORY_ENTRY ];

	#if ( ffconfigUNICODE_UTF8_SUPPORT != 0 )
		int32_t slRetVal;
	#endif

	#if( ffconfigUNICODE_UTF16_SUPPORT != 0 ) || ( ffconfigUNICODE_UTF8_SUPPORT != 0 )
		uint16_t usUtf16Name[ ffconfigMAX_FILENAME + 1 ];
	#endif

	#if( ffconfigUNICODE_UTF16_SUPPORT == 0 )
		char *NamePtr;
	#else
		int16_t *NamePtr;
	#endif


		#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
		{
			#if WCHAR_MAX <= 0xFFFF
			{
				y = wcslen( pcName );
				if( y > ffconfigMAX_FILENAME )
				{
					xError = ( FF_Error_t ) ( FF_ERR_DIR_NAME_TOO_LONG | FF_CREATELFNS );
				}
				else
				{
					wcsncpy( usUtf16Name, pcName, ffconfigMAX_FILENAME );
				}
			}
			#else
			{
				xIndex = 0;
				y = 0;
				while( pcName[ xIndex ] )
				{
					FF_Utf32ctoUtf16c( &usUtf16Name[ y ], ( uint32_t ) pcName[xIndex], ffconfigMAX_FILENAME - xIndex );
					y += FF_GetUtf16SequenceLen( usUtf16Name[ y ] );
					xIndex++;
					if( y > ffconfigMAX_FILENAME )
					{
						xError = ( FF_Error_t ) ( FF_ERR_DIR_NAME_TOO_LONG | FF_CREATELFNS );
						break;
					}
				}
			}
			#endif
		}
		#endif /* ffconfigUNICODE_UTF16_SUPPORT */

		/* Convert the name into UTF-16 format. */
		#if ( ffconfigUNICODE_UTF8_SUPPORT != 0 )
		{
			/* Simply convert the UTF8 to UTF16 and be done with it. */
			xIndex = 0;
			y = 0;
			while( pcName[ xIndex ] != 0 )
			{
				slRetVal = FF_Utf8ctoUtf16c( &( usUtf16Name[ y ] ), ( uint8_t * )&( pcName[ xIndex ] ), ffconfigMAX_FILENAME - xIndex );
				if( slRetVal > 0 )
				{
					xIndex += slRetVal;
				}
				else
				{
					break;	/* No more space in the UTF-16 buffer, simply truncate for safety. */
				}
				y += FF_GetUtf16SequenceLen( usUtf16Name[ y ] );
				if( y > ffconfigMAX_FILENAME )
				{
					xError = ( FF_Error_t ) ( FF_ERR_DIR_NAME_TOO_LONG | FF_CREATELFNS );
					break;
				}
			}
		}
		#elif ( ffconfigUNICODE_UTF16_SUPPORT == 0 )
		{
			/* Just check the length. */
			y = strlen( pcName );
			if( y > ffconfigMAX_FILENAME )
			{
				xError = ( FF_Error_t ) ( FF_ERR_DIR_NAME_TOO_LONG | FF_CREATELFNS );
			}
		}
		#endif

		/* Whole name is now in a valid UTF-16 format. Lets go make thos LFN's.
		At this point, it should a be the length of the name. */
		if( FF_isERR( xError ) == pdFALSE )
		{
			xNumLFNs	= y / 13;	/* Number of LFNs is the total number of UTF-16 units, divided by 13 ( 13 units per LFN ). */
			xEndPos	= y % 13;	/* The ending position in an LFN, of the last LFN UTF-16 character. */

			if( xEndPos )
			{
				xNumLFNs++;
			}
			else
			{
				xEndPos = 13;
			}

			xError = FF_InitEntryFetch( pxIOManager, ulDirCluster, &xFetchContext );
			if( FF_isERR( xError ) == pdFALSE )
			{
				#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
				{
					NamePtr = ( int16_t * ) ( usUtf16Name + 13 * ( xNumLFNs - 1 ) );
				}
				#elif ( ffconfigUNICODE_UTF8_SUPPORT != 0 )
				{
					NamePtr = ( int8_t * ) ( usUtf16Name + 13 * ( xNumLFNs - 1 ) );
				}
				#else
				{
					NamePtr = pcName + 13 * ( xNumLFNs - 1 );
				}
				#endif
				/* After this point, xIndex is no longer the length of the Filename in UTF-16 units. */
				for( xIndex = xNumLFNs; xIndex > 0; xIndex-- )
				{
					if( xIndex == xNumLFNs )
					{
						FF_CreateLFNEntry( pucEntryBuffer, ( uint8_t * ) NamePtr, ( UBaseType_t ) xEndPos, ( UBaseType_t ) xIndex, ucCheckSum );
						pucEntryBuffer[0] |= 0x40;
					}
					else
					{
						FF_CreateLFNEntry( pucEntryBuffer, ( uint8_t * ) NamePtr, ( UBaseType_t ) 13u, ( UBaseType_t ) xIndex, ucCheckSum );
					}
					NamePtr -= 13;

					xError = FF_PushEntryWithContext( pxIOManager, ( uint32_t ) ( usEntry + ( xNumLFNs - xIndex ) ), &xFetchContext, pucEntryBuffer );
					if( FF_isERR( xError ) )
					{
						break;
					}
				}

				{
				FF_Error_t xTempError;

					/* Release any buffers that were used. */
					xTempError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext );
					if( FF_isERR( xTempError ) == pdFALSE )
					{
						xError = xTempError;
					}
				}
			}
		}

		return xError;
	}	/* FF_CreateLFNs() */
#endif /* ffconfigLFN_SUPPORT */
/*-----------------------------------------------------------*/

FF_Error_t FF_ExtendDirectory( FF_IOManager_t *pxIOManager, uint32_t ulDirCluster )
{
uint32_t xCurrentCluster;
uint32_t xNextCluster = 0UL;
FF_Error_t xError = FF_ERR_NONE;
FF_FATBuffers_t xFATBuffers;

	if( ( ulDirCluster == pxIOManager->xPartition.ulRootDirCluster ) &&
		( pxIOManager->xPartition.ucType != FF_T_FAT32 ) )
	{
		/* root directories on FAT12 and FAT16 can not be extended. */
		xError = ( FF_Error_t ) ( FF_ERR_DIR_CANT_EXTEND_ROOT_DIR | FF_EXTENDDIRECTORY );
	}
	else if( pxIOManager->xPartition.ulFreeClusterCount == 0UL )
	{
		/* The number of free clusters was not yet calculated or equal to zero. */
		pxIOManager->xPartition.ulFreeClusterCount = FF_CountFreeClusters( pxIOManager, &xError );
	}

	if( FF_isERR( xError ) == pdFALSE )
	{
		if( pxIOManager->xPartition.ulFreeClusterCount == 0UL )
		{
			xError = ( FF_Error_t ) ( FF_ERR_FAT_NO_FREE_CLUSTERS | FF_EXTENDDIRECTORY );
		}
		else
		{
			FF_LockFAT( pxIOManager );
			{
				xCurrentCluster = FF_FindEndOfChain( pxIOManager, ulDirCluster, &xError );
				if( FF_isERR( xError ) == pdFALSE )
				{
					xNextCluster = FF_FindFreeCluster( pxIOManager, &xError, pdTRUE );
					if( FF_isERR( xError ) == pdFALSE )
					{
						FF_InitFATBuffers ( &xFATBuffers, FF_MODE_WRITE );
						/* xNextCluster already has been set to 0xFFFFFFFF,
						now let xCurrentCluster point to xNextCluster. */

						xError = FF_putFATEntry( pxIOManager, xCurrentCluster, xNextCluster, &xFATBuffers );
						{
						FF_Error_t xTempError;

							xTempError = FF_ReleaseFATBuffers( pxIOManager, &xFATBuffers );
							if( FF_isERR( xError ) == pdFALSE )
							{
								xError = xTempError;
							}

							xTempError = FF_DecreaseFreeClusters( pxIOManager, 1 );
							if( FF_isERR( xError ) == pdFALSE )
							{
								xError = xTempError;
							}
						}
					}
				}
			}
			FF_UnlockFAT( pxIOManager );

			if( FF_isERR( xError ) == pdFALSE )
			{
				/* The entire cluster will be filled with zero's,
				because it will contain directory data. */
				xError = FF_ClearCluster( pxIOManager, xNextCluster );
			}
		}
	}

	return xError;
}	/* FF_ExtendDirectory() */
/*-----------------------------------------------------------*/

static const uint8_t forbiddenChrs[] =
{
/* Windows says: don't use these characters: '\/:*?"<>|'
    "     *     /	    :     <     >     ?    '\'    ?     | */
	0x22, 0x2A, 0x2F, 0x3A, 0x3C, 0x3E, 0x3F, 0x5C, 0x7F, 0x7C
};

#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
static void FF_MakeNameCompliant( FF_T_WCHAR *pcName )
#else
static void FF_MakeNameCompliant( char *pcName )
#endif
{
	BaseType_t index;
	if( ( uint8_t ) pcName[ 0 ] == FF_FAT_DELETED )	/* Support Japanese KANJI symbol0xE5. */
	{
		pcName[ 0 ] = 0x05;
	}
	for( ; *pcName; pcName++ )
	{
		for( index = 0; index < ( BaseType_t ) sizeof( forbiddenChrs ); index++ )
		{
			if( *pcName == forbiddenChrs[index] )
			{
				*pcName = '_';
				break;
			}
		}
	}
}	/* FF_MakeNameCompliant() */
/*-----------------------------------------------------------*/

FF_Error_t FF_CreateDirent( FF_IOManager_t *pxIOManager, FF_FindParams_t *pxFindParams, FF_DirEnt_t *pxDirEntry )
{
uint8_t	pucEntryBuffer[ FF_SIZEOF_DIRECTORY_ENTRY ];

BaseType_t xLFNCount;
int32_t	lFreeEntry = 0L;
FF_Error_t xReturn = FF_ERR_NONE;
BaseType_t xEntryCount;
FF_FetchContext_t xFetchContext;
uint32_t	ulDirCluster = pxFindParams->ulDirCluster;
int32_t lFitShort;

#if( ffconfigHASH_CACHE != 0 )
	char pcShortName[ 13 ];
#endif
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	uint16_t NameLen = ( uint16_t ) wcslen( pxDirEntry->pcFileName );
#else
	uint16_t NameLen = ( uint16_t ) strlen( pxDirEntry->pcFileName );
#endif

#if( ffconfigLFN_SUPPORT != 0 )
	uint8_t	ucCheckSum;
#endif

	/* Round-up the number of LFN's needed: */
	xLFNCount = ( BaseType_t ) ( ( NameLen + 12 ) / 13 );

	#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	{
		FF_MakeNameCompliant( pxDirEntry->pcFileName );	/* Ensure we don't break the Dir tables. */
	}
	#else
	{
		FF_MakeNameCompliant( pxDirEntry->pcFileName );	/* Ensure we don't break the Dir tables. */
	}
	#endif
	memset( pucEntryBuffer, 0, sizeof( pucEntryBuffer ) );

	#if( ffconfigLFN_SUPPORT != 0 )
	{
		/* Create and push the LFN's. */
		/* Find enough places for the LFNs and the ShortName. */
		xEntryCount = xLFNCount + 1;
	}
	#else
	{
		xEntryCount = 1;
	}
	#endif

	/* Create the ShortName. */
	FF_LockDirectory( pxIOManager );
	do
	{
		/* Open a do {} while( pdFALSE ) loop to allow the use of break statements. */
		/* As FF_FindShortName( ) can fail, it should be called before finding a free directory entry. */
		if( ( pxFindParams->ulFlags & FIND_FLAG_SHORTNAME_SET ) == 0 )
		{
			FF_CreateShortName( pxFindParams, pxDirEntry->pcFileName );
		}
		lFitShort = FF_FindShortName ( pxIOManager, pxFindParams );

		memcpy( pucEntryBuffer, pxFindParams->pcEntryBuffer, sizeof( pucEntryBuffer ) );

		if( FF_isERR( lFitShort ) )
		{
			xReturn = lFitShort;
			break;
		}
		if( lFitShort != 0 )
		{
			/* There is no need to create a LFN entry because the file name
			fits into a normal 32-byte entry.. */
			xLFNCount = 0;
			xEntryCount = 1;
		}
		lFreeEntry = FF_FindFreeDirent( pxIOManager, pxFindParams, ( uint16_t ) xEntryCount );

		if( FF_isERR( lFreeEntry ) )
		{
			xReturn = lFreeEntry;
			break;
		}
		#if( ffconfigLFN_SUPPORT != 0 )
		{
			if( xLFNCount > 0 )
			{
				ucCheckSum = FF_CreateChkSum( pucEntryBuffer );
				xReturn = FF_CreateLFNs( pxIOManager, ulDirCluster, pxDirEntry->pcFileName, ucCheckSum, ( uint16_t ) lFreeEntry );
			}
		}
		#else
		{
			xLFNCount = 0;
		}
		#endif /* ffconfigLFN_SUPPORT */
		if( FF_isERR( xReturn ) == pdFALSE )
		{
			#if( ffconfigTIME_SUPPORT != 0 )
			{
				FF_GetSystemTime( &pxDirEntry->xCreateTime );		/* Date and Time Created. */
				pxDirEntry->xModifiedTime = pxDirEntry->xCreateTime;	/* Date and Time Modified. */
				pxDirEntry->xAccessedTime = pxDirEntry->xCreateTime;	/* Date of Last Access. */
				FF_PlaceTime( pucEntryBuffer, FF_FAT_DIRENT_CREATE_TIME, &pxDirEntry->xCreateTime );
				FF_PlaceDate( pucEntryBuffer, FF_FAT_DIRENT_CREATE_DATE, &pxDirEntry->xCreateTime );
				FF_PlaceTime( pucEntryBuffer, FF_FAT_DIRENT_LASTMOD_TIME, &pxDirEntry->xModifiedTime );
				FF_PlaceDate( pucEntryBuffer, FF_FAT_DIRENT_LASTMOD_DATE, &pxDirEntry->xModifiedTime );
			}
			#endif /*  ffconfigTIME_SUPPORT */

			FF_putChar( pucEntryBuffer,  FF_FAT_DIRENT_ATTRIB, pxDirEntry->ucAttrib );
		#if( ffconfigSHORTNAME_CASE != 0 )
			FF_putChar( pucEntryBuffer,  FF_FAT_CASE_OFFS, ( uint32_t ) lFitShort & ( FF_FAT_CASE_ATTR_BASE | FF_FAT_CASE_ATTR_EXT ) );
		#endif
			FF_putShort( pucEntryBuffer, FF_FAT_DIRENT_CLUS_HIGH, ( uint16_t )( pxDirEntry->ulObjectCluster >> 16 ) );
			FF_putShort( pucEntryBuffer, FF_FAT_DIRENT_CLUS_LOW, ( uint16_t )( pxDirEntry->ulObjectCluster ) );
			FF_putLong( pucEntryBuffer,  FF_FAT_DIRENT_FILESIZE, pxDirEntry->ulFileSize );

			xReturn = FF_InitEntryFetch( pxIOManager, ulDirCluster, &xFetchContext );
			if( FF_isERR( xReturn ) )
			{
				break;
			}
			xReturn = FF_PushEntryWithContext( pxIOManager, ( uint16_t ) ( lFreeEntry + xLFNCount ), &xFetchContext, pucEntryBuffer );

			{
			FF_Error_t xTempError;

				xTempError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext );
				if( FF_isERR( xReturn ) == pdFALSE )
				{
					xReturn = xTempError;
				}
			}
			if( FF_isERR( xReturn ) )
			{
				break;
			}

			#if( ffconfigHASH_CACHE != 0 )
			{
				if( FF_DirHashed( pxIOManager, ulDirCluster ) == pdFALSE )
				{
					/* Hash the directory. */
					FF_HashDir( pxIOManager, ulDirCluster );
				}
				memcpy( pcShortName, pucEntryBuffer, 11 );
				FF_ProcessShortName( pcShortName );		/* Format the shortname to 8.3. */
				#if( ffconfigHASH_FUNCTION == CRC16 )
				{
					FF_AddDirentHash( pxIOManager, ulDirCluster, ( uint32_t )FF_GetCRC16( ( uint8_t * ) pcShortName, strlen( pcShortName ) ) );
				}
				#elif( ffconfigHASH_FUNCTION == CRC8 )
				{
					FF_AddDirentHash( pxIOManager, ulDirCluster, ( uint32_t )FF_GetCRC8( ( uint8_t * ) pcShortName, strlen( pcShortName ) ) );
				}
				#endif /* ffconfigHASH_FUNCTION */
			}
			#endif /* ffconfigHASH_CACHE*/
		}
	}
	while( pdFALSE );

	FF_UnlockDirectory( pxIOManager );

	if( FF_isERR( xReturn ) == pdFALSE )
	{
		if( pxDirEntry != NULL )
		{
			pxDirEntry->usCurrentItem = ( uint16_t )( lFreeEntry + xLFNCount );
		}
	}

	return xReturn;
}	/* FF_CreateDirent() */
/*-----------------------------------------------------------*/


#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
uint32_t FF_CreateFile( FF_IOManager_t *pxIOManager, FF_FindParams_t *pxFindParams, FF_T_WCHAR *pcFileName, FF_DirEnt_t *pxDirEntry, FF_Error_t *pxError )
#else
uint32_t FF_CreateFile( FF_IOManager_t *pxIOManager, FF_FindParams_t *pxFindParams, char *pcFileName, FF_DirEnt_t *pxDirEntry, FF_Error_t *pxError )
#endif
{
FF_DirEnt_t xMyFile;
FF_Error_t xTempError, xError = FF_ERR_NONE;
uint32_t ulResult;

	memset ( &xMyFile, '\0', sizeof( xMyFile ) );

	#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	{
		wcsncpy( xMyFile.pcFileName, pcFileName, ffconfigMAX_FILENAME );
	}
	#else
	{
		strncpy( xMyFile.pcFileName, pcFileName, ffconfigMAX_FILENAME );
	}
	#endif

	xMyFile.ulObjectCluster = FF_CreateClusterChain( pxIOManager, &xError );

	if( FF_isERR( xError ) == pdFALSE )
	{
		xError = FF_CreateDirent( pxIOManager, pxFindParams, &xMyFile );
		if( FF_isERR( xError ) == pdFALSE )
		{
			/* The new file now has a cluster chain and it has an entry
			in its directory.  Copy data to a pointer provided by caller: */
			if( pxDirEntry != NULL )
			{
				memcpy( pxDirEntry, &xMyFile, sizeof( FF_DirEnt_t ) );
			}
		}
		else
		{
			/* An error occurred in FF_CreateDirent().
			Unlink the file's cluster chain: */
			FF_LockFAT( pxIOManager );
			{
				FF_UnlinkClusterChain( pxIOManager, xMyFile.ulObjectCluster, 0 );
				xMyFile.ulObjectCluster = 0ul;
			}
			FF_UnlockFAT( pxIOManager );
		}
		/* Now flush all buffers to disk. */
		xTempError = FF_FlushCache( pxIOManager );
		if( FF_isERR( xError ) == pdFALSE )
		{
			xError = xTempError;
		}
	}

	*pxError = xError;

	if( FF_isERR( xError ) == pdFALSE )
	{
		ulResult = xMyFile.ulObjectCluster;
	}
	else
	{
		ulResult = 0;
	}

	return ulResult;
}	/* FF_CreateFile() */
/*-----------------------------------------------------------*/


/**
 *	@brief Creates a Directory of the specified path.
 *
 *	@param	pxIOManager	Pointer to the FF_IOManager_t object.
 *	@param	pcPath	Path of the directory to create.
 *
 *	@Return	FF_ERR_NULL_POINTER if pxIOManager was NULL.
 *	@Return FF_ERR_DIR_OBJECT_EXISTS if the object specified by path already exists.
 *	@Return	FF_ERR_DIR_INVALID_PATH
 *	@Return FF_ERR_NONE on success.
 **/
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
FF_Error_t FF_MkDir( FF_IOManager_t *pxIOManager, const FF_T_WCHAR *pcPath )
#else
FF_Error_t FF_MkDir( FF_IOManager_t *pxIOManager, const char *pcPath )
#endif
{
FF_DirEnt_t	xMyDirectory;

#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
	const FF_T_WCHAR *pcDirName;
#else
	const char	*pcDirName;
#endif
uint8_t	pucEntryBuffer[ FF_SIZEOF_DIRECTORY_ENTRY ];
uint32_t ulObjectCluster;
BaseType_t xIndex;
FF_Error_t xError = FF_ERR_NONE;

FF_FindParams_t xFindParams;

	memset ( &xFindParams, '\0', sizeof( xFindParams ) );
	/* Inform the functions that the entry will be created if not found */
	xFindParams.ulFlags |= FIND_FLAG_CREATE_FLAG;

	/* Open a do {} while ( pdFALSE ) loop */
	do
	{
		if( pxIOManager == NULL )
		{
			xError = ( FF_Error_t ) ( FF_ERR_NULL_POINTER | FF_MKDIR );
			break;
		}
#if( ffconfigREMOVABLE_MEDIA != 0 )
		if( ( pxIOManager->ucFlags & FF_IOMAN_DEVICE_IS_EXTRACTED ) != 0 )
		{
			xError = ( FF_Error_t ) ( FF_ERR_IOMAN_DRIVER_NOMEDIUM | FF_MKDIR );
			break;
		}
#endif /* ffconfigREMOVABLE_MEDIA */

		#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
		{
			xIndex = ( BaseType_t ) wcslen( pcPath );
		}
		#else
		{
			xIndex = ( BaseType_t ) strlen( pcPath );
		}
		#endif

		/* Find the last slash in the path. */
		while( xIndex != 0 )
		{
			if( ( pcPath[ xIndex ] == '\\' ) || ( pcPath[ xIndex ] == '/' ) )
			{
				break;
			}
			xIndex--;
		}

		pcDirName = pcPath + xIndex + 1;

		if( xIndex == 0 )
		{
			xIndex = 1;
		}

		if( pcDirName[ 0 ] == '\0' )
		{
			xError = ( FF_ERR_DIR_OBJECT_EXISTS | FF_MKDIR );
			break;
		}

		xFindParams.ulDirCluster = FF_FindDir( pxIOManager, pcPath, ( uint16_t ) xIndex, &xError );

		if( FF_isERR( xError ) )
		{
			break;
		}

		if( xFindParams.ulDirCluster == 0UL )
		{
			xError = ( FF_Error_t ) ( FF_ERR_DIR_INVALID_PATH | FF_MKDIR );
			break;
		}
		memset( &xMyDirectory, '\0', sizeof( xMyDirectory ) );

		/* Will set flags FIND_FLAG_FITS_SHORT and FIND_FLAG_SIZE_OK */
		FF_CreateShortName( &xFindParams, pcDirName );

		if( FF_FindEntryInDir( pxIOManager, &xFindParams, pcDirName, 0x00, &xMyDirectory, &xError ) )
		{
			if( FF_isERR( xError ) == pdFALSE )
			{
				xError = ( FF_Error_t ) ( FF_ERR_DIR_OBJECT_EXISTS | FF_MKDIR );
			}
			break;
		}

		if( ( FF_isERR( xError ) ) && ( FF_GETERROR( xError ) != FF_ERR_DIR_END_OF_DIR ) )
		{
			break;
		}

		#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
		{
			wcsncpy( xMyDirectory.pcFileName, pcDirName, ffconfigMAX_FILENAME );
		}
		#else
		{
			strncpy( xMyDirectory.pcFileName, pcDirName, ffconfigMAX_FILENAME );
		}
		#endif

		xMyDirectory.ulFileSize = 0;
		xMyDirectory.ucAttrib = FF_FAT_ATTR_DIR;
		xMyDirectory.ulObjectCluster = FF_CreateClusterChain( pxIOManager, &xError );

		/* Give all entries a proper time stamp, looks nicer than 1 Jan 1970 */
		#if( ffconfigTIME_SUPPORT != 0 )
		{
			FF_GetSystemTime( &xMyDirectory.xCreateTime );
			FF_GetSystemTime( &xMyDirectory.xModifiedTime );
		}
		#endif

		if( FF_isERR( xError ) )
		{
			break;
		}
		if( xMyDirectory.ulObjectCluster == 0UL )
		{
			/* Couldn't allocate any space for the dir! */
			xError = ( FF_Error_t ) ( FF_ERR_DIR_EXTEND_FAILED | FF_MKDIR );
			break;
		}

		xError = FF_ClearCluster( pxIOManager, xMyDirectory.ulObjectCluster );
		if( FF_isERR( xError ) == pdFALSE )
		{
			xError = FF_CreateDirent( pxIOManager, &xFindParams, &xMyDirectory );
		}

		if( FF_isERR( xError ) )
		{
			FF_LockFAT( pxIOManager );
			{
				FF_UnlinkClusterChain( pxIOManager, xMyDirectory.ulObjectCluster, 0 );
			}
			FF_UnlockFAT( pxIOManager );
			FF_FlushCache( pxIOManager );	/* Don't override error. */
			break;
		}

		/* Write 8.3 entry "." */
		pucEntryBuffer[ 0 ] = '.';
		/* folowed by 10 spaces: */
		memset( pucEntryBuffer + 1, ' ', 10 );
		/* Clear the rest of the structure. */
		memset( pucEntryBuffer + 11, 0, FF_SIZEOF_DIRECTORY_ENTRY - 11 );

		ulObjectCluster = xMyDirectory.ulObjectCluster;
		xError = FF_PutEntry( pxIOManager, ( uint16_t ) 0u, ulObjectCluster, &xMyDirectory, pucEntryBuffer );

		if( FF_isERR( xError ) == pdFALSE )
		{
			pucEntryBuffer[ 1 ] = '.';

			if( xFindParams.ulDirCluster == pxIOManager->xPartition.ulRootDirCluster )
			{
				xMyDirectory.ulObjectCluster = 0;
			}
			else
			{
				xMyDirectory.ulObjectCluster = xFindParams.ulDirCluster;
			}
			xError = FF_PutEntry( pxIOManager, 1u, ulObjectCluster, &xMyDirectory, pucEntryBuffer );

			xMyDirectory.ulObjectCluster = ulObjectCluster;
		}

		if( FF_isERR( xError ) )
		{
			FF_LockFAT( pxIOManager );
			{
				FF_UnlinkClusterChain( pxIOManager, xMyDirectory.ulObjectCluster, 0 );
			}
			FF_UnlockFAT( pxIOManager );
		}
		FF_FlushCache( pxIOManager );
	}
	while( pdFALSE );

	return xError;
}	/* FF_MkDir() */
/*-----------------------------------------------------------*/


FF_Error_t FF_RmLFNs( FF_IOManager_t *pxIOManager, uint16_t usDirEntry, FF_FetchContext_t *pxContext )
{
FF_Error_t xError = FF_ERR_NONE;
uint8_t	pucEntryBuffer[ FF_SIZEOF_DIRECTORY_ENTRY ];

	if( usDirEntry != 0 )
	{
		usDirEntry--;

		do
		{
			xError = FF_FetchEntryWithContext( pxIOManager, usDirEntry, pxContext, pucEntryBuffer );
			if( FF_isERR( xError ) )
			{
				break;
			}

			if( FF_getChar( pucEntryBuffer, ( uint16_t )( FF_FAT_DIRENT_ATTRIB ) ) == FF_FAT_ATTR_LFN )
			{
				FF_putChar( pucEntryBuffer, ( uint16_t ) 0, ( uint8_t ) FF_FAT_DELETED );
				xError = FF_PushEntryWithContext( pxIOManager, usDirEntry, pxContext, pucEntryBuffer );
				if( FF_isERR( xError ) )
				{
					break;
				}
			}

			if( usDirEntry == 0 )
			{
				break;
			}
			usDirEntry--;
		} while( FF_getChar( pucEntryBuffer, ( uint16_t )( FF_FAT_DIRENT_ATTRIB ) ) == FF_FAT_ATTR_LFN );
	}

	return xError;
}	/* FF_RmLFNs() */
/*-----------------------------------------------------------*/

#if( ffconfigHASH_CACHE != 0 )
	FF_Error_t FF_HashDir( FF_IOManager_t *pxIOManager, uint32_t ulDirCluster )
	{
		/* Find most suitable Hash Table to replace! */
	BaseType_t xIndex;
	FF_HashTable_t *pxHashCache = NULL;
	FF_FetchContext_t xFetchContext;
	const uint8_t *pucEntryBuffer = NULL;
	uint8_t ucAttrib;
	uint32_t ulHash;
	FF_Error_t xError;

		for( xIndex = 0; xIndex < ffconfigHASH_CACHE_DEPTH; xIndex++ )
		{
			if( pxIOManager->xHashCache[ xIndex ].ulNumHandles == 0 )
			{
				if( pxHashCache == NULL )
				{
					pxHashCache = &pxIOManager->xHashCache[ xIndex ];
				}
				else
				{
					if( ( pxIOManager->xHashCache[ xIndex ].ulMisses > pxHashCache->ulMisses ) )
					{
						pxHashCache = &pxIOManager->xHashCache[ xIndex ];
					}
				}
			}
		}

		if( pxHashCache != NULL )
		{
		#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
			FF_T_WCHAR	pcMyShortName[ 13 ];
		#else
			char pcMyShortName[ 13 ];
		#endif
			/* Clear the hash table! */
			memset( pxHashCache, '\0', sizeof( *pxHashCache ) );
			pxHashCache->ulDirCluster = ulDirCluster;
			pxHashCache->ulMisses = 0;

			/* Hash the directory! */

			xError = FF_InitEntryFetch( pxIOManager, ulDirCluster, &xFetchContext );

			if( FF_isERR( xError ) == pdFALSE )
			{
				for( xIndex = 0; xIndex < FF_MAX_ENTRIES_PER_DIRECTORY; xIndex++ )
				{
					if( ( pucEntryBuffer == NULL ) ||
						( pucEntryBuffer >= xFetchContext.pxBuffer->pucBuffer + ( FF_SIZEOF_SECTOR - FF_SIZEOF_DIRECTORY_ENTRY ) ) )
					{
						xError = FF_FetchEntryWithContext( pxIOManager, ( uint32_t ) xIndex, &xFetchContext, NULL );
						if( FF_isERR( xError ) )
						{
							break;
						}
						pucEntryBuffer = xFetchContext.pxBuffer->pucBuffer;
					}
					else
					{
						/* Advance the pointer 32 bytes to the next directory entry. */
						pucEntryBuffer += FF_SIZEOF_DIRECTORY_ENTRY;
					}
					if( FF_isDeleted( pucEntryBuffer ) == pdFALSE )
					{
						ucAttrib = FF_getChar( pucEntryBuffer, FF_FAT_DIRENT_ATTRIB );
						if( ( ( ucAttrib & FF_FAT_ATTR_LFN ) != FF_FAT_ATTR_LFN ) &&
							( ( ucAttrib & FF_FAT_ATTR_VOLID ) != FF_FAT_ATTR_VOLID ) )
						{
							memcpy ( pcMyShortName, pucEntryBuffer, 11 );
							FF_ProcessShortName( pcMyShortName );
							if( FF_isEndOfDir( pucEntryBuffer ) )
							{
								break;
							}

							/* Generate the Hash. */
							#if( ffconfigHASH_FUNCTION == CRC16 )
							{
								ulHash = FF_GetCRC16( ( uint8_t * ) pcMyShortName, strlen( pcMyShortName ) );
							}
							#else /* ffconfigHASH_FUNCTION == CRC8 */
							{
								ulHash = FF_GetCRC8( pcMyShortName, strlen( pcMyShortName ) );
							}
							#endif
							FF_SetHash( pxHashCache, ulHash );
						}
					}
				} /* for( xIndex = 0; xIndex < FF_MAX_ENTRIES_PER_DIRECTORY; xIndex++ ) */
				{
				FF_Error_t xTempError;
					xTempError = FF_CleanupEntryFetch( pxIOManager, &xFetchContext );
					if( FF_isERR( xError ) == pdFALSE )
					{
						xError = xTempError;
					}
				}
			}
		} /* if( pxHashCache != NULL ) */
		else
		{
			xError = -1;
		}

		return xError;
	}	/* FF_HashDir() */
#endif /* ffconfigHASH_CACHE != 0 */
/*-----------------------------------------------------------*/

#if( ffconfigHASH_CACHE != 0 )
	/* FF_UnHashDir() : invalidate the hash tables of a given directory.
	It is called when a file or sub-directory is removed or when the
	directory itself is removed. */
	void FF_UnHashDir( FF_IOManager_t *pxIOManager, uint32_t ulDirCluster )
	{
	FF_HashTable_t *pxHash = pxIOManager->xHashCache;
	FF_HashTable_t *pxLast = pxIOManager->xHashCache + ffconfigHASH_CACHE_DEPTH;

		for( ; pxHash < pxLast; pxHash++ )
		{
			if( pxHash->ulDirCluster == ulDirCluster )
			{
				pxHash->ulDirCluster = 0;
				break;
			}
		}
	}	/* FF_UnHashDir() */
#endif /* ffconfigHASH_CACHE */
/*-----------------------------------------------------------*/

#if( ffconfigHASH_CACHE != 0 )
	/**
	 *
	 *
	 **/
	void FF_SetHash( FF_HashTable_t *pxHash, uint32_t ulHash )
	{
	uint32_t tblIndex = ( ulHash / 32 ) % FF_HASH_TABLE_ENTRY_COUNT;
	uint32_t tblBit = ulHash % 32;

		pxHash->ulBitTable[ tblIndex ] |= ( 0x80000000ul >> tblBit );
	}	/* FF_SetHash() */
#endif /* ffconfigHASH_CACHE */
/*-----------------------------------------------------------*/

#if( ffconfigHASH_CACHE != 0 )
	void FF_ClearHash( FF_HashTable_t *pxHash, uint32_t ulHash )
	{
		if( pxHash != NULL )
		{
		uint32_t tblIndex = ( ulHash / 32 ) % FF_HASH_TABLE_ENTRY_COUNT;
		uint32_t tblBit = ulHash % 32;

			pxHash->ulBitTable[ tblIndex ] &= ~( 0x80000000ul >> tblBit );
		}
	}	/* FF_ClearHash() */
#endif /* ffconfigHASH_CACHE */
/*-----------------------------------------------------------*/

#if( ffconfigHASH_CACHE != 0 )
	BaseType_t FF_isHashSet( FF_HashTable_t *pxHash, uint32_t ulHash )
	{
	FF_Error_t xResult;

		xResult = pdFALSE;

		if( pxHash != NULL )
		{
		uint32_t tblIndex = ( ulHash / 32 ) % FF_HASH_TABLE_ENTRY_COUNT;
		uint32_t tblBit = ulHash % 32;

			if( pxHash->ulBitTable[ tblIndex ] & ( 0x80000000ul >> tblBit ) )
			{
				xResult = pdTRUE;
			}
		}

		return xResult;
	}	/* FF_isHashSet() */
#endif /* ffconfigHASH_CACHE */
/*-----------------------------------------------------------*/

#if( ffconfigHASH_CACHE != 0 )
	void FF_AddDirentHash( FF_IOManager_t *pxIOManager, uint32_t ulDirCluster, uint32_t ulHash )
	{
	FF_HashTable_t *pxHash = pxIOManager->xHashCache;
	FF_HashTable_t *pxLast = pxIOManager->xHashCache + ffconfigHASH_CACHE_DEPTH;

		for( ; pxHash < pxLast; pxHash++ )
		{
			if( pxHash->ulDirCluster == ulDirCluster )
			{
				FF_SetHash( pxHash, ulHash );
				break;
			}
		}
	}	/* FF_AddDirentHash() */
#endif /* ffconfigHASH_CACHE*/
/*-----------------------------------------------------------*/

#if( ffconfigHASH_CACHE != 0 )
	BaseType_t FF_CheckDirentHash( FF_IOManager_t *pxIOManager, uint32_t ulDirCluster, uint32_t ulHash )
	{
	FF_HashTable_t *pxHash = pxIOManager->xHashCache;
	FF_HashTable_t *pxLast = pxIOManager->xHashCache + ffconfigHASH_CACHE_DEPTH;
	BaseType_t xResult;

		for( ; ; )
		{
			if( pxHash->ulDirCluster == ulDirCluster )
			{
				xResult = FF_isHashSet( pxHash, ulHash );
				break;
			}
			pxHash++;
			if( pxHash >= pxLast )
			{
				xResult = -1;
				break;
			}
		}

		return xResult;
	}	/* FF_CheckDirentHash() */
#endif /* ffconfigHASH_CACHE */
/*-----------------------------------------------------------*/

#if( ffconfigHASH_CACHE != 0 )
	BaseType_t FF_DirHashed( FF_IOManager_t *pxIOManager, uint32_t ulDirCluster )
	{
	FF_HashTable_t *pxHash = pxIOManager->xHashCache;
	FF_HashTable_t *pxLast = pxIOManager->xHashCache + ffconfigHASH_CACHE_DEPTH;
	BaseType_t xResult;

		for( ; ; )
		{
			if( pxHash->ulDirCluster == ulDirCluster )
			{
				xResult = pdTRUE;
				break;
			}
			pxHash++;
			if( pxHash >= pxLast )
			{
				xResult = pdFALSE;
				break;
			}
		}

		return xResult;
	}	/* FF_DirHashed() */
#endif /* ffconfigHASH_CACHE */
/*-----------------------------------------------------------*/