Pass 'glob' explicitly to nearly every function. Now builds again with

[AROS.git] / rom / filesys / fat / direntry.c

/*
 * fat-handler - FAT12/16/32 filesystem handler
 *
 * Copyright © 2006 Marek Szyprowski
 * Copyright © 2007-2015 The AROS Development Team
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the same terms as AROS itself.
 *
 * $Id$
 */

#include <aros/macros.h>
#include <exec/types.h>
#include <dos/dos.h>
#include <proto/exec.h>
#include <proto/dos.h>

#include <string.h>

#include "cache.h"

#include "fat_fs.h"
#include "fat_protos.h"

#define DEBUG DEBUG_DIRENTRY
#include "debug.h"

LONG InitDirHandle(struct FSSuper *sb, ULONG cluster, struct DirHandle *dh,
    BOOL reuse, struct Globals *glob)
{
    /* dh may or may not be initialised when this is called. if it is, then it
     * probably has a valid cache block that we need to free, but we wouldn't
     * know. we test the superblock pointer to figure out if it's valid or
     * not */
    if (reuse && (dh->ioh.sb == sb))
    {
        D(bug("[fat] reusing directory handle\n"));
        if (dh->ioh.block != NULL)
        {
            Cache_FreeBlock(sb->cache, dh->ioh.block);
            dh->ioh.block = NULL;
        }
    }
    else
    {
        dh->ioh.sb = sb;
        dh->ioh.block = NULL;
    }

    if (cluster == 0)
    {
        dh->ioh.first_cluster = sb->rootdir_cluster;
        dh->ioh.first_sector = sb->rootdir_sector;
    }
    else
    {
        dh->ioh.first_cluster = cluster;
        dh->ioh.first_sector = 0;
    }

    RESET_DIRHANDLE(dh);
    dh->ioh.cur_sector = dh->ioh.first_sector;
    dh->ioh.sector_offset = 0;

    D(bug("[fat] initialised dir handle, first cluster is %ld,"
        " first sector is %ld\n", dh->ioh.first_cluster,
        dh->ioh.first_sector));

    return 0;
}

LONG ReleaseDirHandle(struct DirHandle *dh, struct Globals *glob)
{
    D(bug("[fat] releasing dir handle (cluster %ld)\n",
        dh->ioh.first_cluster));
    RESET_DIRHANDLE(dh);

    return 0;
}

LONG GetDirEntry(struct DirHandle *dh, ULONG index, struct DirEntry *de,
    struct Globals *glob)
{
    LONG err = 0;
    ULONG nread;

    D(bug("[fat] looking for dir entry %ld in dir starting at cluster %ld\n",
        index, dh->ioh.first_cluster));

    /* fat dirs are limited to 2^16 entries */
    if (index >= 0x10000)
    {
        D(bug("[fat] request for out-of-range index, returning not found\n"));
        return ERROR_OBJECT_NOT_FOUND;
    }

    /* set up the return object */
    de->sb = dh->ioh.sb;
    de->cluster = dh->ioh.first_cluster;
    de->index = index;
    de->pos = index * sizeof(struct FATDirEntry);

    /* get the data directly into the entry */
    err = ReadFileChunk(&(dh->ioh), de->pos, sizeof(struct FATDirEntry),
        (UBYTE *) &(de->e.entry), &nread);
    if (err != 0)
    {
        D(bug("[fat] dir entry lookup failed\n"));
        return err;
    }

    /* remember where we are for GetNextDirEntry() */
    dh->cur_index = index;

    /* done! */
    return 0;
}

LONG GetNextDirEntry(struct DirHandle *dh, struct DirEntry *de,
    struct Globals *glob)
{
    LONG err;

    D(bug("[fat] looking for next entry after index %ld\n", dh->cur_index));

