709 lines
No EOL
21 KiB
C
709 lines
No EOL
21 KiB
C
#include "libfat.h"
|
|
|
|
#define FAT_ENTRY_CLUSTER(entry) ((((os_u32)entry.start_cluster_high) << 16) + entry.start_cluster)
|
|
|
|
#define DIRECTORY_BUFFER_SIZE 32
|
|
|
|
FatDirectoryEntry directory_buffer[DIRECTORY_BUFFER_SIZE];
|
|
|
|
|
|
os_bool libfat_read_header_12(LFFileHandle handle, FatHeader_12* result) {
|
|
|
|
handle.seek(0, LIBFAT_SEEK_END, handle.user_data);
|
|
os_u32 size = handle.tell(handle.user_data);
|
|
|
|
if (size < sizeof(FatHeader_12)) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
handle.seek(0, LIBFAT_SEEK_ORIGIN, handle.user_data);
|
|
handle.read(sizeof(FatHeader_12), (void*)result, handle.user_data);
|
|
|
|
return OS_TRUE;
|
|
}
|
|
|
|
os_bool libfat_read_header_32(LFFileHandle handle, FatHeader_32* result) {
|
|
handle.seek(0, LIBFAT_SEEK_END, handle.user_data);
|
|
os_u32 size = handle.tell(handle.user_data);
|
|
|
|
if (size < sizeof(FatHeader_32)) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
handle.seek(0, LIBFAT_SEEK_ORIGIN, handle.user_data);
|
|
handle.read(sizeof(FatHeader_32), (void*)result, handle.user_data);
|
|
|
|
return OS_TRUE;
|
|
}
|
|
|
|
os_bool libfat_load_fat_cluster(LFControlBlock* fat, os_u32 target_cluster, os_bool force) {
|
|
|
|
if (fat->first_loaded_cluster > target_cluster ||
|
|
fat->first_loaded_cluster + fat->loaded_fat_cluster_amount <= target_cluster ||
|
|
force != OS_FALSE) {
|
|
os_u32 fat_size = fat->header.sectors_per_fat_32 * fat->header.base.bytes_per_sector;
|
|
os_u32 fat_offset = (fat->header.base.bytes_per_sector * fat->header.base.reserved_sectors);
|
|
fat->handle.seek(fat_offset, LIBFAT_SEEK_ORIGIN, fat->handle.user_data);
|
|
|
|
os_u32 fat_clusters = fat_size / sizeof(os_u32);
|
|
|
|
if (target_cluster >= fat_clusters) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
os_u32 base_cluster = target_cluster - (target_cluster % fat->loaded_fat_cluster_amount);
|
|
os_u32 final_offset = fat_offset + (base_cluster * sizeof(os_u32));
|
|
|
|
fat->handle.read(fat->loaded_fat_cluster_amount * sizeof(os_u32), (void*)fat->loaded_fat_segment, fat->handle.user_data);
|
|
return OS_TRUE;
|
|
}
|
|
|
|
return OS_TRUE;
|
|
}
|
|
|
|
os_u32 libfat_read_cluster(LFControlBlock* fat, os_u32 cluster) {
|
|
if(libfat_load_fat_cluster(fat, cluster, OS_FALSE) == OS_FALSE) {
|
|
return 0;
|
|
}
|
|
|
|
return fat->loaded_fat_segment[cluster - fat->first_loaded_cluster];
|
|
}
|
|
|
|
|
|
os_bool libfat_write_fat_cluster(LFControlBlock* fat, os_u32 cluster_id, os_u32 cluster_value) {
|
|
os_u32 fat_size = fat->header.sectors_per_fat_32 * fat->header.base.bytes_per_sector;
|
|
if (cluster_id < 2 || cluster_id >= fat_size / sizeof(os_u32)) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
os_u32 first_fat_offset = (fat->header.base.reserved_sectors * fat->header.base.bytes_per_sector);
|
|
os_u32 second_fat_offset = first_fat_offset + fat_size;
|
|
|
|
os_u32 fisrt_fat_cluster_offset = first_fat_offset + (cluster_id * sizeof(os_u32));
|
|
os_u32 second_fat_cluster_offset = second_fat_offset + (cluster_id * sizeof(os_u32));
|
|
|
|
fat->handle.seek(fisrt_fat_cluster_offset, LIBFAT_SEEK_ORIGIN, fat->handle.user_data);
|
|
fat->handle.write(sizeof(os_u32), (void*)&cluster_value, fat->handle.user_data);
|
|
|
|
fat->handle.seek(second_fat_cluster_offset, LIBFAT_SEEK_ORIGIN, fat->handle.user_data);
|
|
fat->handle.write(sizeof(os_u32), (void*)&cluster_value, fat->handle.user_data);
|
|
|
|
return OS_TRUE;
|
|
}
|
|
|
|
os_u32 libfat_load_cluster(LFControlBlock* fat, os_u32 cluster, void* buffer, os_u32 buffer_size, os_u32 offset_in_cluster) {
|
|
os_u32 cluster_size = fat->header.base.bytes_per_sector * fat->header.base.sectors_per_cluster;
|
|
os_u32 data_offset = (fat->header.base.reserved_sectors + (fat->header.sectors_per_fat_32 * fat->header.base.number_of_fats)) * fat->header.base.bytes_per_sector;
|
|
|
|
if (offset_in_cluster >= cluster_size) {
|
|
return 0;
|
|
}
|
|
|
|
os_u32 cluster_offset = data_offset + ((cluster - 2) * cluster_size) + offset_in_cluster;
|
|
|
|
os_u32 amount_to_read = cluster_size - offset_in_cluster > buffer_size ? buffer_size : cluster_size - offset_in_cluster;
|
|
|
|
if(!fat->handle.seek(cluster_offset, LIBFAT_SEEK_ORIGIN, fat->handle.user_data)) {
|
|
return 0;
|
|
}
|
|
os_u32 read = fat->handle.read(amount_to_read, buffer, fat->handle.user_data);
|
|
|
|
return read;
|
|
|
|
}
|
|
|
|
os_u32 libfat_write_cluster(LFControlBlock* fat, os_u32 cluster, void* buffer, os_u32 buffer_size, os_u32 offset_in_cluster) {
|
|
os_u32 cluster_size = fat->header.base.bytes_per_sector * fat->header.base.sectors_per_cluster;
|
|
os_u32 data_offset = (fat->header.base.reserved_sectors + (fat->header.sectors_per_fat_32 * fat->header.base.number_of_fats)) * fat->header.base.bytes_per_sector;
|
|
|
|
if (offset_in_cluster + buffer_size >= cluster_size) {
|
|
return 0;
|
|
}
|
|
|
|
os_u32 cluster_offset = data_offset + ((cluster - 2) * cluster_size) + offset_in_cluster;
|
|
if(fat->handle.seek(cluster_offset, LIBFAT_SEEK_ORIGIN, fat->handle.user_data) != OS_TRUE) {
|
|
return 0;
|
|
}
|
|
os_u32 written = fat->handle.write(buffer_size, buffer, fat->handle.user_data);
|
|
return written;
|
|
}
|
|
|
|
os_bool libfat_open(LFControlBlock* fat, LFDirectoryEntry* entry, LFFile* result) {
|
|
if(result == 0 || fat == 0 || entry == 0) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
if ((entry->entry.attribute & FAT_SYSTEM_BIT) != 0 ||
|
|
(entry->entry.attribute & FAT_VOLUME_BIT) != 0) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
result->fat = fat;
|
|
result->file_entry = *entry;
|
|
result->fat_cluster_size = fat->header.base.sectors_per_cluster * fat->header.base.bytes_per_sector;
|
|
result->position = 0;
|
|
result->current_cluster = FAT_ENTRY_CLUSTER(entry->entry);
|
|
result->in_cluster_position = 0;
|
|
|
|
return OS_TRUE;
|
|
}
|
|
|
|
os_bool libfat_open_directory(LFControlBlock* fat, LFDirectoryEntry* entry, LFDirectory* result) {
|
|
if (fat == 0 || result == 0) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
if (entry != 0 && (entry->entry.attribute & FAT_SUBDIRECTORY_BIT) == 0) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
result->fat = fat;
|
|
result->fat_cluster_size = fat->header.base.sectors_per_cluster * fat->header.base.bytes_per_sector;
|
|
result->current_cluster = entry == 0 ? fat->header.first_root_cluster : FAT_ENTRY_CLUSTER(entry->entry);
|
|
result->base_cluster = result->current_cluster;
|
|
result->position_in_cluster = 0;
|
|
result->done = 0;
|
|
|
|
return OS_TRUE;
|
|
}
|
|
|
|
os_bool libfat_read_directory(LFDirectory* dir, LFDirectoryEntry* entry) {
|
|
if (dir == 0 || entry == 0) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
if (dir->done == OS_TRUE) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
FatDirectoryEntry my_entry;
|
|
os_u32 read = libfat_load_cluster(dir->fat, dir->current_cluster, &my_entry, sizeof(FatDirectoryEntry), dir->position_in_cluster);
|
|
os_u32 cluster = dir->current_cluster;
|
|
os_u32 offset = dir->position_in_cluster;
|
|
dir->position_in_cluster += read;
|
|
if (dir->position_in_cluster == dir->fat_cluster_size) {
|
|
os_u32 next_cluster = libfat_read_cluster(dir->fat, dir->current_cluster);
|
|
if (next_cluster >= FAT_LAST_CLUSTER_32) {
|
|
dir->done = OS_TRUE;
|
|
}
|
|
dir->current_cluster = next_cluster;
|
|
}
|
|
|
|
if (my_entry.file_name[0] == '\0') {
|
|
dir->done = OS_TRUE;
|
|
return OS_FALSE;
|
|
}
|
|
|
|
entry->entry = my_entry;
|
|
entry->entry_cluster = cluster;
|
|
entry->entry_offset = offset;
|
|
return OS_TRUE;
|
|
}
|
|
|
|
os_u32 libfat_read(LFFile* file, void* buffer, os_u32 buffer_size) {
|
|
os_u32 read = 0;
|
|
os_bool eof = file->position >= file->file_entry.entry.file_size ? OS_TRUE : OS_FALSE;
|
|
while(read < buffer_size && eof != OS_TRUE) {
|
|
os_u32 amount_left = file->file_entry.entry.file_size - file->position;
|
|
os_u32 amount_to_read = (buffer_size - read) > amount_left ? amount_left : buffer_size - read;
|
|
|
|
os_u32 local_read;
|
|
if (file->in_cluster_position + amount_to_read >= file->fat_cluster_size) {
|
|
local_read = file->fat_cluster_size - file->in_cluster_position;
|
|
} else {
|
|
local_read = amount_to_read;
|
|
}
|
|
|
|
os_u32 r = libfat_load_cluster(file->fat, file->current_cluster, buffer, local_read, file->in_cluster_position);
|
|
|
|
read += r;
|
|
buffer = ((char*) buffer) + r;
|
|
file->position += r;
|
|
file->in_cluster_position += r;
|
|
if (file->in_cluster_position == file->fat_cluster_size) {
|
|
file->current_cluster = libfat_read_cluster(file->fat, file->current_cluster);
|
|
file->in_cluster_position = 0;
|
|
}
|
|
|
|
if (file->position == file->file_entry.entry.file_size) {
|
|
eof = OS_TRUE;
|
|
}
|
|
}
|
|
|
|
return read;
|
|
}
|
|
|
|
os_u32 libfat_tell(LFFile* file) {
|
|
if(file == 0) {
|
|
return 0;
|
|
}
|
|
|
|
return file->position;
|
|
}
|
|
|
|
os_bool libfat_init(LFFileHandle file, void* buffer, os_u32 buffer_size, LFControlBlock* result) {
|
|
if(libfat_read_header_32(file, &result->header) != OS_TRUE) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
result->handle = file;
|
|
result->loaded_fat_segment = (os_u32*)buffer;
|
|
result->loaded_fat_cluster_amount = buffer_size / sizeof(os_u32);
|
|
result->first_loaded_cluster = 0;
|
|
|
|
if(libfat_load_fat_cluster(result, 2, OS_TRUE) != OS_TRUE) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
return OS_TRUE;
|
|
}
|
|
|
|
os_bool libfat_seek(LFFile* file, os_s32 position, os_u32 direction) {
|
|
if (direction != LIBFAT_SEEK_CURRENT && direction != LIBFAT_SEEK_END && direction != LIBFAT_SEEK_ORIGIN) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
if (file == 0) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
os_u32 target = 0;
|
|
os_s32 final = 0;
|
|
os_s32 reverse = 0;
|
|
|
|
switch(direction) {
|
|
case LIBFAT_SEEK_ORIGIN:
|
|
target = (os_u32)position;
|
|
break;
|
|
case LIBFAT_SEEK_CURRENT:
|
|
final = position + file->position;
|
|
if (final < 0) {
|
|
return OS_FALSE;
|
|
}
|
|
target = (os_u32)final;
|
|
break;
|
|
case LIBFAT_SEEK_END:
|
|
reverse = file->file_entry.entry.file_size - position;
|
|
if (reverse < 0) {
|
|
return OS_FALSE;
|
|
}
|
|
target = (os_u32)reverse;
|
|
break;
|
|
}
|
|
|
|
if (target >= file->file_entry.entry.file_size) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
os_u32 cluster = FAT_ENTRY_CLUSTER(file->file_entry.entry);
|
|
os_u32 tmp_pos = 0;
|
|
|
|
while((tmp_pos + file->fat_cluster_size) <= target) {
|
|
os_u32 next_cluster = libfat_read_cluster(file->fat, cluster);
|
|
tmp_pos += file->fat_cluster_size;
|
|
cluster = next_cluster;
|
|
}
|
|
|
|
file->current_cluster = cluster;
|
|
file->in_cluster_position = target - tmp_pos;
|
|
file->position = target;
|
|
return OS_TRUE;
|
|
}
|
|
|
|
os_u32 libfat_find_free_cluster(LFControlBlock* fat) {
|
|
os_u32 cluster_id = 2;
|
|
os_u32 cluster_value = FAT_LAST_CLUSTER_32;
|
|
do {
|
|
cluster_value = libfat_read_cluster(fat, cluster_id);
|
|
if (cluster_value != 0) {
|
|
cluster_id++;
|
|
}
|
|
if (cluster_id >= (fat->header.sectors_per_fat_32 * fat->header.base.bytes_per_sector) / sizeof(os_u32)) {
|
|
return 0;
|
|
}
|
|
} while(cluster_value != 0);
|
|
return cluster_id;
|
|
}
|
|
|
|
|
|
os_bool libfat_fsinfo_update(LFControlBlock* fat) {
|
|
os_u32 fsinfo_offset = fat->header.fsinfo_sector * fat->header.base.bytes_per_sector;
|
|
if(fat->handle.seek(fsinfo_offset, LIBFAT_SEEK_ORIGIN, fat->handle.user_data) != OS_TRUE) {
|
|
return OS_FALSE;
|
|
}
|
|
os_u32 sig = 0;
|
|
os_u32 read = fat->handle.read(sizeof(os_u32), (void*)&sig, fat->handle.user_data);
|
|
if (read != sizeof(os_u32) || sig != FAT_FSINFO_SIG_0) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
if(fat->handle.seek(fsinfo_offset + 484, LIBFAT_SEEK_ORIGIN, fat->handle.user_data) != OS_TRUE) {
|
|
return OS_FALSE;
|
|
}
|
|
read = fat->handle.read(sizeof(os_u32), (void*)&sig, fat->handle.user_data);
|
|
if (read != sizeof(os_u32) || sig != FAT_FSINFO_SIG_1) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
os_u32 free_clusters = 0;
|
|
read = fat->handle.read(sizeof(os_u32), (void*)&free_clusters, fat->handle.user_data);
|
|
if (read != sizeof(os_u32)) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
os_u32 next_free_cluster = 0;
|
|
read = fat->handle.read(sizeof(os_u32), (void*)&next_free_cluster, fat->handle.user_data);
|
|
if (read != sizeof(os_u32)) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
if (free_clusters != 0xffffffff) {
|
|
free_clusters--;
|
|
if(fat->handle.seek(fsinfo_offset + 488, LIBFAT_SEEK_ORIGIN, fat->handle.user_data) == OS_TRUE) {
|
|
fat->handle.write(sizeof(os_u32), (void*)&free_clusters, fat->handle.user_data);
|
|
}
|
|
}
|
|
|
|
if (next_free_cluster != 0xffffffff) {
|
|
next_free_cluster = libfat_find_free_cluster(fat);
|
|
if (next_free_cluster < 2) {
|
|
next_free_cluster = 0xffffffff;
|
|
}
|
|
if (fat->handle.seek(fsinfo_offset + 492, LIBFAT_SEEK_ORIGIN, fat->handle.user_data) == OS_TRUE) {
|
|
fat->handle.write(sizeof(os_u32), (void*)&next_free_cluster, fat->handle.user_data);
|
|
}
|
|
}
|
|
|
|
return OS_TRUE;
|
|
}
|
|
|
|
os_bool libfat_fsinfo_free(LFControlBlock* fat, os_u32 freed_cluster) {
|
|
os_u32 fsinfo_offset = fat->header.fsinfo_sector * fat->header.base.bytes_per_sector;
|
|
if(fat->handle.seek(fsinfo_offset, LIBFAT_SEEK_ORIGIN, fat->handle.user_data) != OS_TRUE) {
|
|
return OS_FALSE;
|
|
}
|
|
os_u32 sig = 0;
|
|
os_u32 read = fat->handle.read(sizeof(os_u32), (void*)&sig, fat->handle.user_data);
|
|
if (read != sizeof(os_u32) || sig != FAT_FSINFO_SIG_0) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
if(fat->handle.seek(fsinfo_offset + 484, LIBFAT_SEEK_ORIGIN, fat->handle.user_data) != OS_TRUE) {
|
|
return OS_FALSE;
|
|
}
|
|
read = fat->handle.read(sizeof(os_u32), (void*)&sig, fat->handle.user_data);
|
|
if (read != sizeof(os_u32) || sig != FAT_FSINFO_SIG_1) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
os_u32 free_clusters = 0;
|
|
read = fat->handle.read(sizeof(os_u32), (void*)&free_clusters, fat->handle.user_data);
|
|
if (read != sizeof(os_u32)) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
os_u32 next_free_cluster = 0;
|
|
read = fat->handle.read(sizeof(os_u32), (void*)&next_free_cluster, fat->handle.user_data);
|
|
if (read != sizeof(os_u32)) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
if (free_clusters != 0xffffffff) {
|
|
free_clusters++;
|
|
if(fat->handle.seek(fsinfo_offset + 488, LIBFAT_SEEK_ORIGIN, fat->handle.user_data) == OS_TRUE) {
|
|
fat->handle.write(sizeof(os_u32), (void*)&free_clusters, fat->handle.user_data);
|
|
}
|
|
}
|
|
|
|
if (next_free_cluster != 0xffffffff && freed_cluster < next_free_cluster) {
|
|
next_free_cluster = libfat_find_free_cluster(fat);
|
|
if (next_free_cluster < 2) {
|
|
next_free_cluster = 0xffffffff;
|
|
}
|
|
if (fat->handle.seek(fsinfo_offset + 492, LIBFAT_SEEK_ORIGIN, fat->handle.user_data) == OS_TRUE) {
|
|
fat->handle.write(sizeof(os_u32), (void*)&next_free_cluster, fat->handle.user_data);
|
|
}
|
|
}
|
|
|
|
return OS_TRUE;
|
|
}
|
|
|
|
|
|
os_bool libfat_truncate(LFControlBlock* fat, LFDirectoryEntry* entry) {
|
|
if (fat == 0 || entry == 0) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
if ((entry->entry.attribute & FAT_SUBDIRECTORY_BIT) != 0) {
|
|
return OS_FALSE; //Disable truncating subdirectories
|
|
}
|
|
|
|
entry->entry.file_size = 0;
|
|
os_u32 written = libfat_write_cluster(fat, entry->entry_cluster, &entry->entry, sizeof(FatDirectoryEntry), entry->entry_offset);
|
|
if (written != sizeof(FatDirectoryEntry)) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
os_u32 cluster = libfat_read_cluster(fat, FAT_ENTRY_CLUSTER(entry->entry));
|
|
libfat_write_fat_cluster(fat, FAT_ENTRY_CLUSTER(entry->entry), FAT_LAST_CLUSTER_32_2);
|
|
while(cluster < FAT_LAST_CLUSTER_32) {
|
|
os_u32 next_cluster = libfat_read_cluster(fat, cluster);
|
|
libfat_write_fat_cluster(fat, cluster, 0);
|
|
|
|
libfat_fsinfo_free(fat, cluster);
|
|
cluster = next_cluster;
|
|
}
|
|
|
|
return OS_TRUE;
|
|
}
|
|
|
|
os_u32 libfat_add_cluster_to_chain(LFControlBlock* fat, os_u32 last_cluster_id) {
|
|
os_u32 cluster_value;
|
|
do {
|
|
cluster_value = libfat_read_cluster(fat, last_cluster_id);
|
|
if(cluster_value == 0) {
|
|
return 0;
|
|
}
|
|
} while(cluster_value < FAT_LAST_CLUSTER_32);
|
|
|
|
os_u32 free_cluster = libfat_find_free_cluster(fat);
|
|
if (free_cluster == 0) {
|
|
return 0;
|
|
}
|
|
|
|
if(libfat_write_fat_cluster(fat, last_cluster_id, free_cluster) != OS_TRUE) {
|
|
return 0;
|
|
}
|
|
|
|
if(libfat_write_fat_cluster(fat, free_cluster, FAT_LAST_CLUSTER_32_2) != OS_TRUE) {
|
|
return 0;
|
|
}
|
|
|
|
libfat_fsinfo_update(fat);
|
|
|
|
return free_cluster;
|
|
}
|
|
|
|
os_bool libfat_add_entry_to_directory(LFControlBlock* fat, LFDirectoryEntry* parent, FatDirectoryEntry* entry, LFDirectoryEntry* result) {
|
|
os_u32 cluster = fat->header.first_root_cluster;
|
|
if (parent != 0) {
|
|
cluster = FAT_ENTRY_CLUSTER(parent->entry);
|
|
}
|
|
os_u32 cluster_offset = 0;
|
|
os_u32 next_cluster = libfat_read_cluster(fat, cluster);
|
|
|
|
FatDirectoryEntry local_entry;
|
|
do {
|
|
os_u32 read = libfat_load_cluster(fat, cluster, (void*)&local_entry, sizeof(FatDirectoryEntry), cluster_offset);
|
|
if (local_entry.file_name[0] == '\0') {
|
|
break;
|
|
}
|
|
|
|
cluster_offset += read;
|
|
if (cluster_offset >= fat->header.base.sectors_per_cluster * fat->header.base.bytes_per_sector) {
|
|
cluster_offset = 0;
|
|
if (next_cluster >= FAT_LAST_CLUSTER_32) {
|
|
next_cluster = libfat_add_cluster_to_chain(fat, next_cluster);
|
|
if (next_cluster == 0) {
|
|
//Invalid end cluster or no more available clusters
|
|
return OS_FALSE;
|
|
}
|
|
}
|
|
cluster = next_cluster;
|
|
next_cluster = libfat_read_cluster(fat, cluster);
|
|
break;
|
|
}
|
|
} while(local_entry.file_name[0] != '\0');
|
|
|
|
if(libfat_write_cluster(fat, cluster, (void*)entry, sizeof(FatDirectoryEntry), cluster_offset) == 0) {
|
|
return OS_FALSE; //TODO: Maybe undo added cluster
|
|
}
|
|
|
|
result->entry_cluster = cluster;
|
|
result->entry_offset = cluster_offset;
|
|
result->entry = *entry;
|
|
|
|
cluster_offset += sizeof(FatDirectoryEntry);
|
|
if (cluster_offset >= fat->header.base.bytes_per_sector * fat->header.base.sectors_per_cluster) {
|
|
cluster = libfat_add_cluster_to_chain(fat, cluster);
|
|
cluster_offset = 0;
|
|
}
|
|
|
|
char buffer[sizeof(FatDirectoryEntry)];
|
|
for(int i = 0; i < sizeof(FatDirectoryEntry); i++) {
|
|
buffer[i] = '\0';
|
|
}
|
|
|
|
libfat_write_cluster(fat, cluster, (void*)buffer, sizeof(FatDirectoryEntry), cluster_offset);
|
|
|
|
return OS_TRUE;
|
|
}
|
|
|
|
os_bool libfat_create(LFControlBlock* fat, LFDirectoryEntry* parent_entry, os_s8* name, os_bool directory, LFDirectoryEntry* result) {
|
|
FatDirectoryEntry new_entry;
|
|
for(int i = 0; i < 8; i++) {
|
|
new_entry.file_name[i] = name[i];
|
|
}
|
|
for(int i = 0; i < 3; i++) {
|
|
new_entry.extension[i] = name[8 + i];
|
|
}
|
|
|
|
new_entry.attribute = directory != OS_FALSE ? FAT_SUBDIRECTORY_BIT : 0;
|
|
new_entry.date = 0;
|
|
for(int i = 0; i < 8; i++) {
|
|
new_entry.reserved[i] = 0;
|
|
}
|
|
new_entry.time = 0;
|
|
new_entry.file_size = 0;
|
|
|
|
os_u32 cluster = libfat_find_free_cluster(fat);
|
|
if (cluster < 2) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
new_entry.start_cluster = (os_u16) cluster;
|
|
new_entry.start_cluster_high = (os_u16) (cluster >> 16);
|
|
if (libfat_write_fat_cluster(fat, cluster, FAT_LAST_CLUSTER_32_2) != OS_TRUE) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
if(libfat_add_entry_to_directory(fat, parent_entry, &new_entry, result) != OS_TRUE) {
|
|
libfat_write_fat_cluster(fat, cluster, 0);
|
|
return OS_FALSE;
|
|
}
|
|
|
|
libfat_fsinfo_update(fat);
|
|
return OS_TRUE;
|
|
}
|
|
|
|
os_u32 libfat_write(LFFile* f, void* buffer, os_u32 buffer_size) {
|
|
if (f == 0 || buffer == 0 || buffer_size == 0) {
|
|
return 0;
|
|
}
|
|
|
|
os_u32 start_position = f->position;
|
|
os_u32 written = 0;
|
|
|
|
while (buffer_size > 0) {
|
|
os_u32 amount = f->fat_cluster_size - f->in_cluster_position;
|
|
if (amount > buffer_size) {
|
|
amount = buffer_size;
|
|
}
|
|
|
|
os_u32 w = libfat_write_cluster(f->fat, f->current_cluster, buffer, amount, f->in_cluster_position);
|
|
written += w;
|
|
f->position += w;
|
|
f->in_cluster_position += w;
|
|
buffer = ((char*)buffer) + w;
|
|
buffer_size -= w;
|
|
if (f->in_cluster_position >= f->fat_cluster_size) {
|
|
f->in_cluster_position = 0;
|
|
os_u32 next = libfat_read_cluster(f->fat, f->current_cluster);
|
|
if (next >= FAT_LAST_CLUSTER_32_2) {
|
|
next = libfat_add_cluster_to_chain(f->fat, next);
|
|
}
|
|
f->current_cluster = next;
|
|
}
|
|
}
|
|
|
|
if(f->position > f->file_entry.entry.file_size) {
|
|
f->file_entry.entry.file_size = f->position;
|
|
libfat_write_cluster(f->fat, f->file_entry.entry_cluster, (void*)&f->file_entry.entry, sizeof(FatDirectoryEntry), f->file_entry.entry_offset);
|
|
}
|
|
|
|
return written;
|
|
}
|
|
|
|
os_u32 libfat_get_true_entry_offset(LFControlBlock* fat, LFDirectoryEntry* entry) {
|
|
if (fat == 0 || entry == 0) {
|
|
return 0;
|
|
}
|
|
|
|
os_u32 cluster_size = fat->header.base.bytes_per_sector * fat->header.base.sectors_per_cluster;
|
|
os_u32 data_offset = (fat->header.base.reserved_sectors + (fat->header.sectors_per_fat_32 * fat->header.base.number_of_fats)) * fat->header.base.bytes_per_sector;
|
|
|
|
return data_offset + (cluster_size * FAT_ENTRY_CLUSTER(entry->entry) - 2);
|
|
}
|
|
|
|
os_bool libfat_test_mbr(LFFileHandle* mbr) {
|
|
if (mbr == 0) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
if(mbr->seek(0, LIBFAT_SEEK_ORIGIN, mbr->user_data) != OS_TRUE) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
char buffer[6];
|
|
os_u32 read = mbr->read(6, buffer, mbr->user_data);
|
|
if (read < 6) {
|
|
return OS_FALSE;
|
|
}
|
|
|
|
return (buffer[2] != 0x49 && buffer[3] == 0x49) ? OS_TRUE : OS_FALSE;
|
|
}
|
|
/*
|
|
void libfat_test(LFFileHandle handle, PrintRoutine print, PrintNumber printNumber) {
|
|
LFControlBlock cb;
|
|
if (libfat_init(handle, loaded_fat_segment, 512 * sizeof(os_u32), &cb) != OS_TRUE) {
|
|
print("Failed to init FAT.", 0);
|
|
return;
|
|
}
|
|
|
|
LFDirectory dir;
|
|
if (libfat_open_directory(&cb, 0, &dir) != OS_TRUE) {
|
|
print("Failecd to open directory.", 0);
|
|
return;
|
|
}
|
|
|
|
os_bool any = OS_FALSE;
|
|
LFDirectoryEntry entry;
|
|
while(libfat_read_directory(&dir, &entry) == OS_TRUE) {
|
|
if ((entry.entry.attribute & (os_s8)FAT_HIDDEN_BIT) != 0 ||
|
|
(entry.entry.attribute & (os_s8)FAT_VOLUME_BIT) != 0 ||
|
|
(entry.entry.attribute & (os_s8)FAT_SYSTEM_BIT) != 0) {
|
|
continue;
|
|
}
|
|
any = OS_TRUE;
|
|
|
|
print("Entry name: ", 0);
|
|
print(entry.entry.file_name, 11);
|
|
|
|
os_u32 cluster = FAT_ENTRY_CLUSTER(entry.entry);
|
|
|
|
print("Cluster: ", 0);
|
|
printNumber(cluster);
|
|
|
|
print("Size: ", 0);
|
|
printNumber(entry.entry.file_size);
|
|
|
|
os_u32 effective_size = entry.entry.file_size > 512 ? 512 : entry.entry.file_size;
|
|
if(effective_size > 0) {
|
|
LFFile f;
|
|
if (libfat_open(&cb, &entry, &f) == OS_TRUE) {
|
|
char buffer[512];
|
|
os_u32 amount = libfat_read(&f, buffer, 512);
|
|
print("Content: ", 0);
|
|
print(buffer, amount);
|
|
}
|
|
}
|
|
|
|
print("--------", 0);
|
|
}
|
|
|
|
if(any == OS_FALSE) {
|
|
LFDirectoryEntry created_file;
|
|
libfat_create(&cb, 0, "TEST TXT", OS_FALSE, &created_file);
|
|
print("Added file 'test.txt'", 0);
|
|
|
|
LFFile new_file;
|
|
if(libfat_open(&cb, &created_file, &new_file) != OS_TRUE) {
|
|
print("Failed to open new file", 0);
|
|
return;
|
|
}
|
|
|
|
char* data = "test";
|
|
libfat_write(&new_file, data, 5);
|
|
}
|
|
}
|
|
*/ |