Components/IFS/src/include/IFS/FWFS/FileSystem.h

Go to the documentation of this file.

#pragma once

#include "../FileSystem.h"
#include "../ObjectStore.h"

namespace IFS
{
namespace FWFS
{
// File handles start at this value
#ifndef FWFS_HANDLE_MIN
#define FWFS_HANDLE_MIN 100
#endif

// Maximum number of file descriptors
#ifndef FWFS_MAX_FDS
#define FWFS_MAX_FDS 8
#endif

// Maximum number of volumes - 1 is minimum, the rest are mounted in subdirectories
#ifndef FWFS_MAX_VOLUMES
#define FWFS_MAX_VOLUMES 4
#endif

// Maximum file handle value
#define FWFS_HANDLE_MAX (FWFS_HANDLE_MIN + FWFS_MAX_FDS - 1)

enum class FWFileDescAttr {
    allocated, 
};

using FWFileDescAttributes = BitSet<uint8_t, FWFileDescAttr, 1>;

struct FWFileDesc {
    FWObjDesc odFile;    
    uint32_t dataSize{0}; 
    uint32_t cursor{0};   
    FWFileDescAttributes attr;
};

struct FWVolume {
    IObjectStore* store{nullptr};
    ObjRef ref; 

    bool isMounted()
    {
        return store ? store->isMounted() : false;
    }
};

class FileSystem : public IFileSystem
{
public:
    FileSystem()
    {
    }

    FileSystem(IObjectStore* store)
    {
        setVolume(0, store);
    }

    ~FileSystem()
    {
        for(auto& vol : volumes) {
            delete vol.store;
        }
    }

    int setVolume(uint8_t num, IObjectStore* store);

    // IFileSystem methods
    int mount() override;
    int getinfo(Info& info) override;
    int opendir(const char* path, DirHandle& dir) override;
    int fopendir(const Stat* stat, DirHandle& dir) override;
    int readdir(DirHandle dir, Stat& stat) override;
    int rewinddir(DirHandle dir) override;
    int closedir(DirHandle dir) override;
    int mkdir(const char* path) override
    {
        return Error::ReadOnly;
    }
    int stat(const char* path, Stat* stat) override;
    int fstat(FileHandle file, Stat* stat) override;
    int fcontrol(FileHandle file, ControlCode code, void* buffer, size_t bufSize) override;
    int setacl(FileHandle file, const ACL& acl) override
    {
        return Error::ReadOnly;
    }
    int setattr(const char* path, FileAttributes attr)
    {
        return Error::ReadOnly;
    }
    int settime(FileHandle file, time_t mtime) override
    {
        return Error::ReadOnly;
    }
    int setcompression(FileHandle file, const Compression& compression)
    {
        return Error::ReadOnly;
    }
    FileHandle open(const char* path, OpenFlags flags) override;
    FileHandle fopen(const Stat& stat, OpenFlags flags) override;
    int close(FileHandle file) override;
    int read(FileHandle file, void* data, size_t size) override;
    int write(FileHandle file, const void* data, size_t size) override
    {
        return Error::ReadOnly;
    }
    int lseek(FileHandle file, int offset, SeekOrigin origin) override;
    int eof(FileHandle file) override;
    int32_t tell(FileHandle file) override;
    int ftruncate(FileHandle file, size_t new_size) override
    {
        return Error::ReadOnly;
    }
    int flush(FileHandle file) override
    {
        return Error::ReadOnly;
    }
    int rename(const char* oldpath, const char* newpath) override
    {
        return Error::ReadOnly;
    }
    int remove(const char* path) override
    {
        return Error::ReadOnly;
    }
    int fremove(FileHandle file) override
    {
        return Error::ReadOnly;
    }
    int format() override
    {
        return Error::ReadOnly;
    }
    int check() override
    {
        /* We could implement this, but since problems would indicate corrupted firmware
         * there isn't much we can do other than suggest a re-flashing. This sort of issue
         * is better resolved externally using a hash of the entire firmware image. */
        return Error::NotImplemented;
    }

    int getFilePath(FileID fileid, NameBuffer& path);

    int getMd5Hash(FileHandle file, void* buffer, size_t bufSize);

private:
    int seekFilePath(FWObjDesc& parent, FileID fileid, NameBuffer& path);

    int mountVolume(FWVolume& volume);

    int getStore(const ObjRef& ref, IObjectStore*& store)
    {
        if(ref.storenum >= FWFS_MAX_VOLUMES) {
            return Error::BadStore;
        }
        store = volumes[ref.storenum].store;
        return store ? FS_OK : Error::NotMounted;
    }

    int getStore(const FWObjDesc& od, IObjectStore*& store)
    {
        return getStore(od.ref, store);
    }

    int openRootObject(const FWVolume& volume, FWObjDesc& odRoot);

    int openObject(FWObjDesc& od)
    {
        assert(od.ref.refCount == 0);

        IObjectStore* store;
        int res = getStore(od.ref, store);
        if(res >= 0) {
            res = store->open(od);
            if(res >= 0) {
                ++od.ref.refCount;
            }
        }

        return res;
    }

    int openChildObject(const FWObjDesc& parent, const FWObjDesc& child, FWObjDesc& od)
    {
        assert(od.ref.refCount == 0);

        IObjectStore* store;
        int res = getStore(parent.ref, store);
        if(res >= 0) {
            res = store->openChild(parent, child, od);
            if(res >= 0) {
                ++od.ref.refCount;
            }
        }

        return res;
    }

    int closeObject(FWObjDesc& od)
    {
        assert(od.ref.refCount == 1);

        IObjectStore* store;
        int res = getStore(od.ref, store);
        if(res >= 0) {
            res = store->close(od);
            if(res >= 0) {
                --od.ref.refCount;
            }
        }

        return res;
    }

    int readObjectHeader(FWObjDesc& od)
    {
        IObjectStore* store;
        int res = getStore(od.ref, store);
        return res < 0 ? res : store->readHeader(od);
    }

    int readChildObjectHeader(const FWObjDesc& parent, FWObjDesc& child)
    {
        assert(parent.obj.isNamed());
        // Child must be in same store as parent
        child.ref.storenum = parent.ref.storenum;
        IObjectStore* store;
        int res = getStore(parent.ref, store);
        return res < 0 ? res : store->readChildHeader(parent, child);
    }

    int readObjectContent(const FWObjDesc& od, uint32_t offset, uint32_t size, void* buffer)
    {
        IObjectStore* store;
        int res = getStore(od.ref, store);
        return res < 0 ? res : store->readContent(od, offset, size, buffer);
    }

    int findUnusedDescriptor();

    int findChildObjectHeader(const FWObjDesc& parent, FWObjDesc& child, Object::Type objId);
    int findChildObject(const FWObjDesc& parent, FWObjDesc& child, const char* name, unsigned namelen);
    int findObjectByPath(const char* path, FWObjDesc& od);
    int resolveMountPoint(const FWObjDesc& odMountPoint, FWObjDesc& odResolved);

    int readObjectName(const FWObjDesc& od, NameBuffer& name);
    FileHandle allocateFileDescriptor(FWObjDesc& odFile);
    int fillStat(Stat& stat, const FWObjDesc& entry);

    void printObject(const FWObjDesc& od);

private:
    FWVolume volumes[FWFS_MAX_VOLUMES]; 
    ACL rootACL;
    FWFileDesc fileDescriptors[FWFS_MAX_FDS];
};

} // namespace FWFS

} // namespace IFS