    /* cur_index defaults to -1, so this will do the right thing even on a
     * fresh dirhandle */
    while ((err = GetDirEntry(dh, dh->cur_index + 1, de, glob)) == 0)
    {
        /* end of directory, there is no next entry */
        if (de->e.entry.name[0] == 0x00)
        {
            D(bug("[fat] entry %ld is end-of-directory marker, we're done\n",
                dh->cur_index));
            RESET_DIRHANDLE(dh);
            return ERROR_OBJECT_NOT_FOUND;
        }

        /* skip unused entries */
        if (de->e.entry.name[0] == 0xe5)
        {
            D(bug("[fat] entry %ld is empty, skipping it\n", dh->cur_index));
            continue;
        }

        /* this flag will be set for both volume name entries and long
         * filename entries. either way we want to skip them */
        if (de->e.entry.attr & ATTR_VOLUME_ID)
        {
            D(bug("[fat] entry %ld is a volume name or long filename,"
                " skipping it\n", dh->cur_index));
            continue;
        }

        /* ignore the . and .. entries */
        if (de->e.entry.name[0] == '.' && ((de->index == 0
            && strncmp((char *)de->e.entry.name, ".          ",
                FAT_MAX_SHORT_NAME) == 0)
            || (de->index == 1
            && strncmp((char *)de->e.entry.name, "..         ",
                FAT_MAX_SHORT_NAME) == 0)))
        {
            D(bug("[fat] skipping . or .. entry\n"));
            continue;
        }

        D(bug("[fat] returning entry %ld\n", dh->cur_index));

        return 0;
    }

    return err;
}

LONG GetParentDir(struct DirHandle *dh, struct DirEntry *de,
    struct Globals *glob)
{
    LONG err = 0;
    ULONG cluster;

    D(bug("[fat] getting parent for directory at cluster %ld\n",
        dh->ioh.first_cluster));

    /* if we're already at the root, then we can't go any further */
    if (dh->ioh.first_cluster == dh->ioh.sb->rootdir_cluster)
    {
        D(bug("[fat] trying to go up past the root, so entry not found\n"));
        return ERROR_OBJECT_NOT_FOUND;
    }

    /* otherwise, the next cluster is held in the '..' entry, which is
     * entry #1 */
    GetDirEntry(dh, 1, de, glob);

    /* make sure it's actually the parent dir entry */
    if (((de->e.entry.attr & ATTR_DIRECTORY) == 0) ||
        strncmp((char *)de->e.entry.name, "..         ", FAT_MAX_SHORT_NAME)
        != 0)
    {
        D(bug("[fat] entry index 1 does not have name '..', can't go up\n"));
        D(bug("[fat] actual name: '%.*s', attrs: 0x%x\n", FAT_MAX_SHORT_NAME,
            de->e.entry.name, de->e.entry.attr));
        return ERROR_OBJECT_NOT_FOUND;
    }

    /* take us up */
    InitDirHandle(dh->ioh.sb, FIRST_FILE_CLUSTER(de), dh, TRUE, glob);

    /* get handle on grandparent dir so we can find entry with parent's
     * name */
    if (dh->ioh.first_cluster != dh->ioh.sb->rootdir_cluster)
    {
        D(bug("[fat] getting grandparent, first cluster is %ld,"
            " root cluster is %ld\n", dh->ioh.first_cluster,
            dh->ioh.sb->rootdir_cluster));
        cluster = dh->ioh.first_cluster;
        GetDirEntry(dh, 1, de, glob);
        InitDirHandle(dh->ioh.sb, FIRST_FILE_CLUSTER(de), dh, TRUE, glob);

        err = GetDirEntryByCluster(dh, cluster, de, glob);
    }

    return err;
}

LONG GetDirEntryByCluster(struct DirHandle *dh, ULONG cluster,
    struct DirEntry *de, struct Globals *glob)
{
    LONG err;

    D(bug("[fat] looking for dir entry with first cluster %lu\n", cluster));

    /* start at the start */
    RESET_DIRHANDLE(dh);

    /* loop through the entries until we find a match */
    while ((err = GetNextDirEntry(dh, de, glob)) == 0)
    {
        if (de->e.entry.first_cluster_hi == (cluster >> 16)
            && de->e.entry.first_cluster_lo == (cluster & 0xffff))
        {
            D(bug("[fat] matched starting cluster at entry %ld, returning\n",
                dh->cur_index));
            return 0;
        }
    }

    D(bug("[fat] dir entry with first cluster %lu not found\n", cluster));
    return err;
}

LONG GetDirEntryByName(struct DirHandle *dh, STRPTR name, ULONG namelen,
    struct DirEntry *de, struct Globals *glob)
{
    UBYTE buf[256];
    ULONG buflen;
    LONG err;

    D(bug("[fat] looking for dir entry with name '%s'\n", name));

    /* start at the start */
    RESET_DIRHANDLE(dh);

