/* | |
* FreeRTOS+FAT SL V1.0.1 (C) 2014 HCC Embedded | |
* | |
* The FreeRTOS+FAT SL license terms are different to the FreeRTOS license | |
* terms. | |
* | |
* FreeRTOS+FAT SL uses a dual license model that allows the software to be used | |
* under a standard GPL open source license, or a commercial license. The | |
* standard GPL license (unlike the modified GPL license under which FreeRTOS | |
* itself is distributed) requires that all software statically linked with | |
* FreeRTOS+FAT SL is also distributed under the same GPL V2 license terms. | |
* Details of both license options follow: | |
* | |
* - Open source licensing - | |
* FreeRTOS+FAT SL is a free download and may be used, modified, evaluated and | |
* distributed without charge provided the user adheres to version two of the | |
* GNU General Public License (GPL) and does not remove the copyright notice or | |
* this text. The GPL V2 text is available on the gnu.org web site, and on the | |
* following URL: http://www.FreeRTOS.org/gpl-2.0.txt. | |
* | |
* - Commercial licensing - | |
* Businesses and individuals who for commercial or other reasons cannot comply | |
* with the terms of the GPL V2 license must obtain a commercial license before | |
* incorporating FreeRTOS+FAT SL into proprietary software for distribution in | |
* any form. Commercial licenses can be purchased from | |
* http://shop.freertos.org/fat_sl and do not require any source files to be | |
* changed. | |
* | |
* FreeRTOS+FAT SL is distributed in the hope that it will be useful. You | |
* cannot use FreeRTOS+FAT SL unless you agree that you use the software 'as | |
* is'. FreeRTOS+FAT SL is provided WITHOUT ANY WARRANTY; without even the | |
* implied warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A | |
* PARTICULAR PURPOSE. Real Time Engineers Ltd. and HCC Embedded disclaims all | |
* conditions and terms, be they implied, expressed, or statutory. | |
* | |
* http://www.FreeRTOS.org | |
* http://www.FreeRTOS.org/FreeRTOS-Plus | |
* | |
*/ | |
#include "../../api/fat_sl.h" | |
#include "../../psp/include/psp_string.h" | |
#include "util.h" | |
#include "volume.h" | |
#include "drv.h" | |
#include "fat.h" | |
#include "dir.h" | |
#include "file.h" | |
#include "../../version/ver_fat_sl.h" | |
#if VER_FAT_SL_MAJOR != 5 || VER_FAT_SL_MINOR != 2 | |
#error Incompatible FAT_SL version number! | |
#endif | |
static unsigned char _f_stepnextsector ( void ); | |
/**************************************************************************** | |
* | |
* fn_filelength | |
* | |
* Get a file length | |
* | |
* INPUTS | |
* | |
* filename - file whose length is needed | |
* | |
* RETURNS | |
* | |
* length of the file | |
* | |
***************************************************************************/ | |
long fn_filelength ( const char * filename ) | |
{ | |
F_POS pos; | |
F_DIRENTRY * de; | |
F_NAME fsname; | |
if ( _f_setfsname( filename, &fsname ) ) | |
{ | |
return 0; /*invalid name*/ | |
} | |
if ( _f_checknamewc( fsname.filename, fsname.fileext ) ) | |
{ | |
return 0; /*invalid name*/ | |
} | |
if ( _f_getvolume() ) | |
{ | |
return 0; /*can't get the size*/ | |
} | |
if ( !_f_findpath( &fsname, &pos ) ) | |
{ | |
return 0; | |
} | |
if ( !_f_findfilewc( fsname.filename, fsname.fileext, &pos, &de, 0 ) ) | |
{ | |
return 0; | |
} | |
if ( de->attr & F_ATTR_DIR ) | |
{ | |
return 0; /*directory*/ | |
} | |
return (long)_f_getlong( &de->filesize ); | |
} /* fn_filelength */ | |
/**************************************************************************** | |
* | |
* _f_emptywritebuffer | |
* | |
* empty write buffer if it contains unwritten data | |
* | |
* RETURNS | |
* error code or zero if successful | |
* | |
***************************************************************************/ | |
static unsigned char _f_stepnextsector ( void ) | |
{ | |
unsigned char ret; | |
unsigned char b_alloc; | |
b_alloc = 0; | |
gl_volume.fatsector = (unsigned long)-1; | |
if ( gl_file.startcluster == 0 ) | |
{ | |
b_alloc = 1; | |
} | |
else | |
{ | |
++gl_file.pos.sector; | |
if ( gl_file.pos.sector >= gl_file.pos.sectorend ) | |
{ | |
unsigned long value; | |
ret = _f_getclustervalue( gl_file.pos.cluster, &value ); | |
if ( ret ) | |
{ | |
return ret; | |
} | |
if ( ( value >= 2 ) && ( value < F_CLUSTER_RESERVED ) ) /*we are in chain*/ | |
{ | |
_f_clustertopos( value, &gl_file.pos ); /*go to next cluster*/ | |
} | |
else | |
{ | |
b_alloc = 1; | |
} | |
} | |
} | |
if ( b_alloc != 0 ) | |
{ | |
unsigned long nextcluster; | |
ret = _f_alloccluster( &nextcluster ); | |
if ( ret ) | |
{ | |
return ret; | |
} | |
ret = _f_setclustervalue( nextcluster, F_CLUSTER_LAST ); | |
if ( ret ) | |
{ | |
return ret; | |
} | |
if ( gl_file.startcluster == 0 ) | |
{ | |
gl_file.startcluster = nextcluster; | |
} | |
else | |
{ | |
ret = _f_setclustervalue( gl_file.pos.cluster, nextcluster ); | |
if ( ret ) | |
{ | |
return ret; | |
} | |
} | |
_f_clustertopos( nextcluster, &gl_file.pos ); | |
return _f_writefatsector(); | |
} | |
return F_NO_ERROR; | |
} /* _f_stepnextsector */ | |
/**************************************************************************** | |
* | |
* _f_extend | |
* | |
* Extend file to a certain size | |
* | |
***************************************************************************/ | |
static unsigned char _f_extend ( long size ) | |
{ | |
unsigned long _size; | |
unsigned char rc; | |
size -= gl_file.filesize; | |
_size = (unsigned long)size; | |
if ( gl_file.startcluster == 0 ) | |
{ | |
if ( _f_stepnextsector() ) | |
{ | |
return F_ERR_WRITE; | |
} | |
} | |
else | |
{ | |
if ( ( gl_file.relpos > 0 ) && ( gl_file.relpos < F_SECTOR_SIZE ) ) | |
{ | |
rc = _f_getcurrsector(); | |
if ( rc ) | |
{ | |
return rc; | |
} | |
} | |
} | |
if ( gl_file.relpos + _size >= F_SECTOR_SIZE ) | |
{ | |
if ( gl_file.relpos < F_SECTOR_SIZE ) | |
{ | |
psp_memset( gl_sector + gl_file.relpos, 0, ( F_SECTOR_SIZE - gl_file.relpos ) ); | |
_size -= ( F_SECTOR_SIZE - gl_file.relpos ); | |
if ( _f_writeglsector( gl_file.pos.sector ) ) | |
{ | |
return F_ERR_WRITE; | |
} | |
} | |
if ( _f_stepnextsector() ) | |
{ | |
return F_ERR_WRITE; | |
} | |
psp_memset( gl_sector, 0, F_SECTOR_SIZE ); | |
while ( _size >= F_SECTOR_SIZE ) | |
{ | |
if ( _f_writeglsector( gl_file.pos.sector ) ) | |
{ | |
return F_ERR_WRITE; | |
} | |
if ( _f_stepnextsector() ) | |
{ | |
return F_ERR_WRITE; | |
} | |
psp_memset( gl_sector, 0, F_SECTOR_SIZE ); | |
_size -= F_SECTOR_SIZE; | |
} | |
} | |
else | |
{ | |
psp_memset( gl_sector + gl_file.relpos, 0, ( F_SECTOR_SIZE - gl_file.relpos ) ); | |
_size += gl_file.relpos; | |
} | |
gl_file.modified = 1; | |
gl_file.filesize += size; | |
gl_file.abspos = gl_file.filesize & ( ~( F_SECTOR_SIZE - 1 ) ); | |
gl_file.relpos = _size; | |
return F_NO_ERROR; | |
} /* _f_extend */ | |
/**************************************************************************** | |
* | |
* _f_fseek | |
* | |
* subfunction for f_seek it moves position into given offset and read | |
* the current sector | |
* | |
* INPUTS | |
* offset - position from start | |
* | |
* RETURNS | |
* | |
* error code or zero if successful | |
* | |
***************************************************************************/ | |
static unsigned char _f_fseek ( long offset ) | |
{ | |
unsigned long cluster; | |
unsigned long tmp; | |
unsigned char ret = F_NO_ERROR; | |
long remain; | |
if ( offset < 0 ) | |
{ | |
offset = 0; | |
} | |
if ( ( (unsigned long) offset <= gl_file.filesize ) | |
&& ( (unsigned long) offset >= gl_file.abspos ) | |
&& ( (unsigned long) offset < gl_file.abspos + F_SECTOR_SIZE ) ) | |
{ | |
gl_file.relpos = (unsigned short)( offset - gl_file.abspos ); | |
} | |
else | |
{ | |
if ( gl_file.modified ) | |
{ | |
ret = _f_writeglsector( (unsigned long)-1 ); | |
if ( ret ) | |
{ | |
gl_file.mode = F_FILE_CLOSE; /*cant accessed any more*/ | |
return ret; | |
} | |
} | |
if ( gl_file.startcluster ) | |
{ | |
gl_file.abspos = 0; | |
gl_file.relpos = 0; | |
gl_file.pos.cluster = gl_file.startcluster; | |
remain = gl_file.filesize; | |
tmp = gl_volume.bootrecord.sector_per_cluster; | |
tmp *= F_SECTOR_SIZE; /* set to cluster size */ | |
/*calc cluster*/ | |
gl_volume.fatsector = (unsigned long)-1; | |
while ( (unsigned long)offset >= tmp ) | |
{ | |
ret = _f_getclustervalue( gl_file.pos.cluster, &cluster ); | |
if ( ret ) | |
{ | |
gl_file.mode = F_FILE_CLOSE; | |
return ret; | |
} | |
if ( (long) tmp >= remain ) | |
{ | |
break; | |
} | |
remain -= tmp; | |
offset -= tmp; | |
gl_file.abspos += tmp; | |
if ( cluster >= F_CLUSTER_RESERVED ) | |
{ | |
break; | |
} | |
gl_file.pos.cluster = cluster; | |
} | |
_f_clustertopos( gl_file.pos.cluster, &gl_file.pos ); | |
if ( remain && offset ) | |
{ | |
while ( ( offset > (long) F_SECTOR_SIZE ) | |
&& ( remain > (long) F_SECTOR_SIZE ) ) | |
{ | |
gl_file.pos.sector++; | |
offset -= F_SECTOR_SIZE; | |
remain -= F_SECTOR_SIZE; | |
gl_file.abspos += F_SECTOR_SIZE; | |
} | |
} | |
if ( remain < offset ) | |
{ | |
gl_file.relpos = (unsigned short)remain; | |
ret = _f_extend( gl_file.filesize + offset - remain ); | |
} | |
else | |
{ | |
gl_file.relpos = (unsigned short)offset; | |
} | |
} | |
else | |
{ | |
ret = _f_extend( offset ); | |
} | |
} | |
return ret; | |
} /* _f_fseek */ | |
/**************************************************************************** | |
* | |
* fn_open | |
* | |
* open a file for reading/writing/appending | |
* | |
* INPUTS | |
* | |
* filename - which file need to be opened | |
* mode - string how to open ("r"-read, "w"-write, "w+"-overwrite, "a"-append | |
* | |
* RETURNS | |
* | |
* F_FILE pointer if successfully | |
* 0 - if any error | |
* | |
***************************************************************************/ | |
F_FILE * fn_open ( const char * filename, const char * mode ) | |
{ | |
F_DIRENTRY * de; | |
F_NAME fsname; | |
unsigned short date; | |
unsigned short time; | |
unsigned char m_mode = F_FILE_CLOSE; | |
if ( mode[1] == 0 ) | |
{ | |
if ( mode[0] == 'r' ) | |
{ | |
m_mode = F_FILE_RD; | |
} | |
if ( mode[0] == 'w' ) | |
{ | |
m_mode = F_FILE_WR; | |
} | |
if ( mode[0] == 'a' ) | |
{ | |
m_mode = F_FILE_A; | |
} | |
} | |
if ( ( mode[1] == '+' ) && ( mode[2] == 0 ) ) | |
{ | |
if ( mode[0] == 'r' ) | |
{ | |
m_mode = F_FILE_RDP; | |
} | |
if ( mode[0] == 'w' ) | |
{ | |
m_mode = F_FILE_WRP; | |
} | |
if ( mode[0] == 'a' ) | |
{ | |
m_mode = F_FILE_AP; | |
} | |
} | |
if ( m_mode == F_FILE_CLOSE ) | |
{ | |
return 0; /*invalid mode*/ | |
} | |
if ( _f_setfsname( filename, &fsname ) ) | |
{ | |
return 0; /*invalid name*/ | |
} | |
if ( _f_checknamewc( fsname.filename, fsname.fileext ) ) | |
{ | |
return 0; /*invalid name*/ | |
} | |
if ( fsname.filename[0] == '.' ) | |
{ | |
return 0; | |
} | |
if ( _f_getvolume() ) | |
{ | |
return 0; /*cant open any*/ | |
} | |
if ( gl_file.mode != F_FILE_CLOSE ) | |
{ | |
return 0; | |
} | |
psp_memset( &gl_file, 0, sizeof( F_FILE ) ); | |
if ( !_f_findpath( &fsname, &gl_file.dirpos ) ) | |
{ | |
return 0; | |
} | |
switch ( m_mode ) | |
{ | |
case F_FILE_RDP: /*r*/ | |
case F_FILE_RD: /*r*/ | |
if ( !_f_findfilewc( fsname.filename, fsname.fileext, &gl_file.dirpos, &de, 0 ) ) | |
{ | |
return 0; | |
} | |
if ( de->attr & F_ATTR_DIR ) | |
{ | |
return 0; /*directory*/ | |
} | |
gl_file.startcluster = _f_getdecluster( de ); | |
if ( gl_file.startcluster ) | |
{ | |
_f_clustertopos( gl_file.startcluster, &gl_file.pos ); | |
gl_file.filesize = _f_getlong( &de->filesize ); | |
gl_file.abspos = (unsigned long) (-1 * (long) F_SECTOR_SIZE); | |
if ( _f_fseek( 0 ) ) | |
{ | |
return 0; | |
} | |
} | |
#if F_FILE_CHANGED_EVENT | |
if ( m_mode == F_FILE_RDP ) | |
{ | |
_f_createfullname( gl_file.filename, sizeof( gl_file.filename ), fsname.path, fsname.filename, fsname.fileext ); | |
} | |
#endif | |
break; | |
case F_FILE_AP: | |
case F_FILE_A: /*a*/ | |
psp_memcpy( &( gl_file.pos ), &( gl_file.dirpos ), sizeof( F_POS ) ); | |
if ( _f_findfilewc( fsname.filename, fsname.fileext, &gl_file.dirpos, &de, 0 ) ) | |
{ | |
if ( de->attr & ( F_ATTR_DIR | F_ATTR_READONLY ) ) | |
{ | |
return 0; | |
} | |
gl_file.startcluster = _f_getdecluster( de ); | |
gl_file.filesize = _f_getlong( &de->filesize ); | |
if ( gl_file.startcluster ) | |
{ | |
_f_clustertopos( gl_file.startcluster, &gl_file.pos ); | |
gl_file.abspos = (unsigned long) (-1 * (long) F_SECTOR_SIZE); /*forcing seek to read 1st sector! abspos=0;*/ | |
if ( _f_fseek( (long)gl_file.filesize ) ) | |
{ | |
gl_file.mode = F_FILE_CLOSE; | |
return 0; | |
} | |
} | |
} | |
else | |
{ | |
psp_memcpy( &( gl_file.dirpos ), &( gl_file.pos ), sizeof( F_POS ) ); | |
_f_clustertopos( gl_file.dirpos.cluster, &gl_file.pos ); | |
if ( _f_addentry( &fsname, &gl_file.dirpos, &de ) ) | |
{ | |
return 0; /*couldnt be added*/ | |
} | |
de->attr |= F_ATTR_ARC; /*set as archiv*/ | |
if ( _f_writeglsector( (unsigned long)-1 ) ) | |
{ | |
return 0; | |
} | |
} | |
#if F_FILE_CHANGED_EVENT | |
_f_createfullname( gl_file.filename, sizeof( gl_file.filename ), fsname.path, fsname.filename, fsname.fileext ); | |
#endif | |
break; | |
case F_FILE_WR: /*w*/ | |
case F_FILE_WRP: /*w+*/ | |
_f_clustertopos( gl_file.dirpos.cluster, &gl_file.pos ); | |
if ( _f_findfilewc( fsname.filename, fsname.fileext, &gl_file.pos, &de, 0 ) ) | |
{ | |
unsigned long cluster = _f_getdecluster( de ); /*exist*/ | |
if ( de->attr & ( F_ATTR_DIR | F_ATTR_READONLY ) ) | |
{ | |
return 0; | |
} | |
psp_memcpy( &( gl_file.dirpos ), &( gl_file.pos ), sizeof( F_POS ) ); | |
_f_setlong( de->filesize, 0 ); /*reset size;*/ | |
de->attr |= F_ATTR_ARC; /*set as archiv*/ | |
_f_setword( de->clusterlo, 0 ); /*no points anywhere*/ | |
_f_setword( de->clusterhi, 0 ); | |
if ( gl_volume.mediatype == F_FAT32_MEDIA ) | |
{ | |
f_igettimedate( &time, &date ); | |
_f_setword( &de->crtdate, date ); /*if there is realtime clock then creation date could be set from*/ | |
_f_setword( &de->crttime, time ); /*if there is realtime clock then creation time could be set from*/ | |
_f_setword( &de->lastaccessdate, date ); /*if there is realtime clock then creation date could be set from*/ | |
} | |
if ( _f_writeglsector( (unsigned long)-1 ) ) | |
{ | |
return 0; | |
} | |
if ( _f_removechain( cluster ) ) | |
{ | |
return 0; /*remove */ | |
} | |
} | |
else | |
{ | |
if ( _f_addentry( &fsname, &gl_file.dirpos, &de ) ) | |
{ | |
return 0; /*couldnt be added*/ | |
} | |
psp_memset( &gl_file, 0, 21 ); | |
de->attr |= F_ATTR_ARC; /*set as archiv*/ | |
if ( _f_writeglsector( (unsigned long)-1 ) ) | |
{ | |
return 0; | |
} | |
} | |
#if F_FILE_CHANGED_EVENT | |
_f_createfullname( gl_file.filename, sizeof( gl_file.filename ), fsname.path, fsname.filename, fsname.fileext ); | |
#endif | |
break; | |
default: | |
return 0; /*invalid mode*/ | |
} /* switch */ | |
gl_file.mode = m_mode; /* lock it */ | |
return (F_FILE *)1; | |
} /* fn_open */ | |
/**************************************************************************** | |
* _f_updatefileentry | |
* Updated a file directory entry or removes the entry | |
* and the fat chain belonging to it. | |
***************************************************************************/ | |
static unsigned char _f_updatefileentry ( int remove ) | |
{ | |
F_DIRENTRY * de; | |
unsigned short date; | |
unsigned short time; | |
de = (F_DIRENTRY *)( gl_sector + sizeof( F_DIRENTRY ) * gl_file.dirpos.pos ); | |
if ( _f_readglsector( gl_file.dirpos.sector ) || remove ) | |
{ | |
_f_setdecluster( de, 0 ); | |
_f_setlong( &de->filesize, 0 ); | |
(void)_f_writeglsector( (unsigned long)-1 ); | |
(void)_f_removechain( gl_file.startcluster ); | |
return F_ERR_WRITE; | |
} | |
_f_setdecluster( de, gl_file.startcluster ); | |
_f_setlong( &de->filesize, gl_file.filesize ); | |
f_igettimedate( &time, &date ); | |
_f_setword( &de->cdate, date ); /*if there is realtime clock then creation date could be set from*/ | |
_f_setword( &de->ctime, time ); /*if there is realtime clock then creation time could be set from*/ | |
if ( gl_volume.mediatype == F_FAT32_MEDIA ) | |
{ | |
_f_setword( &de->lastaccessdate, date ); /*if there is realtime clock then creation date could be set from*/ | |
} | |
return _f_writeglsector( (unsigned long)-1 ); | |
} /* _f_updatefileentry */ | |
/**************************************************************************** | |
* | |
* fn_close | |
* | |
* close a previously opened file | |
* | |
* INPUTS | |
* | |
* filehandle - which file needs to be closed | |
* | |
* RETURNS | |
* | |
* error code or zero if successful | |
* | |
***************************************************************************/ | |
unsigned char fn_close ( F_FILE * f ) | |
{ | |
unsigned char ret; | |
#if F_FILE_CHANGED_EVENT | |
unsigned char mode; | |
#endif | |
if ( !f ) | |
{ | |
return F_ERR_NOTOPEN; | |
} | |
ret = _f_getvolume(); | |
if ( ret ) | |
{ | |
return ret; | |
} | |
if ( gl_file.mode == F_FILE_CLOSE ) | |
{ | |
return F_ERR_NOTOPEN; | |
} | |
else if ( gl_file.mode == F_FILE_RD ) | |
{ | |
gl_file.mode = F_FILE_CLOSE; | |
return F_NO_ERROR; | |
} | |
else | |
{ | |
#if F_FILE_CHANGED_EVENT | |
mode = f->mode; | |
#endif | |
gl_file.mode = F_FILE_CLOSE; | |
if ( gl_file.modified ) | |
{ | |
if ( _f_writeglsector( (unsigned long)-1 ) ) | |
{ | |
(void)_f_updatefileentry( 1 ); | |
return F_ERR_WRITE; | |
} | |
} | |
ret = _f_updatefileentry( 0 ); | |
#if F_FILE_CHANGED_EVENT | |
if ( f_filechangedevent && !ret ) | |
{ | |
ST_FILE_CHANGED fc; | |
if ( ( mode == F_FILE_WR ) || ( mode == F_FILE_WRP ) ) | |
{ | |
fc.action = FACTION_ADDED; | |
fc.flags = FFLAGS_FILE_NAME; | |
} | |
else if ( ( mode == F_FILE_A ) || ( mode == F_FILE_RDP ) ) | |
{ | |
fc.action = FACTION_MODIFIED; | |
fc.flags = FFLAGS_FILE_NAME | FFLAGS_SIZE; | |
} | |
strcpy( fc.filename, f->filename ); | |
if ( f->filename[0] ) | |
{ | |
f_filechangedevent( &fc ); | |
} | |
f->filename[0] = '\0'; | |
} | |
#endif /* if F_FILE_CHANGED_EVENT */ | |
return ret; | |
} | |
} /* fn_close */ | |
/**************************************************************************** | |
* | |
* fn_flush | |
* | |
* flush a previously opened file | |
* | |
* INPUTS | |
* | |
* filehandle - which file needs to be closed | |
* | |
* RETURNS | |
* | |
* error code or zero if successful | |
* | |
***************************************************************************/ | |
unsigned char fn_flush ( F_FILE * f ) | |
{ | |
unsigned char ret; | |
if ( !f ) | |
{ | |
return F_ERR_NOTOPEN; | |
} | |
ret = _f_getvolume(); | |
if ( ret ) | |
{ | |
return ret; | |
} | |
if ( gl_file.mode == F_FILE_CLOSE ) | |
{ | |
return F_ERR_NOTOPEN; | |
} | |
else if ( gl_file.mode != F_FILE_RD ) | |
{ | |
if ( gl_file.modified ) | |
{ | |
if ( _f_writeglsector( (unsigned long)-1 ) ) | |
{ | |
(void)_f_updatefileentry( 1 ); | |
return F_ERR_WRITE; | |
} | |
} | |
return _f_updatefileentry( 0 ); | |
} | |
return F_NO_ERROR; | |
} /* fn_flush */ | |
/**************************************************************************** | |
* | |
* fn_read | |
* | |
* read data from file | |
* | |
* INPUTS | |
* | |
* buf - where the store data | |
* size - size of items to be read | |
* _size_t - number of items need to be read | |
* filehandle - file where to read from | |
* | |
* RETURNS | |
* | |
* with the number of read bytes | |
* | |
***************************************************************************/ | |
long fn_read ( void * buf, long size, long _size_st, F_FILE * f ) | |
{ | |
char * buffer = (char *)buf; | |
long retsize; | |
if ( !f ) | |
{ | |
return 0; | |
} | |
if ( ( gl_file.mode & ( F_FILE_RD | F_FILE_RDP | F_FILE_WRP | F_FILE_AP ) ) == 0 ) | |
{ | |
return 0; | |
} | |
retsize = size; | |
size *= _size_st; | |
_size_st = retsize; | |
retsize = 0; | |
if ( _f_getvolume() ) | |
{ | |
return 0; /*cant read any*/ | |
} | |
if ( size + gl_file.relpos + gl_file.abspos >= gl_file.filesize ) /*read len longer than the file*/ | |
{ | |
size = (long)( ( gl_file.filesize ) - ( gl_file.relpos ) - ( gl_file.abspos ) ); /*calculate new size*/ | |
} | |
if ( size <= 0 ) | |
{ | |
return 0; | |
} | |
if ( _f_getcurrsector() ) | |
{ | |
gl_file.mode = F_FILE_CLOSE; /*no more read allowed*/ | |
return 0; | |
} | |
for( ; ; ) | |
{ | |
unsigned long rdsize = (unsigned long)size; | |
if ( gl_file.relpos == F_SECTOR_SIZE ) | |
{ | |
unsigned char ret; | |
gl_file.abspos += gl_file.relpos; | |
gl_file.relpos = 0; | |
if ( gl_file.modified ) | |
{ | |
ret = _f_writeglsector( (unsigned long)-1 ); /*empty write buffer */ | |
if ( ret ) | |
{ | |
gl_file.mode = F_FILE_CLOSE; /*no more read allowed*/ | |
return retsize; | |
} | |
} | |
gl_file.pos.sector++; /*goto next*/ | |
ret = _f_getcurrsector(); | |
if ( ( ret == F_ERR_EOF ) && ( !size ) ) | |
{ | |
return retsize; | |
} | |
if ( ret ) | |
{ | |
gl_file.mode = F_FILE_CLOSE; /*no more read allowed*/ | |
return retsize; | |
} | |
} | |
if ( !size ) | |
{ | |
break; | |
} | |
if ( rdsize >= F_SECTOR_SIZE - gl_file.relpos ) | |
{ | |
rdsize = (unsigned long)( F_SECTOR_SIZE - gl_file.relpos ); | |
} | |
psp_memcpy( buffer, gl_sector + gl_file.relpos, rdsize ); /*always less than 512*/ | |
buffer += rdsize; | |
gl_file.relpos += rdsize; | |
size -= rdsize; | |
retsize += rdsize; | |
} | |
return retsize / _size_st; | |
} /* fn_read */ | |
/**************************************************************************** | |
* | |
* fn_write | |
* | |
* write data into file | |
* | |
* INPUTS | |
* | |
* buf - where the store data | |
* size - size of items to be read | |
* size_t - number of items need to be read | |
* filehandle - file where to read from | |
* | |
* RETURNS | |
* | |
* with the number of read bytes | |
* | |
***************************************************************************/ | |
long fn_write ( const void * buf, long size, long _size_st, F_FILE * f ) | |
{ | |
char * buffer = (char *)buf; | |
long retsize; | |
long ret = 0; | |
if ( !f ) | |
{ | |
return 0; | |
} | |
if ( ( gl_file.mode & ( F_FILE_WR | F_FILE_A | F_FILE_RDP | F_FILE_WRP | F_FILE_AP ) ) == 0 ) | |
{ | |
return 0; | |
} | |
retsize = size; | |
size *= _size_st; | |
_size_st = retsize; | |
retsize = 0; | |
if ( size == 0 ) | |
{ | |
return 0; | |
} | |
if ( _f_getvolume() ) | |
{ | |
return 0; /*can't write*/ | |
} | |
if ( ( gl_file.mode ) & ( F_FILE_A | F_FILE_AP ) ) | |
{ | |
if ( _f_fseek( (long)gl_file.filesize ) ) | |
{ | |
gl_file.mode = F_FILE_CLOSE; | |
return 0; | |
} | |
} | |
if ( gl_file.startcluster == 0 ) | |
{ | |
if ( _f_stepnextsector() ) | |
{ | |
gl_file.mode = F_FILE_CLOSE; | |
return 0; | |
} | |
} | |
else | |
{ | |
if ( _f_getcurrsector() ) | |
{ | |
gl_file.mode = F_FILE_CLOSE; | |
return 0; | |
} | |
} | |
for( ; ; ) | |
{ | |
unsigned long wrsize = (unsigned long)size; | |
if ( gl_file.relpos == F_SECTOR_SIZE ) | |
{ /*now full*/ | |
if ( gl_file.modified ) | |
{ | |
if ( _f_writeglsector( gl_file.pos.sector ) ) | |
{ | |
gl_file.mode = F_FILE_CLOSE; | |
if ( _f_updatefileentry( 0 ) == 0 ) | |
{ | |
return retsize; | |
} | |
else | |
{ | |
return 0; | |
} | |
} | |
gl_file.modified = 0; | |
} | |
if ( _f_stepnextsector() ) | |
{ | |
gl_file.mode = F_FILE_CLOSE; | |
if ( _f_updatefileentry( 0 ) == 0 ) | |
{ | |
return retsize; | |
} | |
else | |
{ | |
return 0; | |
} | |
} | |
gl_file.abspos += gl_file.relpos; | |
gl_file.relpos = 0; | |
if ( wrsize && ( wrsize < F_SECTOR_SIZE ) ) | |
{ | |
ret = _f_getcurrsector(); | |
if ( ret ) | |
{ | |
if ( ret != F_ERR_EOF ) | |
{ | |
gl_file.mode = F_FILE_CLOSE; /*no more read allowed*/ | |
return retsize; | |
} | |
} | |
} | |
} | |
if ( !size ) | |
{ | |
break; | |
} | |
if ( wrsize >= F_SECTOR_SIZE - gl_file.relpos ) | |
{ | |
wrsize = (unsigned long)( F_SECTOR_SIZE - gl_file.relpos ); | |
} | |
psp_memcpy( gl_sector + gl_file.relpos, buffer, wrsize ); | |
gl_file.modified = 1; /*sector is modified*/ | |
buffer += wrsize; | |
gl_file.relpos += wrsize; | |
size -= wrsize; | |
retsize += wrsize; | |
if ( gl_file.filesize < gl_file.abspos + gl_file.relpos ) | |
{ | |
gl_file.filesize = gl_file.abspos + gl_file.relpos; | |
} | |
} | |
return retsize / _size_st; | |
} /* fn_write */ | |
/**************************************************************************** | |
* | |
* fn_seek | |
* | |
* moves position into given offset in given file | |
* | |
* INPUTS | |
* | |
* filehandle - F_FILE structure which file position needed to be modified | |
* offset - relative position | |
* whence - where to calculate position (F_SEEK_SET,F_SEEK_CUR,F_SEEK_END) | |
* | |
* RETURNS | |
* | |
* 0 - if successfully | |
* other - if any error | |
* | |
***************************************************************************/ | |
unsigned char fn_seek ( F_FILE * f, long offset, unsigned char whence ) | |
{ | |
unsigned char ret; | |
if ( !f ) | |
{ | |
return F_ERR_NOTOPEN; | |
} | |
if ( ( gl_file.mode & ( F_FILE_RD | F_FILE_WR | F_FILE_A | F_FILE_RDP | F_FILE_WRP | F_FILE_AP ) ) == 0 ) | |
{ | |
return F_ERR_NOTOPEN; | |
} | |
ret = _f_getvolume(); | |
if ( ret ) | |
{ | |
return ret; | |
} | |
if ( whence == F_SEEK_CUR ) | |
{ | |
return _f_fseek( (long)( gl_file.abspos + gl_file.relpos + offset ) ); | |
} | |
else if ( whence == F_SEEK_END ) | |
{ | |
return _f_fseek( (long)( gl_file.filesize + offset ) ); | |
} | |
else if ( whence == F_SEEK_SET ) | |
{ | |
return _f_fseek( offset ); | |
} | |
return F_ERR_NOTUSEABLE; | |
} /* fn_seek */ | |
/**************************************************************************** | |
* | |
* fn_tell | |
* | |
* Tells the current position of opened file | |
* | |
* INPUTS | |
* | |
* filehandle - which file needs the position | |
* | |
* RETURNS | |
* | |
* position in the file from start | |
* | |
***************************************************************************/ | |
long fn_tell ( F_FILE * f ) | |
{ | |
if ( !f ) | |
{ | |
return 0; | |
} | |
if ( ( gl_file.mode & ( F_FILE_RD | F_FILE_WR | F_FILE_A | F_FILE_RDP | F_FILE_WRP | F_FILE_AP ) ) == 0 ) | |
{ | |
return 0; | |
} | |
return (long)( gl_file.abspos + gl_file.relpos ); | |
} | |
/**************************************************************************** | |
* | |
* fn_eof | |
* | |
* Tells if the current position is end of file or not | |
* | |
* INPUTS | |
* | |
* filehandle - which file needs the checking | |
* | |
* RETURNS | |
* | |
* 0 - if not EOF | |
* other - if EOF or invalid file handle | |
* | |
***************************************************************************/ | |
unsigned char fn_eof ( F_FILE * f ) | |
{ | |
if ( !f ) | |
{ | |
return F_ERR_NOTOPEN; /*if error*/ | |
} | |
if ( gl_file.abspos + gl_file.relpos < gl_file.filesize ) | |
{ | |
return 0; | |
} | |
return F_ERR_EOF; /*EOF*/ | |
} | |
/**************************************************************************** | |
* | |
* fn_rewind | |
* | |
* set the fileposition in the opened file to the begining | |
* | |
* INPUTS | |
* | |
* filehandle - which file needs to be rewinded | |
* | |
* RETURNS | |
* | |
* error code or zero if successful | |
* | |
***************************************************************************/ | |
unsigned char fn_rewind ( F_FILE * filehandle ) | |
{ | |
return fn_seek( filehandle, 0L, F_SEEK_SET ); | |
} | |
/**************************************************************************** | |
* | |
* fn_putc | |
* | |
* write a character into file | |
* | |
* INPUTS | |
* | |
* ch - what to write into file | |
* filehandle - file where to write | |
* | |
* RETURNS | |
* | |
* with the number of written bytes (1-success, 0-not successfully) | |
* | |
***************************************************************************/ | |
int fn_putc ( int ch, F_FILE * filehandle ) | |
{ | |
unsigned char tmpch = (unsigned char)ch; | |
if ( fn_write( &tmpch, 1, 1, filehandle ) ) | |
{ | |
return ch; | |
} | |
else | |
{ | |
return -1; | |
} | |
} | |
/**************************************************************************** | |
* | |
* fn_getc | |
* | |
* get a character from file | |
* | |
* INPUTS | |
* | |
* filehandle - file where to read from | |
* | |
* RETURNS | |
* | |
* with the read character or -1 if read was not successfully | |
* | |
***************************************************************************/ | |
int fn_getc ( F_FILE * filehandle ) | |
{ | |
unsigned char ch; | |
if ( !fn_read( &ch, 1, 1, filehandle ) ) | |
{ | |
return -1; | |
} | |
return (int)ch; | |
} | |
/**************************************************************************** | |
* | |
* fn_delete | |
* | |
* delete a file | |
* | |
* INPUTS | |
* | |
* filename - file which wanted to be deleted (with or without path) | |
* | |
* RETURNS | |
* | |
* error code or zero if successful | |
* | |
***************************************************************************/ | |
unsigned char fn_delete ( const char * filename ) | |
{ | |
F_POS pos; | |
F_DIRENTRY * de; | |
F_NAME fsname; | |
unsigned char ret; | |
if ( _f_setfsname( filename, &fsname ) ) | |
{ | |
return F_ERR_INVALIDNAME; /*invalid name*/ | |
} | |
if ( _f_checknamewc( fsname.filename, fsname.fileext ) ) | |
{ | |
return F_ERR_INVALIDNAME; /*invalid name*/ | |
} | |
if ( fsname.filename[0] == '.' ) | |
{ | |
return F_ERR_NOTFOUND; | |
} | |
ret = _f_getvolume(); | |
if ( ret ) | |
{ | |
return ret; | |
} | |
if ( !( _f_findpath( &fsname, &pos ) ) ) | |
{ | |
return F_ERR_INVALIDDIR; | |
} | |
if ( !_f_findfilewc( fsname.filename, fsname.fileext, &pos, &de, 0 ) ) | |
{ | |
return F_ERR_NOTFOUND; | |
} | |
if ( de->attr & F_ATTR_DIR ) | |
{ | |
return F_ERR_INVALIDDIR; /*directory*/ | |
} | |
if ( de->attr & F_ATTR_READONLY ) | |
{ | |
return F_ERR_ACCESSDENIED; /*readonly*/ | |
} | |
if ( ( gl_file.mode != F_FILE_CLOSE ) && ( gl_file.dirpos.sector == pos.sector ) && ( gl_file.dirpos.pos == pos.pos ) ) | |
{ | |
return F_ERR_LOCKED; | |
} | |
de->name[0] = (unsigned char)0xe5; /*removes it*/ | |
ret = _f_writeglsector( (unsigned long)-1 ); | |
if ( ret ) | |
{ | |
return ret; | |
} | |
ret = _f_removechain( _f_getdecluster( de ) ); | |
#if F_FILE_CHANGED_EVENT | |
if ( f_filechangedevent && !ret ) | |
{ | |
ST_FILE_CHANGED fc; | |
fc.action = FACTION_REMOVED; | |
fc.flags = FFLAGS_FILE_NAME; | |
if ( !_f_createfullname( fc.filename, sizeof( fc.filename ), fsname.path, fsname.filename, fsname.fileext ) ) | |
{ | |
f_filechangedevent( &fc ); | |
} | |
} | |
#endif | |
return ret; | |
} /* fn_delete */ | |
/**************************************************************************** | |
* | |
* _f_seteof | |
* | |
* Set end of file | |
* | |
* INPUT: f - file pointer | |
* filesize - required new size | |
* RETURN: F_NO_ERROR - on success | |
* other if error | |
* | |
***************************************************************************/ | |
unsigned char _f_seteof ( F_FILE * f, long filesize ) | |
{ | |
unsigned char rc = F_NO_ERROR; | |
if ( !f ) | |
{ | |
return F_ERR_NOTOPEN; /*if error*/ | |
} | |
if ( ( unsigned long) filesize < gl_file.filesize ) | |
{ | |
rc = _f_fseek( filesize ); | |
if ( rc == F_NO_ERROR ) | |
{ | |
unsigned long cluster; | |
rc = _f_getclustervalue( gl_file.pos.cluster, &cluster ); | |
if ( rc == F_NO_ERROR ) | |
{ | |
if ( cluster != F_CLUSTER_LAST ) | |
{ | |
rc = _f_removechain( cluster ); | |
if ( rc ) | |
{ | |
return rc; | |
} | |
rc = _f_setclustervalue( gl_file.pos.cluster, F_CLUSTER_LAST ); | |
if ( rc ) | |
{ | |
return rc; | |
} | |
rc = _f_writefatsector(); | |
if ( rc ) | |
{ | |
return rc; | |
} | |
} | |
gl_file.filesize = (unsigned long)filesize; | |
} | |
} | |
} | |
else if ( (unsigned long) filesize > gl_file.filesize ) | |
{ | |
rc = _f_fseek( filesize ); | |
} | |
return rc; | |
} /* _f_seteof */ | |
/**************************************************************************** | |
* | |
* fn_seteof | |
* | |
* Set end of file | |
* | |
* INPUT: f - file pointer | |
* filesize - required new size | |
* RETURN: F_NO_ERROR - on success | |
* other if error | |
* | |
***************************************************************************/ | |
unsigned char fn_seteof ( F_FILE * f ) | |
{ | |
unsigned char rc = F_NO_ERROR; | |
rc = _f_seteof( f, ( gl_file.abspos + gl_file.relpos ) ); | |
return rc; | |
} /* fn_seteof */ | |
/**************************************************************************** | |
* | |
* fn_truncate | |
* | |
* Open a file and set end of file | |
* | |
* INPUT: filename - name of the file | |
* filesize - required new size | |
* RETURN: NULL on error, otherwise file pointer | |
* | |
***************************************************************************/ | |
F_FILE * fn_truncate ( const char * filename, long filesize ) | |
{ | |
F_FILE * f = fn_open( filename, "r+" ); | |
unsigned char rc; | |
if ( f != NULL ) | |
{ | |
rc = _f_fseek( (long)gl_file.filesize ); | |
if ( rc == F_NO_ERROR ) | |
{ | |
rc = _f_seteof( f, filesize ); | |
} | |
if ( rc ) | |
{ | |
fn_close( f ); | |
f = NULL; | |
} | |
} | |
return f; | |
} /* fn_truncate */ | |