usbloadergx/source/libfat/fatdir.c

684 lines
20 KiB
C
Raw Normal View History

/*
fatdir.c
Functions used by the newlib disc stubs to interface with
this library
Copyright (c) 2006 Michael "Chishm" Chisholm
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/dir.h>
#include "fatdir.h"
#include "fat_cache.h"
#include "file_allocation_table.h"
#include "partition.h"
#include "directory.h"
#include "bit_ops.h"
#include "filetime.h"
#include "lock.h"
int _FAT_stat_r ( struct _reent *r, const char *path, struct stat *st )
{
PARTITION* partition = NULL;
DIR_ENTRY dirEntry;
// Get the partition this file is on
partition = _FAT_partition_getPartitionFromPath ( path );
if ( partition == NULL )
{
r->_errno = ENODEV;
return -1;
}
// Move the path pointer to the start of the actual path
if ( strchr ( path, ':' ) != NULL )
{
path = strchr ( path, ':' ) + 1;
}
if ( strchr ( path, ':' ) != NULL )
{
r->_errno = EINVAL;
return -1;
}
_FAT_lock( &partition->lock );
// Search for the file on the disc
if ( !_FAT_directory_entryFromPath ( partition, &dirEntry, path, NULL ) )
{
_FAT_unlock( &partition->lock );
r->_errno = ENOENT;
return -1;
}
// Fill in the stat struct
_FAT_directory_entryStat ( partition, &dirEntry, st );
_FAT_unlock( &partition->lock );
return 0;
}
int _FAT_link_r ( struct _reent *r, const char *existing, const char *newLink )
{
r->_errno = ENOTSUP;
return -1;
}
int _FAT_unlink_r ( struct _reent *r, const char *path )
{
PARTITION* partition = NULL;
DIR_ENTRY dirEntry;
DIR_ENTRY dirContents;
uint32_t cluster;
bool nextEntry;
bool errorOccured = false;
// Get the partition this directory is on
partition = _FAT_partition_getPartitionFromPath ( path );
if ( partition == NULL )
{
r->_errno = ENODEV;
return -1;
}
// Make sure we aren't trying to write to a read-only disc
if ( partition->readOnly )
{
r->_errno = EROFS;
return -1;
}
// Move the path pointer to the start of the actual path
if ( strchr ( path, ':' ) != NULL )
{
path = strchr ( path, ':' ) + 1;
}
if ( strchr ( path, ':' ) != NULL )
{
r->_errno = EINVAL;
return -1;
}
_FAT_lock( &partition->lock );
// Search for the file on the disc
if ( !_FAT_directory_entryFromPath ( partition, &dirEntry, path, NULL ) )
{
_FAT_unlock( &partition->lock );
r->_errno = ENOENT;
return -1;
}
cluster = _FAT_directory_entryGetCluster ( partition, dirEntry.entryData );
// If this is a directory, make sure it is empty
if ( _FAT_directory_isDirectory ( &dirEntry ) )
{
nextEntry = _FAT_directory_getFirstEntry ( partition, &dirContents, cluster );
while ( nextEntry )
{
if ( !_FAT_directory_isDot ( &dirContents ) )
{
// The directory had something in it that isn't a reference to itself or it's parent
_FAT_unlock( &partition->lock );
r->_errno = EPERM;
return -1;
}
nextEntry = _FAT_directory_getNextEntry ( partition, &dirContents );
}
}
if ( _FAT_fat_isValidCluster( partition, cluster ) )
{
// Remove the cluster chain for this file
if ( !_FAT_fat_clearLinks ( partition, cluster ) )
{
r->_errno = EIO;
errorOccured = true;
}
}
// Remove the directory entry for this file
if ( !_FAT_directory_removeEntry ( partition, &dirEntry ) )
{
r->_errno = EIO;
errorOccured = true;
}
// Flush any sectors in the disc cache
if ( !_FAT_cache_flush( partition->cache ) )
{
r->_errno = EIO;
errorOccured = true;
}
_FAT_unlock( &partition->lock );
if ( errorOccured )
{
return -1;
}
else
{
return 0;
}
}
int _FAT_chdir_r ( struct _reent *r, const char *path )
{
PARTITION* partition = NULL;
// Get the partition this directory is on
partition = _FAT_partition_getPartitionFromPath ( path );
if ( partition == NULL )
{
r->_errno = ENODEV;
return -1;
}
// Move the path pointer to the start of the actual path
if ( strchr ( path, ':' ) != NULL )
{
path = strchr ( path, ':' ) + 1;
}
if ( strchr ( path, ':' ) != NULL )
{
r->_errno = EINVAL;
return -1;
}
_FAT_lock( &partition->lock );
// Try changing directory
if ( _FAT_directory_chdir ( partition, path ) )
{
// Successful
_FAT_unlock( &partition->lock );
return 0;
}
else
{
// Failed
_FAT_unlock( &partition->lock );
r->_errno = ENOTDIR;
return -1;
}
}
int _FAT_rename_r ( struct _reent *r, const char *oldName, const char *newName )
{
PARTITION* partition = NULL;
DIR_ENTRY oldDirEntry;
DIR_ENTRY newDirEntry;
const char *pathEnd;
uint32_t dirCluster;
// Get the partition this directory is on
partition = _FAT_partition_getPartitionFromPath ( oldName );
if ( partition == NULL )
{
r->_errno = ENODEV;
return -1;
}
_FAT_lock( &partition->lock );
// Make sure the same partition is used for the old and new names
if ( partition != _FAT_partition_getPartitionFromPath ( newName ) )
{
_FAT_unlock( &partition->lock );
r->_errno = EXDEV;
return -1;
}
// Make sure we aren't trying to write to a read-only disc
if ( partition->readOnly )
{
_FAT_unlock( &partition->lock );
r->_errno = EROFS;
return -1;
}
// Move the path pointer to the start of the actual path
if ( strchr ( oldName, ':' ) != NULL )
{
oldName = strchr ( oldName, ':' ) + 1;
}
if ( strchr ( oldName, ':' ) != NULL )
{
_FAT_unlock( &partition->lock );
r->_errno = EINVAL;
return -1;
}
if ( strchr ( newName, ':' ) != NULL )
{
newName = strchr ( newName, ':' ) + 1;
}
if ( strchr ( newName, ':' ) != NULL )
{
_FAT_unlock( &partition->lock );
r->_errno = EINVAL;
return -1;
}
// Search for the file on the disc
if ( !_FAT_directory_entryFromPath ( partition, &oldDirEntry, oldName, NULL ) )
{
_FAT_unlock( &partition->lock );
r->_errno = ENOENT;
return -1;
}
// Make sure there is no existing file / directory with the new name
if ( _FAT_directory_entryFromPath ( partition, &newDirEntry, newName, NULL ) )
{
_FAT_unlock( &partition->lock );
r->_errno = EEXIST;
return -1;
}
// Create the new file entry
// Get the directory it has to go in
pathEnd = strrchr ( newName, DIR_SEPARATOR );
if ( pathEnd == NULL )
{
// No path was specified
dirCluster = partition->cwdCluster;
pathEnd = newName;
}
else
{
// Path was specified -- get the right dirCluster
// Recycling newDirEntry, since it needs to be recreated anyway
if ( !_FAT_directory_entryFromPath ( partition, &newDirEntry, newName, pathEnd ) ||
!_FAT_directory_isDirectory( &newDirEntry ) )
{
_FAT_unlock( &partition->lock );
r->_errno = ENOTDIR;
return -1;
}
dirCluster = _FAT_directory_entryGetCluster ( partition, newDirEntry.entryData );
// Move the pathEnd past the last DIR_SEPARATOR
pathEnd += 1;
}
// Copy the entry data
memcpy ( &newDirEntry, &oldDirEntry, sizeof( DIR_ENTRY ) );
// Set the new name
strncpy ( newDirEntry.filename, pathEnd, MAX_FILENAME_LENGTH - 1 );
// Write the new entry
if ( !_FAT_directory_addEntry ( partition, &newDirEntry, dirCluster ) )
{
_FAT_unlock( &partition->lock );
r->_errno = ENOSPC;
return -1;
}
// Remove the old entry
if ( !_FAT_directory_removeEntry ( partition, &oldDirEntry ) )
{
_FAT_unlock( &partition->lock );
r->_errno = EIO;
return -1;
}
// Flush any sectors in the disc cache
if ( !_FAT_cache_flush ( partition->cache ) )
{
_FAT_unlock( &partition->lock );
r->_errno = EIO;
return -1;
}
_FAT_unlock( &partition->lock );
return 0;
}
int _FAT_mkdir_r ( struct _reent *r, const char *path, int mode )
{
PARTITION* partition = NULL;
bool fileExists;
DIR_ENTRY dirEntry;
const char* pathEnd;
uint32_t parentCluster, dirCluster;
uint8_t newEntryData[DIR_ENTRY_DATA_SIZE];
partition = _FAT_partition_getPartitionFromPath ( path );
if ( partition == NULL )
{
r->_errno = ENODEV;
return -1;
}
// Move the path pointer to the start of the actual path
if ( strchr ( path, ':' ) != NULL )
{
path = strchr ( path, ':' ) + 1;
}
if ( strchr ( path, ':' ) != NULL )
{
r->_errno = EINVAL;
return -1;
}
_FAT_lock( &partition->lock );
// Search for the file/directory on the disc
fileExists = _FAT_directory_entryFromPath ( partition, &dirEntry, path, NULL );
// Make sure it doesn't exist
if ( fileExists )
{
_FAT_unlock( &partition->lock );
r->_errno = EEXIST;
return -1;
}
if ( partition->readOnly )
{
// We can't write to a read-only partition
_FAT_unlock( &partition->lock );
r->_errno = EROFS;
return -1;
}
// Get the directory it has to go in
pathEnd = strrchr ( path, DIR_SEPARATOR );
if ( pathEnd == NULL )
{
// No path was specified
parentCluster = partition->cwdCluster;
pathEnd = path;
}
else
{
// Path was specified -- get the right parentCluster
// Recycling dirEntry, since it needs to be recreated anyway
if ( !_FAT_directory_entryFromPath ( partition, &dirEntry, path, pathEnd ) ||
!_FAT_directory_isDirectory( &dirEntry ) )
{
_FAT_unlock( &partition->lock );
r->_errno = ENOTDIR;
return -1;
}
parentCluster = _FAT_directory_entryGetCluster ( partition, dirEntry.entryData );
// Move the pathEnd past the last DIR_SEPARATOR
pathEnd += 1;
}
// Create the entry data
strncpy ( dirEntry.filename, pathEnd, MAX_FILENAME_LENGTH - 1 );
memset ( dirEntry.entryData, 0, DIR_ENTRY_DATA_SIZE );
// Set the creation time and date
dirEntry.entryData[DIR_ENTRY_cTime_ms] = 0;
u16_to_u8array ( dirEntry.entryData, DIR_ENTRY_cTime, _FAT_filetime_getTimeFromRTC() );
u16_to_u8array ( dirEntry.entryData, DIR_ENTRY_cDate, _FAT_filetime_getDateFromRTC() );
u16_to_u8array ( dirEntry.entryData, DIR_ENTRY_mTime, _FAT_filetime_getTimeFromRTC() );
u16_to_u8array ( dirEntry.entryData, DIR_ENTRY_mDate, _FAT_filetime_getDateFromRTC() );
u16_to_u8array ( dirEntry.entryData, DIR_ENTRY_aDate, _FAT_filetime_getDateFromRTC() );
// Set the directory attribute
dirEntry.entryData[DIR_ENTRY_attributes] = ATTRIB_DIR;
// Get a cluster for the new directory
dirCluster = _FAT_fat_linkFreeClusterCleared ( partition, CLUSTER_FREE );
if ( !_FAT_fat_isValidCluster( partition, dirCluster ) )
{
// No space left on disc for the cluster
_FAT_unlock( &partition->lock );
r->_errno = ENOSPC;
return -1;
}
u16_to_u8array ( dirEntry.entryData, DIR_ENTRY_cluster, dirCluster );
u16_to_u8array ( dirEntry.entryData, DIR_ENTRY_clusterHigh, dirCluster >> 16 );
// Write the new directory's entry to it's parent
if ( !_FAT_directory_addEntry ( partition, &dirEntry, parentCluster ) )
{
_FAT_unlock( &partition->lock );
r->_errno = ENOSPC;
return -1;
}
// Create the dot entry within the directory
memset ( newEntryData, 0, DIR_ENTRY_DATA_SIZE );
memset ( newEntryData, ' ', 11 );
newEntryData[DIR_ENTRY_name] = '.';
newEntryData[DIR_ENTRY_attributes] = ATTRIB_DIR;
u16_to_u8array ( newEntryData, DIR_ENTRY_cluster, dirCluster );
u16_to_u8array ( newEntryData, DIR_ENTRY_clusterHigh, dirCluster >> 16 );
// Write it to the directory, erasing that sector in the process
_FAT_cache_eraseWritePartialSector ( partition->cache, newEntryData,
_FAT_fat_clusterToSector ( partition, dirCluster ), 0, DIR_ENTRY_DATA_SIZE );
// Create the double dot entry within the directory
// if ParentDir == Rootdir then ".."" always link to Cluster 0
if ( parentCluster == partition->rootDirCluster )
parentCluster = FAT16_ROOT_DIR_CLUSTER;
newEntryData[DIR_ENTRY_name + 1] = '.';
u16_to_u8array ( newEntryData, DIR_ENTRY_cluster, parentCluster );
u16_to_u8array ( newEntryData, DIR_ENTRY_clusterHigh, parentCluster >> 16 );
// Write it to the directory
_FAT_cache_writePartialSector ( partition->cache, newEntryData,
_FAT_fat_clusterToSector ( partition, dirCluster ), DIR_ENTRY_DATA_SIZE, DIR_ENTRY_DATA_SIZE );
// Flush any sectors in the disc cache
if ( !_FAT_cache_flush( partition->cache ) )
{
_FAT_unlock( &partition->lock );
r->_errno = EIO;
return -1;
}
_FAT_unlock( &partition->lock );
return 0;
}
int _FAT_statvfs_r ( struct _reent *r, const char *path, struct statvfs *buf )
{
PARTITION* partition = NULL;
unsigned int freeClusterCount;
// Get the partition of the requested path
partition = _FAT_partition_getPartitionFromPath ( path );
if ( partition == NULL )
{
r->_errno = ENODEV;
return -1;
}
_FAT_lock( &partition->lock );
freeClusterCount = _FAT_fat_freeClusterCount ( partition );
// FAT clusters = POSIX blocks
buf->f_bsize = partition->bytesPerCluster; // File system block size.
buf->f_frsize = partition->bytesPerCluster; // Fundamental file system block size.
buf->f_blocks = partition->fat.lastCluster - CLUSTER_FIRST + 1; // Total number of blocks on file system in units of f_frsize.
buf->f_bfree = freeClusterCount; // Total number of free blocks.
buf->f_bavail = freeClusterCount; // Number of free blocks available to non-privileged process.
// Treat requests for info on inodes as clusters
buf->f_files = partition->fat.lastCluster - CLUSTER_FIRST + 1; // Total number of file serial numbers.
buf->f_ffree = freeClusterCount; // Total number of free file serial numbers.
buf->f_favail = freeClusterCount; // Number of file serial numbers available to non-privileged process.
// File system ID. 32bit ioType value
buf->f_fsid = _FAT_disc_hostType( partition->disc );
// Bit mask of f_flag values.
buf->f_flag = ST_NOSUID /* No support for ST_ISUID and ST_ISGID file mode bits */
| ( partition->readOnly ? ST_RDONLY /* Read only file system */ : 0 ) ;
// Maximum filename length.
buf->f_namemax = MAX_FILENAME_LENGTH;
_FAT_unlock( &partition->lock );
return 0;
}
DIR_ITER* _FAT_diropen_r( struct _reent *r, DIR_ITER *dirState, const char *path )
{
DIR_ENTRY dirEntry;
DIR_STATE_STRUCT* state = ( DIR_STATE_STRUCT* ) ( dirState->dirStruct );
bool fileExists;
state->partition = _FAT_partition_getPartitionFromPath ( path );
if ( state->partition == NULL )
{
r->_errno = ENODEV;
return NULL;
}
// Move the path pointer to the start of the actual path
if ( strchr ( path, ':' ) != NULL )
{
path = strchr ( path, ':' ) + 1;
}
if ( strchr ( path, ':' ) != NULL )
{
r->_errno = EINVAL;
return NULL;
}
_FAT_lock( &state->partition->lock );
// Get the start cluster of the directory
fileExists = _FAT_directory_entryFromPath ( state->partition, &dirEntry, path, NULL );
if ( !fileExists )
{
_FAT_unlock( &state->partition->lock );
r->_errno = ENOENT;
return NULL;
}
// Make sure it is a directory
if ( ! _FAT_directory_isDirectory ( &dirEntry ) )
{
_FAT_unlock( &state->partition->lock );
r->_errno = ENOTDIR;
return NULL;
}
// Save the start cluster for use when resetting the directory data
state->startCluster = _FAT_directory_entryGetCluster ( state->partition, dirEntry.entryData );
// Get the first entry for use with a call to dirnext
state->validEntry =
_FAT_directory_getFirstEntry ( state->partition, &( state->currentEntry ), state->startCluster );
// We are now using this entry
state->inUse = true;
_FAT_unlock( &state->partition->lock );
return ( DIR_ITER* ) state;
}
int _FAT_dirreset_r ( struct _reent *r, DIR_ITER *dirState )
{
DIR_STATE_STRUCT* state = ( DIR_STATE_STRUCT* ) ( dirState->dirStruct );
_FAT_lock( &state->partition->lock );
// Make sure we are still using this entry
if ( !state->inUse )
{
_FAT_unlock( &state->partition->lock );
r->_errno = EBADF;
return -1;
}
// Get the first entry for use with a call to dirnext
state->validEntry =
_FAT_directory_getFirstEntry ( state->partition, &( state->currentEntry ), state->startCluster );
_FAT_unlock( &state->partition->lock );
return 0;
}
int _FAT_dirnext_r ( struct _reent *r, DIR_ITER *dirState, char *filename, struct stat *filestat )
{
DIR_STATE_STRUCT* state = ( DIR_STATE_STRUCT* ) ( dirState->dirStruct );
_FAT_lock( &state->partition->lock );
// Make sure we are still using this entry
if ( !state->inUse )
{
_FAT_unlock( &state->partition->lock );
r->_errno = EBADF;
return -1;
}
// Make sure there is another file to report on
if ( ! state->validEntry )
{
_FAT_unlock( &state->partition->lock );
r->_errno = ENOENT;
return -1;
}
// Get the filename
strncpy ( filename, state->currentEntry.filename, MAX_FILENAME_LENGTH );
// Get the stats, if requested
if ( filestat != NULL )
{
_FAT_directory_entryStat ( state->partition, &( state->currentEntry ), filestat );
}
// Look for the next entry for use next time
state->validEntry =
_FAT_directory_getNextEntry ( state->partition, &( state->currentEntry ) );
_FAT_unlock( &state->partition->lock );
return 0;
}
int _FAT_dirclose_r ( struct _reent *r, DIR_ITER *dirState )
{
DIR_STATE_STRUCT* state = ( DIR_STATE_STRUCT* ) ( dirState->dirStruct );
// We are no longer using this entry
_FAT_lock( &state->partition->lock );
state->inUse = false;
_FAT_unlock( &state->partition->lock );
return 0;
}