Browse Source

function to create a directory

master
Ondřej Hruška 7 years ago
parent
commit
9b61123c20
  1. 2
      Makefile
  2. 346
      fat16.c
  3. 71
      fat16.h
  4. 59
      main.c
  5. BIN
      test

2
Makefile

@ -1,7 +1,7 @@
all: main
main: main.c
gcc -std=gnu99 main.c fat16.c -o test -g
gcc -Wall -std=gnu99 main.c fat16.c -o test -g
run: main
./test

346
fat16.c

@ -57,16 +57,16 @@ uint16_t read_fat(const FAT16* fat, const uint16_t cluster);
/** Find absolute address of first boot sector. Returns 0 on failure. */
uint32_t find_bs(const BLOCKDEV* dev)
{
// Reference structure:
// Reference structure:
//
// typedef struct __attribute__((packed)) {
// uint8_t first_byte;
// uint8_t start_chs[3];
// uint8_t partition_type;
// uint8_t end_chs[3];
// uint32_t start_sector;
// uint32_t length_sectors;
// } PartitionTable;
// typedef struct __attribute__((packed)) {
// uint8_t first_byte;
// uint8_t start_chs[3];
// uint8_t partition_type;
// uint8_t end_chs[3];
// uint32_t start_sector;
// uint32_t length_sectors;
// } PartitionTable;
uint16_t addr = 0x1BE + 4; // fourth byte of structure is the type.
uint32_t tmp = 0;
@ -121,7 +121,8 @@ void read_bs(const BLOCKDEV* dev, Fat16BootSector* info, const uint32_t addr)
if (info->total_sectors == 0)
{
dev->load(&(info->total_sectors), 4);
} else
}
else
{
dev->rseek(4); // tsl
}
@ -236,19 +237,18 @@ bool append_cluster(const FAT16* fat, const uint16_t clu)
void free_cluster_chain(const FAT16* fat, uint16_t clu)
{
do {
do
{
// get address of the next cluster
const uint16_t clu2 = read_fat(fat, clu);
// mark cluster as unused
write_fat(fat, clu, 0x0000);
printf("Cluster free at %d\n", clu);
// advance
clu = clu2;
} while (clu != 0xFFFF);
}
while (clu != 0xFFFF);
}
@ -258,7 +258,8 @@ void free_cluster_chain(const FAT16* fat, uint16_t clu)
*/
bool dir_contains_file_raw(FAT16_FILE* dir, char* fname)
{
do {
do
{
bool diff = false;
for (uint8_t i = 0; i < 11; i++)
{
@ -271,7 +272,8 @@ bool dir_contains_file_raw(FAT16_FILE* dir, char* fname)
if (!diff) return true;
} while (fat16_next(dir));
}
while (fat16_next(dir));
return false;
}
@ -290,7 +292,8 @@ void open_file(const FAT16* fat, FAT16_FILE* file, const uint16_t dir_cluster, c
if (dir_cluster == 0)
{
addr = clu_addr(fat, dir_cluster) + num * 32; // root directory, max 512 entries.
} else
}
else
{
addr = clu_offs(fat, dir_cluster, num * 32); // cluster + N (wrapping to next cluster if needed)
}
@ -307,7 +310,7 @@ void open_file(const FAT16* fat, FAT16_FILE* file, const uint16_t dir_cluster, c
file->type = FT_FILE;
switch(file->name[0])
switch (file->name[0])
{
case 0x00:
file->type = FT_NONE;
@ -327,7 +330,8 @@ void open_file(const FAT16* fat, FAT16_FILE* file, const uint16_t dir_cluster, c
{
// ".." directory
file->type = FT_PARENT;
} else
}
else
{
// "." directory
file->type = FT_SELF;
@ -382,41 +386,43 @@ void fat16_init(const BLOCKDEV* dev, FAT16* fat)
*/
bool fat16_fseek(FAT16_FILE* file, uint32_t addr)
{
const FAT16* fat = file->fat;
// Store as rel
file->cur_rel = addr;
// Rewind and resolve abs, clu, ofs
file->cur_clu = file->clu_start;
while (addr >= file->fat->bs.bytes_per_cluster)
while (addr >= fat->bs.bytes_per_cluster)
{
uint32_t next;
// Go to next cluster, allocate if needed
do {
next = next_clu(file->fat, file->cur_clu);
do
{
next = next_clu(fat, file->cur_clu);
if (next == 0xFFFF)
{
// reached end of allocated space
// add one more cluster
if (!append_cluster(file->fat, file->cur_clu))
if (!append_cluster(fat, file->cur_clu))
{
return false;
}
printf("Allocating new cluster due to seek past EOF\n");
}
} while(next == 0xFFFF);
}
while (next == 0xFFFF);
file->cur_clu = next;
addr -= file->fat->bs.bytes_per_cluster;
addr -= fat->bs.bytes_per_cluster;
}
file->cur_abs = clu_addr(file->fat, file->cur_clu) + addr;
file->cur_abs = clu_addr(fat, file->cur_clu) + addr;
file->cur_ofs = addr;
// Physically seek to that location
file->fat->dev->seek(file->cur_abs);
fat->dev->seek(file->cur_abs);
return true;
}
@ -427,7 +433,8 @@ bool fat16_fseek(FAT16_FILE* file, uint32_t addr)
*/
bool fat16_is_file_valid(const FAT16_FILE* file)
{
switch (file->type) {
switch (file->type)
{
case FT_FILE:
case FT_SUBDIR:
case FT_SELF:
@ -444,18 +451,11 @@ bool fat16_is_file_valid(const FAT16_FILE* file)
bool fat16_fread(FAT16_FILE* file, void* target, uint32_t len)
{
if (file->cur_abs == 0xFFFF) {
printf("File at 0xFFFF\n");
if (file->cur_abs == 0xFFFF)
return false; // file at the end already
}
if (file->cur_rel + len > file->size)
{
// Attempt to read more than what is available
printf("Attempt to read more than what is available\n");
return false;
}
return false; // Attempt to read more than what is available
const FAT16* fat = file->fat;
const BLOCKDEV* dev = fat->dev;
@ -493,7 +493,7 @@ bool fat16_fread(FAT16_FILE* file, void* target, uint32_t len)
}
bool fat16_fwrite(FAT16_FILE* file, void* src, uint32_t len)
bool fat16_fwrite(FAT16_FILE* file, void* source, uint32_t len)
{
const FAT16* fat = file->fat;
const BLOCKDEV* dev = fat->dev;
@ -507,8 +507,10 @@ bool fat16_fwrite(FAT16_FILE* file, void* src, uint32_t len)
{
const uint32_t pos_start = file->cur_rel;
// Seek to the last position, using fseek to allocate clusters
if (!fat16_fseek(file, pos_start + len)) return false;
// Seek to the last position
// -> fseek will allocate clusters
if (!fat16_fseek(file, pos_start + len))
return false; // error in seek
// Write starts beyond EOF - creating a zero-filled "hole"
if (file->cur_rel > file->size)
@ -532,8 +534,6 @@ bool fat16_fwrite(FAT16_FILE* file, void* src, uint32_t len)
dev->write(0);
}
printf("Wrote %d filler zeros.\n", chunk);
// subtract from "needed" what was just placed
fill -= chunk;
@ -545,7 +545,7 @@ bool fat16_fwrite(FAT16_FILE* file, void* src, uint32_t len)
}
// Save new size
fat16_set_file_size(file, pos_start + len);
fat16_resize(file, pos_start + len);
// Seek back to where it was before
fat16_fseek(file, pos_start);
@ -560,25 +560,25 @@ bool fat16_fwrite(FAT16_FILE* file, void* src, uint32_t len)
// store the chunk
dev->seek(file->cur_abs);
dev->store(src, chunk);
dev->store(source, chunk);
// advance cursors
file->cur_abs += chunk;
file->cur_rel += chunk;
file->cur_ofs += chunk;
src += chunk; // advance the source pointer
// Pointer arith!
source += chunk; // advance the source pointer
// detect cluster overflow
if (file->cur_ofs >= fat->bs.bytes_per_cluster)
{
// advance to following cluster
file->cur_clu = next_clu(fat, file->cur_clu);
file->cur_abs = clu_addr(fat, file->cur_clu);
file->cur_ofs = 0;
}
printf("Stored %d bytes of data.\n", chunk);
// subtract written length
len -= chunk;
}
@ -597,20 +597,16 @@ bool fat16_next(FAT16_FILE* file)
if (file->clu == 0 && file->num >= fat->bs.root_entries)
return false; // attempt to read outside root directory.
uint32_t addr = clu_offs(fat, file->clu, (file->num + 1) * 32);
const uint32_t addr = clu_offs(fat, file->clu, (file->num + 1) * 32);
if (addr == 0xFFFF)
return false; // next file is out of the directory cluster
// read first byte of the file entry; if zero, can't read (file is NONE)
// FIXME this may be a problem when creating a new file...?
uint8_t x;
// read first byte of the file entry
dev->seek(addr);
x = dev->read();
if (x == 0)
return false;
if (dev->read() == 0)
return false; // can't read (file is NONE)
open_file(fat, file, file->clu, file->num+1);
open_file(fat, file, file->clu, file->num + 1);
return true;
}
@ -622,11 +618,7 @@ bool fat16_prev(FAT16_FILE* file)
if (file->num == 0)
return false; // first file already
open_file(file->fat, file, file->clu, file->num-1);
/* // Skip bad files
if (!fat16_is_file_valid(file))
fat16_prev(file);*/
open_file(file->fat, file, file->clu, file->num - 1);
return true;
}
@ -639,7 +631,7 @@ void fat16_first(FAT16_FILE* file)
}
/** Open a directory */
/** Open a directory denoted by the file. */
bool fat16_opendir(FAT16_FILE* file)
{
// Don't open non-dirs and "." directory.
@ -651,7 +643,7 @@ bool fat16_opendir(FAT16_FILE* file)
}
void fat16_open_root(const FAT16* fat, FAT16_FILE* file)
void fat16_root(const FAT16* fat, FAT16_FILE* file)
{
open_file(fat, file, 0, 0);
}
@ -662,104 +654,170 @@ void fat16_open_root(const FAT16* fat, FAT16_FILE* file)
* If file is found, "dir" will contain it's handle.
* Either way, "dir" gets modified and you may need to rewind it afterwards.
*/
bool fat16_find_file(FAT16_FILE* dir, const char* name)
bool fat16_find(FAT16_FILE* dir, const char* name)
{
char fname[11];
fat16_undisplay_name(name, fname);
fat16_rawname(name, fname);
return dir_contains_file_raw(dir, fname);
}
bool fat16_newfile(FAT16_FILE* dir, FAT16_FILE* file, const char* name)
/** Go through a directory, and open first NONE or DELETED file. */
bool find_empty_file_slot(FAT16_FILE* file)
{
// Convert filename to zero padded raw string
char fname[11];
fat16_undisplay_name(name, fname);
// Abort if file already exists
bool exists = dir_contains_file_raw(dir, fname);
fat16_first(dir); // rewind dir
if (exists) return false;
const uint16_t clu = file->clu;
const FAT16* fat = file->fat;
// Find free directory entry that can be used
uint16_t clu = dir->clu;
const FAT16* fat = dir->fat;
for (uint16_t num = 0; num < 0xFFFF; num++)
{
// root directory has fewer entries, error if trying
// to add one more.
if (dir->clu == 0 && num >= fat->bs.root_entries)
if (file->clu == 0 && num >= fat->bs.root_entries)
return false;
// Resolve addres of next file entry
uint32_t addr;
do {
addr = clu_offs(fat, dir->clu, num * 32);
do
{
addr = clu_offs(fat, file->clu, num * 32);
if (addr == 0xFFFF)
{
// end of chain of allocated clusters for the directory
// append new cluster, return false on failure
if (!append_cluster(fat, dir->clu)) return false;
if (!append_cluster(fat, file->clu)) return false;
}
// if new cluster was just added, repeat.
} while (addr == 0xFFFF);
}
while (addr == 0xFFFF);
// Open the file entry
open_file(fat, file, clu, num);
// Check if can be overwritten
if (file->type == FT_DELETED || file->type == FT_NONE)
{
const uint16_t newclu = alloc_cluster(fat);
const uint32_t entrystart = clu_offs(fat, clu, num * 32);
return true;
}
}
// store the file name
fat->dev->seek(entrystart);
return false; // not found.
}
// filename, without dor, zero-padded.
fat->dev->store(fname, 11);
fat->dev->write(0); // attributes
/** Write information into a file header (alloc first cluster). "file" is an open handle. */
void write_file_header(FAT16_FILE* file, const char* fname, const uint8_t attribs, const uint16_t newclu)
{
const FAT16* fat = file->fat;
const BLOCKDEV* dev = fat->dev;
// 10 reserved, 2+2 date & time
for (uint8_t i = 0; i < 14; i++)
{
fat->dev->write(0);
}
const uint32_t entrystart = clu_offs(fat, file->clu, file->num * 32);
fat->dev->write16(newclu); // starting cluster
// store the file name
dev->seek(entrystart);
dev->store(fname, 11);
// file size (uint32_t)
fat->dev->write16(0);
fat->dev->write16(0);
// attributes
dev->write(attribs);
// reopen file, load the information just written
open_file(fat, file, clu, num);
return true;
}
// 10 reserved, 2+2 date & time
// (could just skip, but better to fill with zeros)
for (uint8_t i = 0; i < 14; i++)
{
dev->write(0);
}
return false;
// addr of the first file cluster
dev->write16(newclu);
// file size (uint32_t)
dev->write16(0);
dev->write16(0);
// reopen file - load & parse the information just written
open_file(fat, file, file->clu, file->num);
}
char* fat16_volume_label(const FAT16* fat, char* str)
bool fat16_mkfile(FAT16_FILE* file, const char* name)
{
// Convert filename to zero padded raw string
char fname[11];
fat16_rawname(name, fname);
// Abort if file already exists
bool exists = dir_contains_file_raw(file, fname);
fat16_first(file); // rewind dir
if (exists)
return false; // file already exists in the dir.
if (!find_empty_file_slot(file))
return false; // error finding a slot
// Write into the new slot
const uint16_t newclu = alloc_cluster(file->fat);
write_file_header(file, fname, 0, newclu);
return true;
}
/**
* Create a sub-directory of given name.
* Directory is allocated and populated with entries "." and ".."
*/
bool fat16_mkdir(FAT16_FILE* file, const char* name)
{
// Convert filename to zero padded raw string
char fname[11];
fat16_rawname(name, fname);
// Abort if file already exists
bool exists = dir_contains_file_raw(file, fname);
fat16_first(file); // rewind dir
if (exists)
return false; // file already exusts in the dir.
if (!find_empty_file_slot(file))
return false; // error finding a slot
// Write into the new slot
const uint16_t newclu = alloc_cluster(file->fat);
write_file_header(file, fname, FA_DIR, newclu);
const uint32_t parent_clu = file->clu;
open_file(file->fat, file, file->clu_start, 0);
write_file_header(file, ". ", FA_DIR, newclu);
// Advance to next file slot
find_empty_file_slot(file);
write_file_header(file, ".. ", FA_DIR, parent_clu);
// rewind.
fat16_first(file);
return true;
}
char* fat16_disk_label(const FAT16* fat, char* label_out)
{
FAT16_FILE first;
fat16_open_root(fat, &first);
fat16_root(fat, &first);
if (first.type == FT_LABEL) {
return fat16_display_name(&first, str);
if (first.type == FT_LABEL)
{
return fat16_dispname(&first, label_out);
}
// find where spaces end
uint8_t j = 10;
int8_t j = 10;
for (; j >= 0; j--)
{
if (fat->bs.volume_label[j] != ' ') break;
@ -769,25 +827,25 @@ char* fat16_volume_label(const FAT16* fat, char* str)
uint8_t i;
for (i = 0; i <= j; i++)
{
str[i] = fat->bs.volume_label[i];
label_out[i] = fat->bs.volume_label[i];
}
str[i] = 0; // ender
label_out[i] = 0; // ender
return str;
return label_out;
}
char* fat16_display_name(const FAT16_FILE* file, char* str)
char* fat16_dispname(const FAT16_FILE* file, char* disp_out)
{
// Cannot get name for special files
if (file->type == FT_NONE || // not-yet-used directory location
file->type == FT_DELETED || // deleted file entry
file->attribs == 0x0F) // long name special entry (system, hidden)
file->type == FT_DELETED || // deleted file entry
file->attribs == 0x0F) // long name special entry (system, hidden)
return NULL;
// find first non-space
uint8_t j = 7;
int8_t j = 7;
for (; j >= 0; j--)
{
if (file->name[j] != ' ') break;
@ -798,37 +856,37 @@ char* fat16_display_name(const FAT16_FILE* file, char* str)
uint8_t i;
for (i = 0; i <= j; i++)
{
str[i] = file->name[i];
disp_out[i] = file->name[i];
}
// directory entry, no extension
if (file->type == FT_SUBDIR || file->type == FT_SELF || file->type == FT_PARENT)
{
str[i] = 0; // end of string
return str;
disp_out[i] = 0; // end of string
return disp_out;
}
// add a dot
if (file->type != FT_LABEL) // volume label has no dot!
str[i++] = '.';
disp_out[i++] = '.';
// Add extension chars
for (j = 8; j < 11; j++, i++)
{
const char c = file->name[j];
if (c == ' ') break;
str[i] = c;
disp_out[i] = c;
}
str[i] = 0; // end of string
disp_out[i] = 0; // end of string
return str;
return disp_out;
}
char* fat16_undisplay_name(const char* name, char* fixed)
char* fat16_rawname(const char* disp_in, char* raw_out)
{
uint8_t name_c = 0, wr_c = 0;
bool filling = false;
@ -836,9 +894,10 @@ char* fat16_undisplay_name(const char* name, char* fixed)
for (; wr_c < 11; wr_c++)
{
// start filling with spaces if end of filename reached
char c = name[name_c];
uint8_t c = disp_in[name_c];
// handle special rule for 0xE5
if (name_c == 0 && c == 0xE5) {
if (name_c == 0 && c == 0xE5)
{
c = 0x05;
}
@ -851,7 +910,7 @@ char* fat16_undisplay_name(const char* name, char* fixed)
if (c == '.')
{
name_c++; // skip the dot
c = name[name_c];
c = disp_in[name_c];
at_ext = true;
}
}
@ -863,13 +922,14 @@ char* fat16_undisplay_name(const char* name, char* fixed)
if (!at_ext)
{
// try to advance past dot (if any)
while(true)
while (true)
{
c = name[name_c++];
c = disp_in[name_c++];
if (c == 0) break;
if (c == '.') {
if (c == '.')
{
// read char PAST the dot
c = name[name_c];
c = disp_in[name_c];
at_ext = true;
break;
}
@ -887,21 +947,21 @@ char* fat16_undisplay_name(const char* name, char* fixed)
if (!filling)
{
// copy char of filename
fixed[wr_c] = name[name_c++];
raw_out[wr_c] = disp_in[name_c++];
}
else
{
// add a filler space
fixed[wr_c] = ' ';
raw_out[wr_c] = ' ';
}
}
return fixed;
return raw_out;
}
/** Write new file size (also to the disk). Does not allocate clusters. */
void fat16_set_file_size(FAT16_FILE* file, uint32_t size)
void fat16_resize(FAT16_FILE* file, uint32_t size)
{
const FAT16* fat = file->fat;
const BLOCKDEV* dev = file->fat->dev;
@ -919,8 +979,6 @@ void fat16_set_file_size(FAT16_FILE* file, uint32_t size)
const uint16_t next = next_clu(fat, file->cur_clu);
if (next != 0xFFFF)
{
printf("Trimming file clusters\n");
free_cluster_chain(fat, next);
// Mark that there's no further clusters
@ -929,7 +987,7 @@ void fat16_set_file_size(FAT16_FILE* file, uint32_t size)
}
void fat16_delete_file(FAT16_FILE* file)
void fat16_delete(FAT16_FILE* file)
{
const FAT16* fat = file->fat;

71
fat16.h

@ -1,7 +1,8 @@
#pragma once
/** Abstract block device interface */
typedef struct {
typedef struct
{
// Sequential read
void (*load)(void* dest, const uint16_t len);
// Sequential write
@ -24,7 +25,8 @@ typedef struct {
// -------------------------------
/** file types (values don't matter) */
typedef enum {
typedef enum
{
FT_NONE = '-',
FT_DELETED = 'x',
FT_SUBDIR = 'D',
@ -46,7 +48,8 @@ typedef enum {
/** Boot Sector structure - INTERNAL! */
typedef struct __attribute__((packed)) {
typedef struct __attribute__((packed))
{
// Fields loaded directly from disk:
@ -66,11 +69,13 @@ typedef struct __attribute__((packed)) {
uint32_t bytes_per_cluster;
} Fat16BootSector;
}
Fat16BootSector;
/** FAT filesystem handle - private fields! */
typedef struct __attribute__((packed)) {
typedef struct __attribute__((packed))
{
// Backing block device
const BLOCKDEV* dev;
@ -85,12 +90,13 @@ typedef struct __attribute__((packed)) {
// Boot sector data struct
Fat16BootSector bs;
} FAT16;
}
FAT16;
/** File handle struct */
typedef struct __attribute__((packed)) {
typedef struct __attribute__((packed))
{
// Fields loaded directly from disk:
uint8_t name[11]; // Starting 0x05 converted to 0xE5, other "magic chars" left intact
@ -117,12 +123,14 @@ typedef struct __attribute__((packed)) {
// pointer to FAT
const FAT16* fat;
} FAT16_FILE;
}
FAT16_FILE;
/** Initialize a filesystem */
void fat16_init(const BLOCKDEV* dev, FAT16* fat);
/**
* Open the first file of the root directory.
* The file may be invalid (eg. a volume label, deleted etc),
@ -130,12 +138,13 @@ void fat16_init(const BLOCKDEV* dev, FAT16* fat);
*
* Either way, the prev and next functions will work as expected.
*/
void fat16_open_root(const FAT16* fat, FAT16_FILE* file);
void fat16_root(const FAT16* fat, FAT16_FILE* file);
/**
* Resolve volume label.
* Resolve the disk label.
*/
char* fat16_volume_label(const FAT16* fat, char* str);
char* fat16_disk_label(const FAT16* fat, char* label_out);
// ----------- FILE I/O -------------
@ -154,29 +163,39 @@ bool fat16_fseek(FAT16_FILE* file, uint32_t addr);
*/
bool fat16_fread(FAT16_FILE* file, void* target, uint32_t len);
/**
* Write into file at a "seek" position.
* "seek" cursor must be within (0..filesize)
*/
bool fat16_fwrite(FAT16_FILE* file, void* src, uint32_t len);
bool fat16_fwrite(FAT16_FILE* file, void* source, uint32_t len);
/**
* Create a new file in given folder
*
* directory ... parent folder's first entry
* file ... where to store info about newly opened file
* file ... open directory; new file is opened into this handle.
* name ... name of the new file, including extension
*/
bool fat16_newfile(FAT16_FILE* directory, FAT16_FILE* file, const char* name);
bool fat16_mkfile(FAT16_FILE* file, const char* name);
/**
* Create a sub-directory of given name.
* Directory is allocated and populated with entries "." and ".."
*/
bool fat16_mkdir(FAT16_FILE* file, const char* name);
/**
* Write new file size (also to the disk).
* Allocates / frees needed clusters, does not erase them.
*/
void fat16_set_file_size(FAT16_FILE* file, uint32_t size);
void fat16_resize(FAT16_FILE* file, uint32_t size);
/** Delete a file entry and free clusters. Does NOT descend into subdirectories. */
void fat16_delete_file(FAT16_FILE* file);
void fat16_delete(FAT16_FILE* file);
// --------- NAVIGATION ------------
@ -184,21 +203,28 @@ void fat16_delete_file(FAT16_FILE* file);
/** Go to previous file in the directory (false = no prev file) */
bool fat16_prev(FAT16_FILE* file);
/** Go to next file in directory (false = no next file) */
bool fat16_next(FAT16_FILE* file);
/** Open a directory (file is a directory entry) */
/**
* Open a subdirectory denoted by the file.
* Provided handle changes to first entry of the directory.
*/
bool fat16_opendir(FAT16_FILE* file);
/** Rewind to first file in directory */
void fat16_first(FAT16_FILE* file);
/**
* Find a file with given "display name" in this directory.
* If file is found, "dir" will contain it's handle.
* Either way, "dir" gets modified and you may need to rewind it afterwards.
*/
bool fat16_find_file(FAT16_FILE* dir, const char* name);
bool fat16_find(FAT16_FILE* dir, const char* name);
// -------- FILE INSPECTION -----------
@ -211,11 +237,12 @@ bool fat16_is_file_valid(const FAT16_FILE* file);
* Resolve a file name, trim spaces and add null terminator.
* Returns the passed char*, or NULL on error.
*/
char* fat16_display_name(const FAT16_FILE* file, char* str);
char* fat16_dispname(const FAT16_FILE* file, char* disp_out);
/**
* Convert filename to zero-padded fixed length one
* Returns the passed char*.
*/
char* fat16_undisplay_name(const char* name, char* fixed);
char* fat16_rawname(const char* disp_in, char* raw_out);

59
main.c

@ -90,12 +90,8 @@ void test_close()
// --- testing ---
int main(int argc, char const *argv[])
int main()
{
uint32_t i32;
uint16_t i16;
uint8_t i8;
test_open();
// Initialize the FS
@ -103,22 +99,57 @@ int main(int argc, char const *argv[])
fat16_init(&test, &fat);
FAT16_FILE file;
fat16_open_root(&fat, &file);
fat16_root(&fat, &file);
char str[12];
printf("Disk label: %s\n", fat16_volume_label(&fat, str));
printf("Disk label: %s\n", fat16_disk_label(&fat, str));
do {
do
{
if (!fat16_is_file_valid(&file)) continue;
printf("File name: %s, %c, %d B, @ 0x%x\n",
fat16_display_name(&file, str),
file.type, file.size, file.clu_start);
} while (fat16_next(&file));
fat16_open_root(&fat, &file);
fat16_dispname(&file, str),
file.type, file.size, file.clu_start);
}
while (fat16_next(&file));
fat16_root(&fat, &file);
if (fat16_find(&file, "FOLDER"))
{
if (fat16_opendir(&file))
{
printf("Listing FOLDER:\n");
do
{
printf("File name: %s, %c, %d B, @ 0x%x\n",
fat16_dispname(&file, str),
file.type, file.size, file.clu_start);
}
while (fat16_next(&file));
if (fat16_find(&file, "banana.exe"))
{
char m[49];
fat16_fread(&file, m, 49);
printf("%.49s\n", m);
}
}
}
//fat16_mkfile(&file, "banana.exe");
//fat16_fwrite(&file, "THIS IS A STRING STORED IN A FILE CALLED BANANA!\n", 49);
// fat16_find(&file, "banana.exe");
// char m[49];
// fat16_fread(&file, m, 49);
// printf("%.49s\n", m);
//fat16_mkdir(&file, "FOLDER2");
// bool found = fat16_find_file(&file, "NEW_FILE.DAT");
//

BIN
test

Binary file not shown.
Loading…
Cancel
Save