/*
 * Copyright 2011-2014, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "packagefs.h"

#include <errno.h>
#include <unistd.h>

#include <package/hpkg/DataReader.h>
#include <package/hpkg/ErrorOutput.h>
#include <package/hpkg/PackageDataReader.h>
#include <package/hpkg/PackageEntry.h>
#include <package/hpkg/PackageEntryAttribute.h>
#include <package/hpkg/PackageFileHeapReader.h>
#include <package/hpkg/PackageReaderImpl.h>

#include <AutoDeleter.h>
#include <FdIO.h>

#include <util/DoublyLinkedList.h>

#include <Referenceable.h>

#include <boot/PathBlocklist.h>
#include <boot/platform.h>

#include "PackageSettingsItem.h"


#if 0
#       define RETURN_ERROR(error) return (error);
#else
#       define RETURN_ERROR(err)                                                                                                \
        {                                                                                                                                               \
                status_t _status = err;                                                                                         \
                if (_status < B_OK)                                                                                                     \
                        dprintf("%s:%d: %s\n", __FILE__, __LINE__, strerror(_status));  \
                return _status;                                                                                                         \
        }
#endif


using namespace BPackageKit;
using namespace BPackageKit::BHPKG;
using BPackageKit::BHPKG::BPrivate::PackageFileHeapReader;
using BPackageKit::BHPKG::BPrivate::PackageReaderImpl;

using namespace PackageFS;


namespace PackageFS {


struct PackageDirectory;
struct PackageNode;
struct PackageVolume;


static status_t create_node(PackageNode* packageNode, ::Node*& _node);


// #pragma mark - PackageNode


struct PackageNode : DoublyLinkedListLinkImpl<PackageNode> {
        PackageNode(PackageVolume* volume, mode_t mode)
                :
                fVolume(volume),
                fParentDirectory(NULL),
                fName(NULL),
                fNodeID(0),
                fMode(mode)
        {
        }

        virtual ~PackageNode()
        {
                free(fName);
        }

        status_t Init(PackageDirectory* parentDir, const char* name, ino_t nodeID)
        {
                fParentDirectory = parentDir;
                fName = strdup(name);
                fNodeID = nodeID;

                return fName != NULL ? B_OK : B_NO_MEMORY;
        }

        PackageVolume* Volume() const
        {
                return fVolume;
        }

        const char* Name() const
        {
                return fName;
        }

        ino_t NodeID() const
        {
                return fNodeID;
        }

        mode_t Mode() const
        {
                return fMode;
        }

        virtual void RemoveEntry(const char* path)
        {
        }

protected:
        PackageVolume*          fVolume;
        PackageDirectory*       fParentDirectory;
        char*                           fName;
        ino_t                           fNodeID;
        mode_t                          fMode;
};


// #pragma mark - PackageFile


struct PackageFile : PackageNode {
        PackageFile(PackageVolume* volume, mode_t mode, const BPackageData& data)
                :
                PackageNode(volume, mode),
                fData(data)
        {
        }

        const BPackageData& Data() const
        {
                return fData;
        }

        off_t Size() const
        {
                return fData.Size();
        }

private:
        BPackageData    fData;
};


// #pragma mark - PackageSymlink


struct PackageSymlink : PackageNode {
        PackageSymlink(PackageVolume* volume, mode_t mode)
                :
                PackageNode(volume, mode),
                fPath(NULL)
        {
        }

        ~PackageSymlink()
        {
                free(fPath);
        }

        status_t SetSymlinkPath(const char* path)
        {
                fPath = strdup(path);
                return fPath != NULL ? B_OK : B_NO_MEMORY;
        }

        const char* SymlinkPath() const
        {
                return fPath;
        }

private:
        char*   fPath;
};


// #pragma mark - PackageDirectory


struct PackageDirectory : PackageNode {
        PackageDirectory(PackageVolume* volume, mode_t mode)
                :
                PackageNode(volume, mode)
        {
        }

        ~PackageDirectory()
        {
                while (PackageNode* node = fEntries.RemoveHead())
                        delete node;
        }

        void AddChild(PackageNode* node)
        {
                fEntries.Add(node);
        }

        PackageNode* FirstChild() const
        {
                return fEntries.Head();
        }

        PackageNode* NextChild(PackageNode* child) const
        {
                return fEntries.GetNext(child);
        }

        PackageNode* Lookup(const char* name)
        {
                if (strcmp(name, ".") == 0)
                        return this;
                if (strcmp(name, "..") == 0)
                        return fParentDirectory;

                return _LookupChild(name, strlen(name));
        }

        virtual void RemoveEntry(const char* path)
        {
                const char* componentEnd = strchr(path, '/');
                if (componentEnd == NULL)
                        componentEnd = path + strlen(path);

                PackageNode* child = _LookupChild(path, componentEnd - path);
                if (child == NULL)
                        return;

                if (*componentEnd == '\0') {
                        // last path component -- delete the child
                        fEntries.Remove(child);
                        delete child;
                } else {
                        // must be a directory component -- continue resolving the path
                        child->RemoveEntry(componentEnd + 1);
                }
        }

private:
        typedef DoublyLinkedList<PackageNode>   NodeList;

private:
        PackageNode* _LookupChild(const char* name, size_t nameLength)
        {
                for (NodeList::Iterator it = fEntries.GetIterator();
                                PackageNode* child = it.Next();) {
                        if (strncmp(child->Name(), name, nameLength) == 0
                                && child->Name()[nameLength] == '\0') {
                                return child;
                        }
                }

                return NULL;
        }

private:
        NodeList        fEntries;
};


// #pragma mark - PackageLoaderErrorOutput


struct PackageLoaderErrorOutput : BErrorOutput {
        PackageLoaderErrorOutput()
        {
        }

        virtual void PrintErrorVarArgs(const char* format, va_list args)
        {
                char buffer[256];
                vsnprintf(buffer, sizeof(buffer), format, args);
                dprintf("%s", buffer);
        }
};


// #pragma mark - PackageVolume


struct PackageVolume : BReferenceable, private PackageLoaderErrorOutput {
        PackageVolume()
                :
                fNextNodeID(1),
                fRootDirectory(this, S_IFDIR),
                fHeapReader(NULL),
                fFile(NULL)
        {
        }

        ~PackageVolume()
        {
                delete fHeapReader;
                delete fFile;
        }

        status_t Init(int fd, const PackageFileHeapReader* heapReader)
        {
                status_t error = fRootDirectory.Init(&fRootDirectory, ".",
                        NextNodeID());
                if (error != B_OK)
                        return error;

                fd = dup(fd);
                if (fd < 0)
                        return errno;

                fFile = new(std::nothrow) BFdIO(fd, true);
                if (fFile == NULL) {
                        close(fd);
                        return B_NO_MEMORY;
                }

                // clone a heap reader and adjust it for our use
                fHeapReader = heapReader->Clone();
                if (fHeapReader == NULL)
                        return B_NO_MEMORY;

                fHeapReader->SetErrorOutput(this);
                fHeapReader->SetFile(fFile);

                return B_OK;
        }

        PackageDirectory* RootDirectory()
        {
                return &fRootDirectory;
        }

        ino_t NextNodeID()
        {
                return fNextNodeID++;
        }

        status_t CreateFileDataReader(const BPackageData& data,
                BAbstractBufferedDataReader*& _reader)
        {
                return BPackageDataReaderFactory().CreatePackageDataReader(fHeapReader,
                        data, _reader);
        }

private:
        ino_t                                           fNextNodeID;
        PackageDirectory                        fRootDirectory;
        PackageFileHeapReader*          fHeapReader;
        BPositionIO*                            fFile;
};


// #pragma mark - PackageLoaderContentHandler


struct PackageLoaderContentHandler : BPackageContentHandler {
        PackageLoaderContentHandler(PackageVolume* volume,
                PackageSettingsItem* settingsItem)
                :
                fVolume(volume),
                fSettingsItem(settingsItem),
                fLastSettingsEntry(NULL),
                fLastSettingsEntryEntry(NULL),
                fErrorOccurred(false)
        {
        }

        status_t Init()
        {
                return B_OK;
        }

        virtual status_t HandleEntry(BPackageEntry* entry)
        {
                if (fErrorOccurred
                        || (fLastSettingsEntry != NULL
                                && fLastSettingsEntry->IsBlocked())) {
                        return B_OK;
                }

                PackageDirectory* parentDir = NULL;
                if (const BPackageEntry* parentEntry = entry->Parent()) {
                        if (!S_ISDIR(parentEntry->Mode()))
                                RETURN_ERROR(B_BAD_DATA);

                        parentDir = static_cast<PackageDirectory*>(
                                (PackageNode*)parentEntry->UserToken());
                }

                if (fSettingsItem != NULL
                        && (parentDir == NULL
                                || entry->Parent() == fLastSettingsEntryEntry)) {
                        PackageSettingsItem::Entry* settingsEntry
                                = fSettingsItem->FindEntry(fLastSettingsEntry, entry->Name());
                        if (settingsEntry != NULL) {
                                fLastSettingsEntry = settingsEntry;
                                fLastSettingsEntryEntry = entry;
                                if (fLastSettingsEntry->IsBlocked())
                                        return B_OK;
                        }
                }

                if (parentDir == NULL)
                        parentDir = fVolume->RootDirectory();

                status_t error;

                // get the file mode -- filter out write permissions
                mode_t mode = entry->Mode() & ~(mode_t)(S_IWUSR | S_IWGRP | S_IWOTH);

                // create the package node
                PackageNode* node;
                if (S_ISREG(mode)) {
                        // file
                        node = new(std::nothrow) PackageFile(fVolume, mode, entry->Data());
                } else if (S_ISLNK(mode)) {
                        // symlink
                        PackageSymlink* symlink = new(std::nothrow) PackageSymlink(
                                fVolume, mode);
                        if (symlink == NULL)
                                RETURN_ERROR(B_NO_MEMORY);

                        error = symlink->SetSymlinkPath(entry->SymlinkPath());
                        if (error != B_OK) {
                                delete symlink;
                                return error;
                        }

                        node = symlink;
                } else if (S_ISDIR(mode)) {
                        // directory
                        node = new(std::nothrow) PackageDirectory(fVolume, mode);
                } else
                        RETURN_ERROR(B_BAD_DATA);

                if (node == NULL)
                        RETURN_ERROR(B_NO_MEMORY);

                error = node->Init(parentDir, entry->Name(), fVolume->NextNodeID());
                if (error != B_OK) {
                        delete node;
                        RETURN_ERROR(error);
                }

                // add it to the parent directory
                parentDir->AddChild(node);

                entry->SetUserToken(node);

                return B_OK;
        }

        virtual status_t HandleEntryAttribute(BPackageEntry* entry,
                BPackageEntryAttribute* attribute)
        {
                // attributes aren't needed in the boot loader
                return B_OK;
        }

        virtual status_t HandleEntryDone(BPackageEntry* entry)
        {
                if (entry == fLastSettingsEntryEntry) {
                        fLastSettingsEntryEntry = entry->Parent();
                        fLastSettingsEntry = fLastSettingsEntry->Parent();
                }

                return B_OK;
        }

        virtual status_t HandlePackageAttribute(
                const BPackageInfoAttributeValue& value)
        {
                // TODO?
                return B_OK;
        }

        virtual void HandleErrorOccurred()
        {
                fErrorOccurred = true;
        }

private:
        PackageVolume*                          fVolume;
        const PackageSettingsItem*      fSettingsItem;
        PackageSettingsItem::Entry*     fLastSettingsEntry;
        const BPackageEntry*            fLastSettingsEntryEntry;
        bool                                            fErrorOccurred;
};


// #pragma mark - File


struct File : ::Node {
        File(PackageFile* file)
                :
                fFile(file)
        {
                fFile->Volume()->AcquireReference();
        }

        ~File()
        {
                fFile->Volume()->ReleaseReference();
        }

        virtual ssize_t ReadAt(void* cookie, off_t pos, void* buffer,
                size_t bufferSize)
        {
                off_t size = fFile->Size();
                if (pos < 0 || pos > size)
                        return B_BAD_VALUE;
                if (pos + (off_t)bufferSize > size)
                        bufferSize = size - pos;

                if (bufferSize > 0) {
                        BAbstractBufferedDataReader* dataReader
                                = (BAbstractBufferedDataReader*)cookie;
                        status_t error = dataReader->ReadData(pos, buffer, bufferSize);
                        if (error != B_OK)
                                return error;
                }

                return bufferSize;
        }

        virtual ssize_t WriteAt(void* cookie, off_t pos, const void *buffer,
                size_t bufferSize)
        {
                return B_READ_ONLY_DEVICE;
        }

        virtual status_t GetName(char* nameBuffer, size_t bufferSize) const
        {
                strlcpy(nameBuffer, fFile->Name(), bufferSize);
                return B_OK;
        }

        virtual status_t Open(void** _cookie, int mode)
        {
                if ((mode & O_ACCMODE) != O_RDONLY && (mode & O_ACCMODE) != O_RDWR)
                        return B_NOT_ALLOWED;

                BAbstractBufferedDataReader* dataReader;
                status_t error = fFile->Volume()->CreateFileDataReader(fFile->Data(),
                        dataReader);
                if (error != B_OK)
                        return error;

                *_cookie = dataReader;
                Acquire();
                return B_OK;
        }

        virtual status_t Close(void* cookie)
        {
                BAbstractBufferedDataReader* dataReader
                        = (BAbstractBufferedDataReader*)cookie;
                delete dataReader;
                Release();
                return B_OK;
        }


        virtual int32 Type() const
        {
                return fFile->Mode() & S_IFMT;
        }

        virtual off_t Size() const
        {
                return fFile->Size();
        }

        virtual ino_t Inode() const
        {
                return fFile->NodeID();
        }

private:
        PackageFile*    fFile;
};


// #pragma mark - Symlink


struct Symlink : ::Node {
        Symlink(PackageSymlink* symlink)
                :
                fSymlink(symlink)
        {
                fSymlink->Volume()->AcquireReference();
        }

        ~Symlink()
        {
                fSymlink->Volume()->ReleaseReference();
        }

        virtual ssize_t ReadAt(void* cookie, off_t pos, void* buffer,
                size_t bufferSize)
        {
                return B_BAD_VALUE;
        }

        virtual ssize_t WriteAt(void* cookie, off_t pos, const void *buffer,
                size_t bufferSize)
        {
                return B_READ_ONLY_DEVICE;
        }

        virtual status_t ReadLink(char* buffer, size_t bufferSize)
        {
                const char* path = fSymlink->SymlinkPath();
                size_t size = strlen(path) + 1;

                if (size > bufferSize)
                        return B_BUFFER_OVERFLOW;

                memcpy(buffer, path, size);
                return B_OK;
        }

        virtual status_t GetName(char* nameBuffer, size_t bufferSize) const
        {
                strlcpy(nameBuffer, fSymlink->Name(), bufferSize);
                return B_OK;
        }

        virtual int32 Type() const
        {
                return fSymlink->Mode() & S_IFMT;
        }

        virtual off_t Size() const
        {
                return strlen(fSymlink->SymlinkPath()) + 1;
        }

        virtual ino_t Inode() const
        {
                return fSymlink->NodeID();
        }

private:
        PackageSymlink* fSymlink;
};


// #pragma mark - Directory


struct Directory : ::Directory {
        Directory(PackageDirectory* symlink)
                :
                fDirectory(symlink)
        {
                fDirectory->Volume()->AcquireReference();
        }

        ~Directory()
        {
                fDirectory->Volume()->ReleaseReference();
        }

        void RemoveEntry(const char* path)
        {
                fDirectory->RemoveEntry(path);
        }

        virtual ssize_t ReadAt(void* cookie, off_t pos, void* buffer,
                size_t bufferSize)
        {
                return B_IS_A_DIRECTORY;
        }

        virtual ssize_t WriteAt(void* cookie, off_t pos, const void *buffer,
                size_t bufferSize)
        {
                return B_IS_A_DIRECTORY;
        }

        virtual status_t GetName(char* nameBuffer, size_t bufferSize) const
        {
                strlcpy(nameBuffer, fDirectory->Name(), bufferSize);
                return B_OK;
        }

        virtual int32 Type() const
        {
                return fDirectory->Mode() & S_IFMT;
        }

        virtual ino_t Inode() const
        {
                return fDirectory->NodeID();
        }

        virtual status_t Open(void** _cookie, int mode)
        {
                if ((mode & O_ACCMODE) != O_RDONLY && (mode & O_ACCMODE) != O_RDWR)
                        return B_NOT_ALLOWED;

                Cookie* cookie = new(std::nothrow) Cookie;
                if (cookie == NULL)
                        return B_NO_MEMORY;

                cookie->nextChild = fDirectory->FirstChild();

                Acquire();
                *_cookie = cookie;
                return B_OK;
        }

        virtual status_t Close(void* _cookie)
        {
                Cookie* cookie = (Cookie*)_cookie;
                delete cookie;
                Release();
                return B_OK;
        }

        virtual Node* LookupDontTraverse(const char* name)
        {
                // look up the child
                PackageNode* child = fDirectory->Lookup(name);
                if (child == NULL)
                        return NULL;

                // create the node
                ::Node* node;
                return create_node(child, node) == B_OK ? node : NULL;
        }

        virtual status_t GetNextEntry(void* _cookie, char* nameBuffer,
                size_t bufferSize)
        {
                Cookie* cookie = (Cookie*)_cookie;
                PackageNode* child = cookie->nextChild;
                if (child == NULL)
                        return B_ENTRY_NOT_FOUND;

                cookie->nextChild = fDirectory->NextChild(child);

                strlcpy(nameBuffer, child->Name(), bufferSize);
                return B_OK;
        }

        virtual status_t GetNextNode(void* _cookie, Node** _node)
        {
                Cookie* cookie = (Cookie*)_cookie;
                PackageNode* child = cookie->nextChild;
                if (child == NULL)
                        return B_ENTRY_NOT_FOUND;

                cookie->nextChild = fDirectory->NextChild(child);

                return create_node(child, *_node);
        }

        virtual status_t Rewind(void* _cookie)
        {
                Cookie* cookie = (Cookie*)_cookie;
                cookie->nextChild = NULL;
                return B_OK;
        }

        virtual bool IsEmpty()
        {
                return fDirectory->FirstChild() == NULL;
        }

private:
        struct Cookie {
                PackageNode*    nextChild;
        };


private:
        PackageDirectory*       fDirectory;
};


// #pragma mark -


static status_t
create_node(PackageNode* packageNode, ::Node*& _node)
{
        if (packageNode == NULL)
                return B_BAD_VALUE;

        ::Node* node;
        switch (packageNode->Mode() & S_IFMT) {
                case S_IFREG:
                        node = new(std::nothrow) File(
                                static_cast<PackageFile*>(packageNode));
                        break;
                case S_IFLNK:
                        node = new(std::nothrow) Symlink(
                                static_cast<PackageSymlink*>(packageNode));
                        break;
                case S_IFDIR:
                        node = new(std::nothrow) Directory(
                                static_cast<PackageDirectory*>(packageNode));
                        break;
                default:
                        return B_BAD_VALUE;
        }

        if (node == NULL)
                return B_NO_MEMORY;

        _node = node;
        return B_OK;
}


}       // namespace PackageFS


status_t
packagefs_mount_file(int fd, ::Directory* systemDirectory,
        ::Directory*& _mountedDirectory)
{
        PackageLoaderErrorOutput errorOutput;
        PackageReaderImpl packageReader(&errorOutput);
        status_t error = packageReader.Init(fd, false, 0);
        if (error != B_OK)
                RETURN_ERROR(error);

        // create the volume
        PackageVolume* volume = new(std::nothrow) PackageVolume;
        if (volume == NULL)
                return B_NO_MEMORY;
        BReference<PackageVolume> volumeReference(volume, true);

        error = volume->Init(fd, packageReader.RawHeapReader());
        if (error != B_OK)
                RETURN_ERROR(error);

        // load settings for the package
        PackageSettingsItem* settings = PackageSettingsItem::Load(systemDirectory,
                "haiku");
        ObjectDeleter<PackageSettingsItem> settingsDeleter(settings);

        // parse content -- this constructs the entry/node tree
        PackageLoaderContentHandler handler(volume, settings);
        error = handler.Init();
        if (error != B_OK)
                RETURN_ERROR(error);

        error = packageReader.ParseContent(&handler);
        if (error != B_OK)
                RETURN_ERROR(error);

        // create a VFS node for the root node
        ::Node* rootNode;
        error = create_node(volume->RootDirectory(), rootNode);
        if (error != B_OK)
                RETURN_ERROR(error);

        _mountedDirectory = static_cast< ::Directory*>(rootNode);
        return B_OK;
}


void
packagefs_apply_path_blocklist(::Directory* systemDirectory,
        const PathBlocklist& pathBlocklist)
{
        PackageFS::Directory* directory
                = static_cast<PackageFS::Directory*>(systemDirectory);

        for (PathBlocklist::Iterator it = pathBlocklist.GetIterator();
                BlockedPath* path = it.Next();) {
                directory->RemoveEntry(path->Path());
        }
}