    /* loop through the entries until we find a match */
    while ((err = GetNextDirEntry(dh, de, glob)) == 0)
    {
        /* compare with the short name first, since we already have it */
        GetDirEntryShortName(de, buf, &buflen, glob);
        if (namelen == buflen
            && strnicmp((char *)name, (char *)buf, buflen) == 0)
        {
            D(bug("[fat] matched short name '%s' at entry %ld, returning\n",
                buf, dh->cur_index));
            return 0;
        }

        /* no match, extract the long name and compare with that instead */
        GetDirEntryLongName(de, buf, &buflen);
        if (namelen == buflen
            && strnicmp((char *)name, (char *)buf, buflen) == 0)
        {
            D(bug("[fat] matched long name '%s' at entry %ld, returning\n",
                buf, dh->cur_index));
            return 0;
        }
    }

    return err;
}

LONG GetDirEntryByPath(struct DirHandle *dh, STRPTR path, ULONG pathlen,
    struct DirEntry *de, struct Globals *glob)
{
    LONG err;
    ULONG len, i;

    D(
        bug("[fat] looking for entry with path '");
        RawPutChars(path, pathlen);
        bug("' from dir at cluster %ld\n", dh->ioh.first_cluster);
    )

    /* get back to the start of the dir */
    RESET_DIRHANDLE(dh);

    /* if it starts with a volume specifier (or just a :), remove it and get
     * us back to the root dir */
    for (i = 0; i < pathlen; i++)
        if (path[i] == ':')
        {
            D(bug(
                "[fat] path has volume specifier, moving to the root dir\n"));

            pathlen -= (i + 1);
            path = &path[i + 1];

            InitDirHandle(dh->ioh.sb, 0, dh, TRUE, glob);

            /* If we were called with simply ":" as the name we will return
               immediately after this, so we prepare a fictional direntry for
               such a case.
               Note that we fill only fields which are actually used in our handler */
            de->cluster = 0;
            de->index = -1;     /* WARNING! Dummy index */
            de->e.entry.attr = ATTR_DIRECTORY;
            de->e.entry.first_cluster_hi = 0;
            de->e.entry.first_cluster_lo = 0;

            break;
        }

    D(
        bug("[fat] now looking for entry with path '");
        RawPutChars(path, pathlen);
        bug("' from dir at cluster %ld\n", dh->ioh.first_cluster);
    )

    /* each time around the loop we find one dir/file in the full path */
    while (pathlen > 0)
    {

        /* zoom forward and find the first dir separator */
        for (len = 0; len < pathlen && path[len] != '/'; len++);

        D(
            bug("[fat] remaining path is '");
            RawPutChars(path, pathlen);
            bug("' (%d bytes), current chunk is '", pathlen);
            RawPutChars(path, len); bug("' (%d bytes)\n", len);
        )

        /* if the first character is a /, then we have to go up a level */
        if (len == 0)
        {

            /* get the parent dir, and bale if we've gone past it (i.e. we are
             * the root) */
            if ((err = GetParentDir(dh, de, glob)) != 0)
                return err;
        }

        /* otherwise, we want to search the current directory for this name */
        else
        {
            if ((err = GetDirEntryByName(dh, path, len, de, glob)) != 0)
                return ERROR_OBJECT_NOT_FOUND;
        }

        /* move up the buffer */
        path += len;
        pathlen -= len;

        /* a / here is either the path separator or the directory we just went
         * up. either way, we have to ignore it */
        if (pathlen > 0 && path[0] == '/')
        {
            path++;
            pathlen--;
        }

        if (pathlen > 0)
        {
            /* more to do, so this entry had better be a directory */
            if (!(de->e.entry.attr & ATTR_DIRECTORY))
            {
                D(bug("[fat] '%.*s' is not a directory,"
                    " so can't go any further\n", len, path));
                return ERROR_OBJECT_WRONG_TYPE;
            }

            InitDirHandle(dh->ioh.sb, FIRST_FILE_CLUSTER(de), dh, TRUE,
                glob);
        }
    }

    /* nothing left, so we've found it */
    D(bug("[fat] found the entry, returning it\n"));
    return 0;
}

LONG UpdateDirEntry(struct DirEntry *de, struct Globals *glob)
{
    struct DirHandle dh;
    LONG err = 0;
    ULONG nwritten;

    D(bug("[fat] writing dir entry %ld in dir starting at cluster %ld\n",
        de->index, de->cluster));

    InitDirHandle(glob->sb, de->cluster, &dh, FALSE, glob);

    err =
        WriteFileChunk(&(dh.ioh), de->pos, sizeof(struct FATDirEntry),
        (UBYTE *) &(de->e.entry), &nwritten);
    if (err != 0)
    {
        D(bug("[fat] dir entry update failed\n"));
        ReleaseDirHandle(&dh, glob);
        return err;
    }

    ReleaseDirHandle(&dh, glob);

    return 0;
}

LONG AllocDirEntry(struct DirHandle *dh, ULONG gap, struct DirEntry *de,
    struct Globals *glob)
{
    ULONG nwant;
    LONG err;
    ULONG nfound;
    BOOL clusteradded = FALSE;

    /* find out how many entries we need */
    nwant = gap + 1;

    D(bug("[fat] need to find room for %ld contiguous entries\n", nwant));

    /* get back to the start of the dir */
    RESET_DIRHANDLE(dh);

    /* search the directory until we find a large enough gap */
    nfound = 0;
    de->index = -1;
    while (nfound < nwant)
    {
        err = GetDirEntry(dh, de->index + 1, de, glob);

        /* if we can't get the entry, then we ran off the end, so there's no
         * space left */
        if (err == ERROR_OBJECT_NOT_FOUND)
        {
            D(bug("[fat] ran off the end of the directory, no space left\n"));
            return ERROR_NO_FREE_STORE;
        }

        /* return any other error direct */
        if (err != 0)
            return err;

        /* if it's unused, make a note */
        if (de->e.entry.name[0] == 0xe5)
        {
            nfound++;
            continue;
        }

        /* if we hit end-of-directory, then we can shortcut it */
        if (de->e.entry.name[0] == 0x00)
        {
            ULONG last;

            if (de->index + nwant >= 0x10000)
            {
                D(bug("[fat] hit end-of-directory marker,"
                    " but there's not enough room left after it\n"));
                return ERROR_NO_FREE_STORE;
            }

            D(bug("[fat] found end-of-directory marker,"
                " making space after it\n"));

            last = de->index + nwant;
            do
            {
                if (GetDirEntry(dh, de->index + 1, de, glob) != 0)
                    clusteradded = TRUE;
                de->e.entry.name[0] = 0x00;
                UpdateDirEntry(de, glob);
            }
            while (de->index != last);

            D(bug("[fat] new end-of-directory is entry %ld\n", de->index));

            /* clear all remaining entries in any new cluster added */
            if (clusteradded)
                while (GetDirEntry(dh, de->index + 1, de, glob) == 0)
                {
                    memset(&de->e.entry, 0, sizeof(struct FATDirEntry));
                    UpdateDirEntry(de, glob);
                }

            /* get the previous entry; this is the base (short name) entry */
            GetDirEntry(dh, last - 1, de, glob);

            break;
        }

        /* anything else is an in-use entry, so reset our count */
        nfound = 0;
    }

    D(bug("[fat] found a gap, base (short name) entry is %ld\n",
        de->index));
    return 0;
}

LONG CreateDirEntry(struct DirHandle *dh, STRPTR name, ULONG namelen,
    UBYTE attr, ULONG cluster, struct DirEntry *de, struct Globals *glob)
{
    ULONG gap;
    LONG err;

    D(
        bug("[fat] creating dir entry (name '");
        RawPutChars(name, namelen);
        bug("' attr 0x%02x cluster %ld)\n", attr, cluster);
    )

    /* find out how many extra entries we need for the long name */
    gap = NumLongNameEntries(name, namelen);

    /* search for a suitable unused entry */
    err = AllocDirEntry(dh, gap, de, glob);
    if (err != 0)
        return err;

    /* build the entry */
    FillDirEntry(de, attr, cluster, glob);

    SetDirEntryName(de, name, namelen);

    if ((err = UpdateDirEntry(de, glob)) != 0)
    {
        D(bug(
            "[fat] couldn't update base directory entry, creation failed\n"));
        return err;
    }

    D(bug("[fat] created dir entry %ld\n", de->index));

    return 0;
}

void FillDirEntry(struct DirEntry *de, UBYTE attr, ULONG cluster,
    struct Globals *glob)
{
    struct DateStamp ds;

    de->e.entry.attr = attr;
    de->e.entry.nt_res = 0;

    DateStamp(&ds);
    ConvertDOSDate(&ds, &(de->e.entry.create_date),
        &(de->e.entry.create_time), glob);
    de->e.entry.write_date = de->e.entry.create_date;
    de->e.entry.write_time = de->e.entry.create_time;
    de->e.entry.last_access_date = de->e.entry.create_date;
    de->e.entry.create_time_tenth = ds.ds_Tick % (TICKS_PER_SECOND * 2)
        / (TICKS_PER_SECOND / 10);

