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