/* 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 #include #include #include #include #include "fatdir.h" #include "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 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; }