    de->e.entry.first_cluster_lo = cluster & 0xffff;
    de->e.entry.first_cluster_hi = cluster >> 16;

    de->e.entry.file_size = 0;
}

LONG DeleteDirEntry(struct DirEntry *de, struct Globals *glob)
{
    struct DirHandle dh;
    UBYTE checksum;
    ULONG order;
    LONG err;

    InitDirHandle(glob->sb, de->cluster, &dh, FALSE, glob);

    /* calculate the short name checksum before we trample on the name */
    CALC_SHORT_NAME_CHECKSUM(de->e.entry.name, checksum);

    D(bug("[fat] short name checksum is 0x%02x\n", checksum));

    /* mark the short entry free */
    de->e.entry.name[0] = 0xe5;
    UpdateDirEntry(de, glob);

    D(bug("[fat] deleted short name entry\n"));

    /* now we loop over the previous entries, looking for matching long name
     * entries and killing them */
    order = 1;
    while ((err = GetDirEntry(&dh, de->index - 1, de, glob)) == 0)
    {

        /* see if this is a matching long name entry. if it's not, we're done */
        if (!((de->e.entry.attr & ATTR_LONG_NAME_MASK) == ATTR_LONG_NAME) ||
            (de->e.long_entry.order & ~0x40) != order ||
            de->e.long_entry.checksum != checksum)

            break;

        /* kill it */
        de->e.entry.name[0] = 0xe5;
        UpdateDirEntry(de, glob);

        order++;
    }

    D(bug("[fat] deleted %ld long name entries\n", order - 1));

    ReleaseDirHandle(&dh, glob);

    return err;
}

LONG FillFIB(struct ExtFileLock *fl, struct FileInfoBlock *fib,
    struct Globals *glob)
{
    struct FSSuper *sb = glob->sb;
    struct GlobalLock *gl = (fl != NULL ? fl->gl : &sb->info->root_lock);
    struct DirHandle dh;
    struct DirEntry de;
    LONG result = 0;
    int len;

    D(bug("\tFilling FIB data.\n"));

    if (gl == &sb->info->root_lock)
    {
        D(bug("\t\ttype: root directory\n"));
        fib->fib_DirEntryType = ST_ROOT;
    }
    else if (gl->attr & ATTR_DIRECTORY)
    {
        D(bug("\t\ttype: directory\n"));
        fib->fib_DirEntryType = ST_USERDIR;
    }
    else
    {
        D(bug("\t\ttype: file\n"));
        fib->fib_DirEntryType = ST_FILE;
    }

    D(bug("\t\tsize: %ld\n", gl->size));

    fib->fib_Size = gl->size;
    fib->fib_NumBlocks = ((gl->size + (sb->clustersize - 1))
        >> sb->clustersize_bits) << sb->cluster_sectors_bits;
    fib->fib_EntryType = fib->fib_DirEntryType;
    fib->fib_DiskKey = 0xfffffffflu;    //fl->entry;

    if (fib->fib_DirEntryType == ST_ROOT)
        CopyMem(&sb->volume.create_time, &fib->fib_Date,
            sizeof(struct DateStamp));
    else
    {
        InitDirHandle(sb, gl->dir_cluster, &dh, FALSE, glob);
        GetDirEntry(&dh, gl->dir_entry, &de, glob);
        ConvertFATDate(de.e.entry.write_date, de.e.entry.write_time,
            &fib->fib_Date, glob);
        ReleaseDirHandle(&dh, glob);
    }

    len = gl->name[0] <= 106 ? gl->name[0] : 106;
    CopyMem(gl->name, fib->fib_FileName, len + 1);
    fib->fib_FileName[len + 1] = '\0';
    D(bug("\t\tname (len %ld) %s\n", len, fib->fib_FileName + 1));

    fib->fib_Protection = 0;
    if (gl->attr & ATTR_READ_ONLY)
        fib->fib_Protection |= (FIBF_DELETE | FIBF_WRITE);
    if (gl->attr & ATTR_ARCHIVE)
        fib->fib_Protection |= FIBF_ARCHIVE;

    fib->fib_Comment[0] = 0;
#if DEBUG_NAMES
    CopyMem(gl->shortname, fib->fib_Comment, gl->shortname[0] + 1);
#endif

    return result;
}