check.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
off_t	alloc_rootdir_entry (DOS_FS *fs, DIR_ENT *de, const char *pattern, int gen_name)
int	scan_root (DOS_FS *fs)

Function Documentation

alloc_rootdir_entry()

off_t alloc_rootdir_entry	(	DOS_FS *	fs,
		DIR_ENT *	de,
		const char *	pattern,
		int	gen_name
	)

Definition at line 74 of file check.c.

{
    static int curr_num = 0;
    off_t offset;

    if (fs->root_cluster) {
    DIR_ENT d2;
    int i = 0, got = 0;
    uint32_t clu_num, prev = 0;
    off_t offset2;

    clu_num = fs->root_cluster;
    offset = cluster_start(fs, clu_num);
    while (clu_num > 0 && clu_num != -1) {
        fs_read(offset, sizeof(DIR_ENT), &d2);
        if (IS_FREE(d2.name) && d2.attr != VFAT_LN_ATTR) {
        got = 1;
        break;
        }
        i += sizeof(DIR_ENT);
        offset += sizeof(DIR_ENT);
        if ((i % fs->cluster_size) == 0) {
        prev = clu_num;
        if ((clu_num = next_cluster(fs, clu_num)) == 0 || clu_num == -1)
            break;
        offset = cluster_start(fs, clu_num);
        }
    }
    if (!got) {
        /* no free slot, need to extend root dir: alloc next free cluster
         * after previous one */
        if (!prev)
        die("Root directory has no cluster allocated!");
        for (clu_num = prev + 1; clu_num != prev; clu_num++) {
        FAT_ENTRY entry;

        if (clu_num >= fs->data_clusters + 2)
            clu_num = 2;
        get_fat(&entry, fs->fat, clu_num, fs);
        if (!entry.value)
            break;
        }
        if (clu_num == prev)
        die("Root directory full and no free cluster");
        set_fat(fs, prev, clu_num);
        set_fat(fs, clu_num, -1);
        set_owner(fs, clu_num, get_owner(fs, fs->root_cluster));
        /* clear new cluster */
        memset(&d2, 0, sizeof(d2));
        offset = cluster_start(fs, clu_num);
        for (i = 0; i < fs->cluster_size; i += sizeof(DIR_ENT))
        fs_write(offset + i, sizeof(d2), &d2);
    }
    memset(de, 0, sizeof(DIR_ENT));
    if (gen_name) {
        while (1) {
        char expanded[12];
        sprintf(expanded, pattern, curr_num);
        memcpy(de->name, expanded, MSDOS_NAME);
        clu_num = fs->root_cluster;
        i = 0;
        offset2 = cluster_start(fs, clu_num);
        while (clu_num > 0 && clu_num != -1) {
            fs_read(offset2, sizeof(DIR_ENT), &d2);
            if (offset2 != offset &&
            !strncmp((const char *)d2.name, (const char *)de->name,
                 MSDOS_NAME))
            break;
            i += sizeof(DIR_ENT);
            offset2 += sizeof(DIR_ENT);
            if ((i % fs->cluster_size) == 0) {
            if ((clu_num = next_cluster(fs, clu_num)) == 0 ||
                clu_num == -1)
                break;
            offset2 = cluster_start(fs, clu_num);
            }
        }
        if (clu_num == 0 || clu_num == -1)
            break;
        if (++curr_num >= 10000)
            die("Unable to create unique name");
        }
    } else {
        memcpy(de->name, pattern, MSDOS_NAME);
    }
    } else {
    DIR_ENT *root;
    int next_free = 0, scan;

    root = alloc(fs->root_entries * sizeof(DIR_ENT));
    fs_read(fs->root_start, fs->root_entries * sizeof(DIR_ENT), root);

    while (next_free < fs->root_entries)
        if (IS_FREE(root[next_free].name) &&
        root[next_free].attr != VFAT_LN_ATTR)
        break;
        else
        next_free++;
    if (next_free == fs->root_entries)
        die("Root directory is full.");
    offset = fs->root_start + next_free * sizeof(DIR_ENT);
    memset(de, 0, sizeof(DIR_ENT));
    if (gen_name) {
        while (1) {
        char expanded[12];
        sprintf(expanded, pattern, curr_num);
        memcpy(de->name, expanded, MSDOS_NAME);
        for (scan = 0; scan < fs->root_entries; scan++)
            if (scan != next_free &&
            !strncmp((const char *)root[scan].name,
                 (const char *)de->name, MSDOS_NAME))
            break;
        if (scan == fs->root_entries)
            break;
        if (++curr_num >= 10000)
            die("Unable to create unique name");
        }
    } else {
        memcpy(de->name, pattern, MSDOS_NAME);
    }
    free(root);
    }
    ++n_files;
    return offset;
}

Referenced by reclaim_file(), and write_volume_label().

scan_root()

int scan_root

(

DOS_FS *

fs

)

Scan all directory and file information for errors.

Parameters

[in,out]

fs

Information about the filesystem

Returns

0 Success

1 Error

Definition at line 1232 of file check.c.

{
    DOS_FILE **chain;
    int i;

    root = NULL;
    chain = &root;
    new_dir();
    if (fs->root_cluster) {
    add_file(fs, &chain, NULL, 0, &fp_root);
    } else {
    for (i = 0; i < fs->root_entries; i++)
        add_file(fs, &chain, NULL, fs->root_start + i * sizeof(DIR_ENT),
             &fp_root);
    }
    lfn_check_orphaned();
    (void)check_dir(fs, &root, 0);
    if (check_files(fs, root))
    return 1;
    return subdirs(fs, NULL, &fp_root);
}

Referenced by VfatChkdsk().