FAT directory functions
[FAT support]

Collaboration diagram for FAT directory functions:

Functions
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_dir (struct fat_dir_struct *parent, const char *dir, struct fat_dir_entry_struct *dir_entry)

---

Detailed Description

Functions for managing directories.

---

Function Documentation

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:

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:

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:

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:

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: