FAT support

Collaboration diagram for FAT support:

Files
file	fat.c
file	fat.h
file	fat_config.h
Modules
	FAT configuration
	FAT access
	FAT file functions
	FAT directory functions
Data Structures
struct	fat_dir_entry_struct
Defines
#define	fat_delete_dir   fat_delete_file
Functions
struct fat_fs_struct *	fat_open (struct partition_struct *partition)
void	fat_close (struct fat_fs_struct *fs)
struct fat_file_struct *	fat_open_file (struct fat_fs_struct *fs, const struct fat_dir_entry_struct *dir_entry)
void	fat_close_file (struct fat_file_struct *fd)
intptr_t	fat_read_file (struct fat_file_struct *fd, uint8_t *buffer, uintptr_t buffer_len)
intptr_t	fat_write_file (struct fat_file_struct *fd, const uint8_t *buffer, uintptr_t buffer_len)
uint8_t	fat_seek_file (struct fat_file_struct *fd, int32_t *offset, uint8_t whence)
uint8_t	fat_resize_file (struct fat_file_struct *fd, uint32_t size)
struct fat_dir_struct *	fat_open_dir (struct fat_fs_struct *fs, const struct fat_dir_entry_struct *dir_entry)
void	fat_close_dir (struct fat_dir_struct *dd)
uint8_t	fat_read_dir (struct fat_dir_struct *dd, struct fat_dir_entry_struct *dir_entry)
uint8_t	fat_reset_dir (struct fat_dir_struct *dd)
uint8_t	fat_create_file (struct fat_dir_struct *parent, const char *file, struct fat_dir_entry_struct *dir_entry)
uint8_t	fat_delete_file (struct fat_fs_struct *fs, struct fat_dir_entry_struct *dir_entry)
uint8_t	fat_create_dir (struct fat_dir_struct *parent, const char *dir, struct fat_dir_entry_struct *dir_entry)
void	fat_get_file_modification_date (const struct fat_dir_entry_struct *dir_entry, uint16_t *year, uint8_t *month, uint8_t *day)
void	fat_get_file_modification_time (const struct fat_dir_entry_struct *dir_entry, uint8_t *hour, uint8_t *min, uint8_t *sec)
uint8_t	fat_get_dir_entry_of_path (struct fat_fs_struct *fs, const char *path, struct fat_dir_entry_struct *dir_entry)
offset_t	fat_get_fs_size (const struct fat_fs_struct *fs)
offset_t	fat_get_fs_free (const struct fat_fs_struct *fs)
void	get_datetime (uint16_t *year, uint8_t *month, uint8_t *day, uint8_t *hour, uint8_t *min, uint8_t *sec)

---

Detailed Description

This module implements FAT16/FAT32 read and write access.

The following features are supported:

• File names up to 31 characters long.
• Unlimited depth of subdirectories.
• Short 8.3 and long filenames.
• Creating and deleting files.
• Reading and writing from and to files.
• File resizing.
• File sizes of up to 4 gigabytes.

---

Define Documentation

#define fat_delete_dir   fat_delete_file

Definition at line 110 of file fat.h.

---

Function Documentation

void fat_close

(

struct fat_fs_struct *

fs

)

Closes a FAT filesystem.

When this function returns, the given filesystem descriptor will be invalid.

Parameters:

[in]

fs

The filesystem to close.

See also:

fat_open

Definition at line 291 of file fat.c.

References fat_fs_struct::partition.

Referenced by WaspSD::close().

{
    if(!fs)
        return;

#if USE_DYNAMIC_MEMORY
    free(fs);
#else
    fs->partition = 0;
#endif
}

Here is the caller graph for this function:

void fat_close_dir

(

struct fat_dir_struct *

dd

)

Closes a directory descriptor.

This function destroys a directory descriptor which was previously obtained by calling fat_open_dir(). When this function returns, the given descriptor will be invalid.

Parameters:

[in]

dd

The directory descriptor to close.

See also:

fat_open_dir

Definition at line 1418 of file fat.c.

References fat_dir_struct::fs.

Referenced by WaspSD::cd(), WaspSD::close(), and fat_get_dir_entry_of_path().

{
    if(dd)
#if USE_DYNAMIC_MEMORY
        free(dd);
#else
        dd->fs = 0;
#endif
}

Here is the caller graph for this function:

void fat_close_file

(

struct fat_file_struct *

fd

)

Closes a file.

Parameters:

[in]

fd

The file handle of the file to close.

See also:

fat_open_file

Definition at line 964 of file fat.c.

References fat_file_struct::dir_entry, fat_write_dir_entry(), and fat_file_struct::fs.

Referenced by WaspSD::cat(), WaspSD::catBin(), WaspSD::catln(), WaspSD::closeFile(), WaspSD::indexOf(), WaspSD::numln(), and WaspSD::writeSD().

{
    if(fd)
    {
#if FAT_DELAY_DIRENTRY_UPDATE
        /* write directory entry */
        fat_write_dir_entry(fd->fs, &fd->dir_entry);
#endif

#if USE_DYNAMIC_MEMORY
        free(fd);
#else
        fd->fs = 0;
#endif
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t fat_create_dir	(	struct fat_dir_struct *	parent,
		const char *	dir,
		struct fat_dir_entry_struct *	dir_entry
	)

Creates a directory.

Creates a directory and obtains its directory entry. If the directory to create already exists, its directory entry will be returned within the dir_entry parameter.

Note:

The notes which apply to fat_create_file also apply to this function.

Parameters:

[in]	parent	The handle of the parent directory of the new directory.
[in]	dir	The name of the directory to create.
[out]	dir_entry	The directory entry to fill for the new directory.

Returns:

0 on failure, 1 on success.

See also:

fat_delete_dir

Definition at line 2170 of file fat.c.

References fat_dir_entry_struct::attributes, fat_dir_entry_struct::cluster, fat_header_struct::cluster_size, fat_header_struct::cluster_zero_offset, fat_dir_struct::dir_entry, fat_dir_entry_struct::entry_offset, fat_append_clusters(), FAT_ATTRIB_DIR, fat_clear_cluster(), fat_find_offset_for_dir_entry(), fat_free_clusters(), fat_read_dir(), fat_reset_dir(), fat_write_dir_entry(), fat_dir_struct::fs, fat_fs_struct::header, and fat_dir_entry_struct::long_name.

Referenced by WaspSD::mkdir().

{
    if(!parent || !dir || !dir[0] || !dir_entry)
        return 0;

    /* check if the file or directory already exists */
    while(fat_read_dir(parent, dir_entry))
    {
        if(strcmp(dir, dir_entry->long_name) == 0)
        {
            fat_reset_dir(parent);
            return 0;
        }
    }

    struct fat_fs_struct* fs = parent->fs;

    /* allocate cluster which will hold directory entries */
    cluster_t dir_cluster = fat_append_clusters(fs, 0, 1);
    if(!dir_cluster)
        return 0;

    /* clear cluster to prevent bogus directory entries */
    fat_clear_cluster(fs, dir_cluster);
    
    memset(dir_entry, 0, sizeof(*dir_entry));
    dir_entry->attributes = FAT_ATTRIB_DIR;

    /* create "." directory self reference */
    dir_entry->entry_offset = fs->header.cluster_zero_offset +
                              (offset_t) (dir_cluster - 2) * fs->header.cluster_size;
    dir_entry->long_name[0] = '.';
    dir_entry->cluster = dir_cluster;
    if(!fat_write_dir_entry(fs, dir_entry))
    {
        fat_free_clusters(fs, dir_cluster);
        return 0;
    }

    /* create ".." parent directory reference */
    dir_entry->entry_offset += 32;
    dir_entry->long_name[1] = '.';
    dir_entry->cluster = parent->dir_entry.cluster;
    if(!fat_write_dir_entry(fs, dir_entry))
    {
        fat_free_clusters(fs, dir_cluster);
        return 0;
    }

    /* fill directory entry */
    strncpy(dir_entry->long_name, dir, sizeof(dir_entry->long_name) - 1);
    dir_entry->cluster = dir_cluster;

    /* find place where to store directory entry */
    if(!(dir_entry->entry_offset = fat_find_offset_for_dir_entry(fs, parent, dir_entry)))
    {
        fat_free_clusters(fs, dir_cluster);
        return 0;
    }

    /* write directory to disk */
    if(!fat_write_dir_entry(fs, dir_entry))
    {
        fat_free_clusters(fs, dir_cluster);
        return 0;
    }

    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t fat_create_file	(	struct fat_dir_struct *	parent,
		const char *	file,
		struct fat_dir_entry_struct *	dir_entry
	)

Creates a file.

Creates a file and obtains the directory entry of the new file. If the file to create already exists, the directory entry of the existing file will be returned within the dir_entry parameter.

Note:

The file name is not checked for invalid characters.

The generation of the short 8.3 file name is quite simple. The first eight characters are used for the filename. The extension, if any, is made up of the first three characters following the last dot within the long filename. If the filename (without the extension) is longer than eight characters, the lower byte of the cluster number replaces the last two characters to avoid name clashes. In any other case, it is your responsibility to avoid name clashes.

Parameters:

[in]	parent	The handle of the directory in which to create the file.
[in]	file	The name of the file to create.
[out]	dir_entry	The directory entry to fill for the new file.

Returns:

0 on failure, 1 on success.

See also:

fat_delete_file

Definition at line 2055 of file fat.c.

References fat_dir_entry_struct::entry_offset, fat_find_offset_for_dir_entry(), fat_read_dir(), fat_reset_dir(), fat_write_dir_entry(), fat_dir_struct::fs, and fat_dir_entry_struct::long_name.

Referenced by WaspSD::create().

{
    if(!parent || !file || !file[0] || !dir_entry)
        return 0;

    /* check if the file already exists */
    while(1)
    {
        if(!fat_read_dir(parent, dir_entry))
            break;

        if(strcmp(file, dir_entry->long_name) == 0)
        {
            fat_reset_dir(parent);
            return 0;
        }
    }

    struct fat_fs_struct* fs = parent->fs;

    /* prepare directory entry with values already known */
    memset(dir_entry, 0, sizeof(*dir_entry));
    strncpy(dir_entry->long_name, file, sizeof(dir_entry->long_name) - 1);

    /* find place where to store directory entry */
    if(!(dir_entry->entry_offset = fat_find_offset_for_dir_entry(fs, parent, dir_entry)))
        return 0;
    
    /* write directory entry to disk */
    if(!fat_write_dir_entry(fs, dir_entry))
        return 0;
    
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t fat_delete_file	(	struct fat_fs_struct *	fs,
		struct fat_dir_entry_struct *	dir_entry
	)

Deletes a file or directory.

If a directory is deleted without first deleting its subdirectories and files, disk space occupied by these files will get wasted as there is no chance to release it and mark it as free.

Parameters:

[in]	fs	The filesystem on which to operate.
[in]	dir_entry	The directory entry of the file to delete.

Returns:

0 on failure, 1 on success.

See also:

fat_create_file

Definition at line 2106 of file fat.c.

References fat_dir_entry_struct::cluster, partition_struct::device_read, partition_struct::device_write, fat_dir_entry_struct::entry_offset, FAT_DIRENTRY_DELETED, fat_free_clusters(), and fat_fs_struct::partition.

Referenced by WaspSD::delDir(), and WaspSD::delFile().

{
    if(!fs || !dir_entry)
        return 0;

    /* get offset of the file's directory entry */
    offset_t dir_entry_offset = dir_entry->entry_offset;
    if(!dir_entry_offset)
        return 0;

#if FAT_LFN_SUPPORT
    uint8_t buffer[12];
    while(1)
    {
        /* read directory entry */
        if(!fs->partition->device_read(dir_entry_offset, buffer, sizeof(buffer)))
            return 0;
        
        /* mark the directory entry as deleted */
        buffer[0] = FAT_DIRENTRY_DELETED;
        
        /* write back entry */
        if(!fs->partition->device_write(dir_entry_offset, buffer, sizeof(buffer)))
            return 0;

        /* check if we deleted the whole entry */
        if(buffer[11] != 0x0f)
            break;

        dir_entry_offset += 32;
    }
#else
    /* mark the directory entry as deleted */
    uint8_t first_char = FAT_DIRENTRY_DELETED;
    if(!fs->partition->device_write(dir_entry_offset, &first_char, 1))
        return 0;
#endif

    /* We deleted the directory entry. The next thing to do is
     * marking all occupied clusters as free.
     */
    return (dir_entry->cluster == 0 || fat_free_clusters(fs, dir_entry->cluster));
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t fat_get_dir_entry_of_path	(	struct fat_fs_struct *	fs,
		const char *	path,
		struct fat_dir_entry_struct *	dir_entry
	)

Retrieves the directory entry of a path.

The given path may both describe a file or a directory.

Parameters:

[in]	fs	The FAT filesystem on which to search.
[in]	path	The path of which to read the directory entry.
[out]	dir_entry	The directory entry to fill.

Returns:

0 on failure, 1 on success.

See also:

fat_read_dir

Definition at line 850 of file fat.c.

References fat_dir_entry_struct::attributes, FAT_ATTRIB_DIR, fat_close_dir(), fat_open_dir(), fat_read_dir(), and fat_dir_entry_struct::long_name.

Referenced by WaspSD::init().

{
    if(!fs || !path || path[0] == '\0' || !dir_entry)
        return 0;

    if(path[0] == '/')
        ++path;

    /* begin with the root directory */
    memset(dir_entry, 0, sizeof(*dir_entry));
    dir_entry->attributes = FAT_ATTRIB_DIR;

    while(1)
    {
        if(path[0] == '\0')
            return 1;

        struct fat_dir_struct* dd = fat_open_dir(fs, dir_entry);
        if(!dd)
            break;

        /* extract the next hierarchy we will search for */
        const char* sub_path = strchr(path, '/');
        uint8_t length_to_sep;
        if(sub_path)
        {
            length_to_sep = sub_path - path;
            ++sub_path;
        }
        else
        {
            length_to_sep = strlen(path);
            sub_path = path + length_to_sep;
        }
        
        /* read directory entries */
        while(fat_read_dir(dd, dir_entry))
        {
            /* check if we have found the next hierarchy */
            if((strlen(dir_entry->long_name) != length_to_sep ||
                strncmp(path, dir_entry->long_name, length_to_sep) != 0))
                continue;

            fat_close_dir(dd);
            dd = 0;

            if(path[length_to_sep] == '\0')
                /* we iterated through the whole path and have found the file */
                return 1;

            if(dir_entry->attributes & FAT_ATTRIB_DIR)
            {
                /* we found a parent directory of the file we are searching for */
                path = sub_path;
                break;
            }

            /* a parent of the file exists, but not the file itself */
            return 0;
        }

        fat_close_dir(dd);
    }
    
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void fat_get_file_modification_date	(	const struct fat_dir_entry_struct *	dir_entry,
		uint16_t *	year,
		uint8_t *	month,
		uint8_t *	day
	)

void fat_get_file_modification_time	(	const struct fat_dir_entry_struct *	dir_entry,
		uint8_t *	hour,
		uint8_t *	min,
		uint8_t *	sec
	)

offset_t fat_get_fs_free

(

const struct fat_fs_struct *

fs

)

Returns the amount of free storage capacity on the filesystem in bytes.

Note:

As the FAT filesystem is cluster based, this function does not return continuous values but multiples of the cluster size.

Parameters:

[in]

fs

The filesystem on which to operate.

Returns:

0 on failure, the free filesystem space in bytes otherwise.

Definition at line 2376 of file fat.c.

References fat_usage_count_callback_arg::buffer_size, fat_usage_count_callback_arg::cluster_count, fat_header_struct::cluster_size, partition_struct::device_read_interval, FAT_FAT32_SUPPORT, fat_get_fs_free_16_callback(), fat_header_struct::fat_offset, fat_header_struct::fat_size, fat_fs_struct::header, fat_fs_struct::partition, PARTITION_TYPE_FAT16, and partition_struct::type.

Referenced by WaspSD::getDiskFree(), and WaspSD::print_disk_info().

{
    if(!fs)
        return 0;

    uint8_t fat[32];
    struct fat_usage_count_callback_arg count_arg;
    count_arg.cluster_count = 0;
    count_arg.buffer_size = sizeof(fat);

    offset_t fat_offset = fs->header.fat_offset;
    uint32_t fat_size = fs->header.fat_size;
    while(fat_size > 0)
    {
        uintptr_t length = UINTPTR_MAX - 1;
        if(fat_size < length)
            length = fat_size;

        if(!fs->partition->device_read_interval(fat_offset,
                                                fat,
                                                sizeof(fat),
                                                length,
#if FAT_FAT32_SUPPORT
                                                (fs->partition->type == PARTITION_TYPE_FAT16) ?
                                                    fat_get_fs_free_16_callback :
                                                    fat_get_fs_free_32_callback,
#else
                                                fat_get_fs_free_16_callback,
#endif
                                                &count_arg
                                               )
          )
            return 0;

        fat_offset += length;
        fat_size -= length;
    }

    return (offset_t) count_arg.cluster_count * fs->header.cluster_size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

offset_t fat_get_fs_size

(

const struct fat_fs_struct *

fs

)

Deletes a directory.

This is just a synonym for fat_delete_file(). If a directory is deleted without first deleting its subdirectories and files, disk space occupied by these files will get wasted as there is no chance to release it and mark it as free.

Parameters:

[in]	fs	The filesystem on which to operate.
[in]	dir_entry	The directory entry of the directory to delete.

Returns:

0 on failure, 1 on success.

See also:

fat_create_dir

Returns the amount of total storage capacity of the filesystem in bytes.

Parameters:

[in]

fs

The filesystem on which to operate.

Returns:

0 on failure, the filesystem size in bytes otherwise.

Definition at line 2353 of file fat.c.

References fat_header_struct::cluster_size, fat_header_struct::fat_size, fat_fs_struct::header, fat_fs_struct::partition, PARTITION_TYPE_FAT32, and partition_struct::type.

Referenced by WaspSD::getDiskSize(), and WaspSD::print_disk_info().

{
    if(!fs)
        return 0;

#if FAT_FAT32_SUPPORT
    if(fs->partition->type == PARTITION_TYPE_FAT32)
        return (offset_t) (fs->header.fat_size / 4 - 2) * fs->header.cluster_size;
    else
#endif
        return (offset_t) (fs->header.fat_size / 2 - 2) * fs->header.cluster_size;
}

Here is the caller graph for this function:

struct fat_fs_struct* fat_open

(

struct partition_struct *

partition

)

[read]

Opens a FAT filesystem.

Parameters:

[in]

partition

Discriptor of partition on which the filesystem resides.

Returns:

0 on error, a FAT filesystem descriptor on success.

See also:

fat_close

Definition at line 235 of file fat.c.

References partition_struct::device_write, partition_struct::device_write_interval, FAT_FS_COUNT, fat_fs_handles, fat_read_header(), FAT_WRITE_SUPPORT, and fat_fs_struct::partition.

Referenced by WaspSD::init().

{
    if(!partition ||
#if FAT_WRITE_SUPPORT
       !partition->device_write ||
       !partition->device_write_interval
#else
       0
#endif
      )
        return 0;

#if USE_DYNAMIC_MEMORY
    struct fat_fs_struct* fs = malloc(sizeof(*fs));
    if(!fs)
        return 0;
#else
    struct fat_fs_struct* fs = fat_fs_handles;
    uint8_t i;
    for(i = 0; i < FAT_FS_COUNT; ++i)
    {
        if(!fs->partition)
            break;

        ++fs;
    }
    if(i >= FAT_FS_COUNT)
        return 0;
#endif

    memset(fs, 0, sizeof(*fs));

    fs->partition = partition;
    if(!fat_read_header(fs))
    {
#if USE_DYNAMIC_MEMORY
        free(fs);
#else
        fs->partition = 0;
#endif
        return 0;
    }
    
    return fs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct fat_dir_struct* fat_open_dir	(	struct fat_fs_struct *	fs,
		const struct fat_dir_entry_struct *	dir_entry
	)			[read]

Opens a directory.

Parameters:

[in]	fs	The filesystem on which the directory to open resides.
[in]	dir_entry	The directory entry which stands for the directory to open.

Returns:

An opaque directory descriptor on success, 0 on failure.

See also:

fat_close_dir

Definition at line 1376 of file fat.c.

References fat_dir_entry_struct::attributes, fat_dir_entry_struct::cluster, fat_dir_struct::dir_entry, fat_dir_struct::entry_cluster, fat_dir_struct::entry_offset, FAT_ATTRIB_DIR, FAT_DIR_COUNT, fat_dir_handles, and fat_dir_struct::fs.

Referenced by WaspSD::cd(), fat_get_dir_entry_of_path(), and WaspSD::init().

{
    if(!fs || !dir_entry || !(dir_entry->attributes & FAT_ATTRIB_DIR))
        return 0;

#if USE_DYNAMIC_MEMORY
    struct fat_dir_struct* dd = malloc(sizeof(*dd));
    if(!dd)
        return 0;
#else
    struct fat_dir_struct* dd = fat_dir_handles;
    uint8_t i;
    for(i = 0; i < FAT_DIR_COUNT; ++i)
    {
        if(!dd->fs)
            break;

        ++dd;
    }
    if(i >= FAT_DIR_COUNT)
        return 0;
#endif
    
    memcpy(&dd->dir_entry, dir_entry, sizeof(*dir_entry));
    dd->fs = fs;
    dd->entry_cluster = dir_entry->cluster;
    dd->entry_offset = 0;

    return dd;
}

Here is the caller graph for this function:

struct fat_file_struct* fat_open_file	(	struct fat_fs_struct *	fs,
		const struct fat_dir_entry_struct *	dir_entry
	)			[read]

Opens a file on a FAT filesystem.

Parameters:

[in]	fs	The filesystem on which the file to open lies.
[in]	dir_entry	The directory entry of the file to open.

Returns:

The file handle, or 0 on failure.

See also:

fat_close_file

Definition at line 926 of file fat.c.

References fat_dir_entry_struct::attributes, fat_dir_entry_struct::cluster, fat_file_struct::dir_entry, FAT_ATTRIB_DIR, FAT_FILE_COUNT, fat_file_handles, fat_file_struct::fs, fat_file_struct::pos, and fat_file_struct::pos_cluster.

Referenced by WaspSD::openFile().

{
    if(!fs || !dir_entry || (dir_entry->attributes & FAT_ATTRIB_DIR))
        return 0;

#if USE_DYNAMIC_MEMORY
    struct fat_file_struct* fd = malloc(sizeof(*fd));
    if(!fd)
        return 0;
#else
    struct fat_file_struct* fd = fat_file_handles;
    uint8_t i;
    for(i = 0; i < FAT_FILE_COUNT; ++i)
    {
        if(!fd->fs)
            break;

        ++fd;
    }
    if(i >= FAT_FILE_COUNT)
        return 0;
#endif
    
    memcpy(&fd->dir_entry, dir_entry, sizeof(*dir_entry));
    fd->fs = fs;
    fd->pos = 0;
    fd->pos_cluster = dir_entry->cluster;

    return fd;
}

Here is the caller graph for this function:

uint8_t fat_read_dir	(	struct fat_dir_struct *	dd,
		struct fat_dir_entry_struct *	dir_entry
	)

Reads the next directory entry contained within a parent directory.

Parameters:

[in]	dd	The descriptor of the parent directory from which to read the entry.
[out]	dir_entry	Pointer to a buffer into which to write the directory entry information.

Returns:

0 on failure, 1 on success.

See also:

fat_reset_dir

Definition at line 1437 of file fat.c.

References fat_read_dir_callback_arg::bytes_read, fat_header_struct::cluster_size, fat_header_struct::cluster_zero_offset, partition_struct::device_read_interval, fat_read_dir_callback_arg::dir_entry, fat_dir_struct::entry_cluster, fat_dir_struct::entry_offset, fat_cluster_offset(), fat_dir_entry_read_callback(), fat_get_next_cluster(), fat_reset_dir(), fat_read_dir_callback_arg::finished, fat_dir_struct::fs, fat_fs_struct::header, fat_fs_struct::partition, PARTITION_TYPE_FAT32, fat_header_struct::root_dir_offset, and partition_struct::type.

Referenced by WaspSD::delDir(), fat_create_dir(), fat_create_file(), fat_get_dir_entry_of_path(), WaspSD::find_file_in_dir(), WaspSD::ls(), and WaspSD::numFiles().

{
    if(!dd || !dir_entry)
        return 0;

    /* get current position of directory handle */
    struct fat_fs_struct* fs = dd->fs;
    const struct fat_header_struct* header = &fs->header;
    uint16_t cluster_size = header->cluster_size;
    cluster_t cluster_num = dd->entry_cluster;
    uint16_t cluster_offset = dd->entry_offset;
    struct fat_read_dir_callback_arg arg;

    if(cluster_offset >= cluster_size)
    {
        /* The latest call hit the border of the last cluster in
         * the chain, but it still returned a directory entry.
         * So we now reset the handle and signal the caller the
         * end of the listing.
         */
        fat_reset_dir(dd);
        return 0;
    }

    /* reset callback arguments */
    memset(&arg, 0, sizeof(arg));
    memset(dir_entry, 0, sizeof(*dir_entry));
    arg.dir_entry = dir_entry;

    /* check if we read from the root directory */
    if(cluster_num == 0)
    {
#if FAT_FAT32_SUPPORT
        if(fs->partition->type == PARTITION_TYPE_FAT32)
            cluster_num = header->root_dir_cluster;
        else
#endif
            cluster_size = header->cluster_zero_offset - header->root_dir_offset;
    }

    /* read entries */
    uint8_t buffer[32];
    while(!arg.finished)
    {
        /* read directory entries up to the cluster border */
        uint16_t cluster_left = cluster_size - cluster_offset;
        offset_t pos = cluster_offset;
        if(cluster_num == 0)
            pos += header->root_dir_offset;
        else
            pos += fat_cluster_offset(fs, cluster_num);

        arg.bytes_read = 0;
        if(!fs->partition->device_read_interval(pos,
                                                buffer,
                                                sizeof(buffer),
                                                cluster_left,
                                                fat_dir_entry_read_callback,
                                                &arg)
          )
            return 0;

        cluster_offset += arg.bytes_read;

        if(cluster_offset >= cluster_size)
        {
            /* we reached the cluster border and switch to the next cluster */

            /* get number of next cluster */
            if((cluster_num = fat_get_next_cluster(fs, cluster_num)) != 0)
            {
                cluster_offset = 0;
                continue;
            }

            /* we are at the end of the cluster chain */
            if(!arg.finished)
            {
                /* directory entry not found, reset directory handle */
                fat_reset_dir(dd);
                return 0;
            }
            else
            {
                /* The current execution of the function has been successful,
                 * so we can not signal an end of the directory listing to
                 * the caller, but must wait for the next call. So we keep an
                 * invalid cluster offset to mark this directory handle's
                 * traversal as finished.
                 */
            }

            break;
        }
    }

    dd->entry_cluster = cluster_num;
    dd->entry_offset = cluster_offset;

    return arg.finished;
}

Here is the call graph for this function:

Here is the caller graph for this function:

intptr_t fat_read_file	(	struct fat_file_struct *	fd,
		uint8_t *	buffer,
		uintptr_t	buffer_len
	)

Reads data from a file.

The data requested is read from the current file location.

Parameters:

[in]	fd	The file handle of the file from which to read.
[out]	buffer	The buffer into which to write.
[in]	buffer_len	The amount of data to read.

Returns:

The number of bytes read, 0 on end of file, or -1 on failure.

See also:

fat_write_file

Definition at line 993 of file fat.c.

References fat_dir_entry_struct::cluster, fat_header_struct::cluster_size, partition_struct::device_read, fat_file_struct::dir_entry, fat_cluster_offset(), fat_get_next_cluster(), fat_dir_entry_struct::file_size, fat_file_struct::fs, fat_fs_struct::header, fat_fs_struct::partition, fat_file_struct::pos, and fat_file_struct::pos_cluster.

Referenced by WaspSD::cat(), WaspSD::catBin(), WaspSD::catln(), WaspSD::indexOf(), and WaspSD::numln().

{
    /* check arguments */
    if(!fd || !buffer || buffer_len < 1)
        return -1;

    /* determine number of bytes to read */
    if(fd->pos + buffer_len > fd->dir_entry.file_size)
        buffer_len = fd->dir_entry.file_size - fd->pos;
    if(buffer_len == 0)
        return 0;
    
    uint16_t cluster_size = fd->fs->header.cluster_size;
    cluster_t cluster_num = fd->pos_cluster;
    uintptr_t buffer_left = buffer_len;
    uint16_t first_cluster_offset = (uint16_t) (fd->pos & (cluster_size - 1));

    /* find cluster in which to start reading */
    if(!cluster_num)
    {
        cluster_num = fd->dir_entry.cluster;
        
        if(!cluster_num)
        {
            if(!fd->pos)
                return 0;
            else
                return -1;
        }

        if(fd->pos)
        {
            uint32_t pos = fd->pos;
            while(pos >= cluster_size)
            {
                pos -= cluster_size;
                cluster_num = fat_get_next_cluster(fd->fs, cluster_num);
                if(!cluster_num)
                    return -1;
            }
        }
    }
    
    /* read data */
    do
    {
        /* calculate data size to copy from cluster */
        offset_t cluster_offset = fat_cluster_offset(fd->fs, cluster_num) + first_cluster_offset;
        uint16_t copy_length = cluster_size - first_cluster_offset;
        if(copy_length > buffer_left)
            copy_length = buffer_left;

        /* read data */
        if(!fd->fs->partition->device_read(cluster_offset, buffer, copy_length))
            return buffer_len - buffer_left;

        /* calculate new file position */
        buffer += copy_length;
        buffer_left -= copy_length;
        fd->pos += copy_length;

        if(first_cluster_offset + copy_length >= cluster_size)
        {
            /* we are on a cluster boundary, so get the next cluster */
            if((cluster_num = fat_get_next_cluster(fd->fs, cluster_num)))
            {
                first_cluster_offset = 0;
            }
            else
            {
                fd->pos_cluster = 0;
                return buffer_len - buffer_left;
            }
        }

        fd->pos_cluster = cluster_num;

    } while(buffer_left > 0); /* check if we are done */

    return buffer_len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t fat_reset_dir

(

struct fat_dir_struct *

dd

)

Resets a directory handle.

Resets the directory handle such that reading restarts with the first directory entry.

Parameters:

[in]

dd

The directory handle to reset.

Returns:

0 on failure, 1 on success.

See also:

fat_read_dir

Definition at line 1550 of file fat.c.

References fat_dir_entry_struct::cluster, fat_dir_struct::dir_entry, fat_dir_struct::entry_cluster, and fat_dir_struct::entry_offset.

Referenced by fat_create_dir(), fat_create_file(), fat_read_dir(), and WaspSD::find_file_in_dir().

{
    if(!dd)
        return 0;

    dd->entry_cluster = dd->dir_entry.cluster;
    dd->entry_offset = 0;
    return 1;
}

Here is the caller graph for this function:

uint8_t fat_resize_file	(	struct fat_file_struct *	fd,
		uint32_t	size
	)

Resizes a file to have a specific size.

Enlarges or shrinks the file pointed to by the file descriptor to have exactly the specified size.

If the file is truncated, all bytes having an equal or larger offset than the given size are lost. If the file is expanded, the additional bytes are allocated.

Note:

Please be aware that this function just allocates or deallocates disk space, it does not explicitely clear it. To avoid data leakage, this must be done manually.

Parameters:

[in]	fd	The file decriptor of the file which to resize.
[in]	size	The new size of the file.

Returns:

0 on failure, 1 on success.

Definition at line 1288 of file fat.c.

References fat_dir_entry_struct::cluster, fat_header_struct::cluster_size, fat_file_struct::dir_entry, fat_append_clusters(), fat_free_clusters(), fat_get_next_cluster(), fat_terminate_clusters(), fat_write_dir_entry(), fat_dir_entry_struct::file_size, fat_file_struct::fs, fat_fs_struct::header, fat_file_struct::pos, and fat_file_struct::pos_cluster.

Referenced by fat_seek_file().

{
    if(!fd)
        return 0;

    cluster_t cluster_num = fd->dir_entry.cluster;
    uint16_t cluster_size = fd->fs->header.cluster_size;
    uint32_t size_new = size;

    do
    {
        if(cluster_num == 0 && size_new == 0)
            /* the file stays empty */
            break;

        /* seek to the next cluster as long as we need the space */
        while(size_new > cluster_size)
        {
            /* get next cluster of file */
            cluster_t cluster_num_next = fat_get_next_cluster(fd->fs, cluster_num);
            if(cluster_num_next)
            {
                cluster_num = cluster_num_next;
                size_new -= cluster_size;
            }
            else
            {
                break;
            }
        }

        if(size_new > cluster_size || cluster_num == 0)
        {
            /* Allocate new cluster chain and append
             * it to the existing one, if available.
             */
            cluster_t cluster_count = (size_new + cluster_size - 1) / cluster_size;
            cluster_t cluster_new_chain = fat_append_clusters(fd->fs, cluster_num, cluster_count);
            if(!cluster_new_chain)
                return 0;

            if(!cluster_num)
            {
                cluster_num = cluster_new_chain;
                fd->dir_entry.cluster = cluster_num;
            }
        }

        /* write new directory entry */
        fd->dir_entry.file_size = size;
        if(size == 0)
            fd->dir_entry.cluster = 0;
        if(!fat_write_dir_entry(fd->fs, &fd->dir_entry))
            return 0;

        if(size == 0)
        {
            /* free all clusters of file */
            fat_free_clusters(fd->fs, cluster_num);
        }
        else if(size_new <= cluster_size)
        {
            /* free all clusters no longer needed */
            fat_terminate_clusters(fd->fs, cluster_num);
        }

    } while(0);

    /* correct file position */
    if(size < fd->pos)
    {
        fd->pos = size;
        fd->pos_cluster = 0;
    }

    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t fat_seek_file	(	struct fat_file_struct *	fd,
		int32_t *	offset,
		uint8_t	whence
	)

Repositions the read/write file offset.

Changes the file offset where the next call to fat_read_file() or fat_write_file() starts reading/writing.

If the new offset is beyond the end of the file, fat_resize_file() is implicitly called, i.e. the file is expanded.

The new offset can be given in different ways determined by the whence parameter:

• FAT_SEEK_SET: *offset is relative to the beginning of the file.
• FAT_SEEK_CUR: *offset is relative to the current file position.
• FAT_SEEK_END: *offset is relative to the end of the file.

The resulting absolute offset is written to the location the offset parameter points to.

Parameters:

[in]	fd	The file decriptor of the file on which to seek.
[in,out]	offset	A pointer to the new offset, as affected by the whence parameter. The function writes the new absolute offset to this location before it returns.
[in]	whence	Affects the way offset is interpreted, see above.

Returns:

0 on failure, 1 on success.

Definition at line 1233 of file fat.c.

References fat_file_struct::dir_entry, fat_resize_file(), FAT_SEEK_CUR, FAT_SEEK_END, FAT_SEEK_SET, FAT_WRITE_SUPPORT, fat_dir_entry_struct::file_size, fat_file_struct::pos, and fat_file_struct::pos_cluster.

Referenced by WaspSD::cat(), WaspSD::catBin(), and WaspSD::writeSD().

{
    if(!fd || !offset)
        return 0;

    uint32_t new_pos = fd->pos;
    switch(whence)
    {
        case FAT_SEEK_SET:
            new_pos = *offset;
            break;
        case FAT_SEEK_CUR:
            new_pos += *offset;
            break;
        case FAT_SEEK_END:
            new_pos = fd->dir_entry.file_size + *offset;
            break;
        default:
            return 0;
    }

    if(new_pos > fd->dir_entry.file_size
#if FAT_WRITE_SUPPORT
       && !fat_resize_file(fd, new_pos)
#endif
       )
        return 0;

    fd->pos = new_pos;
    fd->pos_cluster = 0;

    *offset = (int32_t) new_pos;
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

intptr_t fat_write_file	(	struct fat_file_struct *	fd,
		const uint8_t *	buffer,
		uintptr_t	buffer_len
	)

Writes data to a file.

The data is written to the current file location.

Parameters:

[in]	fd	The file handle of the file to which to write.
[in]	buffer	The buffer from which to read the data to be written.
[in]	buffer_len	The amount of data to write.

Returns:

The number of bytes written, 0 on disk full, or -1 on failure.

See also:

fat_read_file

Definition at line 1088 of file fat.c.

References fat_dir_entry_struct::cluster, fat_header_struct::cluster_size, partition_struct::device_write, fat_file_struct::dir_entry, fat_append_clusters(), fat_cluster_offset(), fat_get_next_cluster(), fat_write_dir_entry(), fat_dir_entry_struct::file_size, fat_file_struct::fs, fat_fs_struct::header, fat_fs_struct::partition, fat_file_struct::pos, and fat_file_struct::pos_cluster.

Referenced by WaspSD::writeSD().

{
    /* check arguments */
    if(!fd || !buffer || buffer_len < 1)
        return -1;
    if(fd->pos > fd->dir_entry.file_size)
        return -1;

    uint16_t cluster_size = fd->fs->header.cluster_size;
    cluster_t cluster_num = fd->pos_cluster;
    uintptr_t buffer_left = buffer_len;
    uint16_t first_cluster_offset = (uint16_t) (fd->pos & (cluster_size - 1));

    /* find cluster in which to start writing */
    if(!cluster_num)
    {
        cluster_num = fd->dir_entry.cluster;
        
        if(!cluster_num)
        {
            if(!fd->pos)
            {
                /* empty file */
                fd->dir_entry.cluster = cluster_num = fat_append_clusters(fd->fs, 0, 1);
                if(!cluster_num)
                    return -1;
            }
            else
            {
                return -1;
            }
        }

        if(fd->pos)
        {
            uint32_t pos = fd->pos;
            cluster_t cluster_num_next;
            while(pos >= cluster_size)
            {
                pos -= cluster_size;
                cluster_num_next = fat_get_next_cluster(fd->fs, cluster_num);
                if(!cluster_num_next && pos == 0)
                    /* the file exactly ends on a cluster boundary, and we append to it */
                    cluster_num_next = fat_append_clusters(fd->fs, cluster_num, 1);
                if(!cluster_num_next)
                    return -1;

                cluster_num = cluster_num_next;
            }
        }
    }
    
    /* write data */
    do
    {
        /* calculate data size to write to cluster */
        offset_t cluster_offset = fat_cluster_offset(fd->fs, cluster_num) + first_cluster_offset;
        uint16_t write_length = cluster_size - first_cluster_offset;
        if(write_length > buffer_left)
            write_length = buffer_left;

        /* write data which fits into the current cluster */
        if(!fd->fs->partition->device_write(cluster_offset, buffer, write_length))
            break;

        /* calculate new file position */
        buffer += write_length;
        buffer_left -= write_length;
        fd->pos += write_length;

        if(first_cluster_offset + write_length >= cluster_size)
        {
            /* we are on a cluster boundary, so get the next cluster */
            cluster_t cluster_num_next = fat_get_next_cluster(fd->fs, cluster_num);
            if(!cluster_num_next && buffer_left > 0)
                /* we reached the last cluster, append a new one */
                cluster_num_next = fat_append_clusters(fd->fs, cluster_num, 1);
            if(!cluster_num_next)
            {
                fd->pos_cluster = 0;
                break;
            }

            cluster_num = cluster_num_next;
            first_cluster_offset = 0;
        }

        fd->pos_cluster = cluster_num;

    } while(buffer_left > 0); /* check if we are done */

    /* update directory entry */
    if(fd->pos > fd->dir_entry.file_size)
    {
#if !FAT_DELAY_DIRENTRY_UPDATE
        uint32_t size_old = fd->dir_entry.file_size;
#endif

        /* update file size */
        fd->dir_entry.file_size = fd->pos;

#if !FAT_DELAY_DIRENTRY_UPDATE
        /* write directory entry */
        if(!fat_write_dir_entry(fd->fs, &fd->dir_entry))
        {
            /* We do not return an error here since we actually wrote
             * some data to disk. So we calculate the amount of data
             * we wrote to disk and which lies within the old file size.
             */
            buffer_left = fd->pos - size_old;
            fd->pos = size_old;
        }
#endif
    }

    return buffer_len - buffer_left;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void get_datetime	(	uint16_t *	year,
		uint8_t *	month,
		uint8_t *	day,
		uint8_t *	hour,
		uint8_t *	min,
		uint8_t *	sec
	)