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


#ifdef BUILDING_FS_SHELL
#       include "compat.h"
#       define B_OK                     0
#       define B_FILE_ERROR     EBADF
#else
#       include <BeOSBuildCompatibility.h>
#endif

#include "fs_descriptors.h"

#include <map>

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <fs_attr.h>

#include <syscalls.h>

#include "fs_impl.h"

using std::map;

static const int kVirtualDescriptorStart = 10000;

typedef map<int, BPrivate::Descriptor*> DescriptorMap;
static DescriptorMap *sDescriptors;

namespace BPrivate {


static int
dup_maybe_system(int fd)
{
        if (get_descriptor(fd) != NULL)
                return _kern_dup(fd);

        int clonedFD = dup(fd);
        return clonedFD >= 0 ? clonedFD : errno;
}


static status_t
close_maybe_system(int fd)
{
        if (get_descriptor(fd) != NULL)
                return _kern_close(fd);

        return close(fd) == 0 ? B_OK : errno;
}


// #pragma mark - Descriptor


// constructor
Descriptor::~Descriptor()
{
}

// IsSystemFD
bool
Descriptor::IsSystemFD() const
{
        return false;
}

// GetPath
status_t
Descriptor::GetPath(string& path) const
{
        return get_path(fd, NULL, path);
}

// GetNodeRef
status_t
Descriptor::GetNodeRef(NodeRef &ref)
{
        struct stat st;
        status_t error = GetStat(false, &st);
        if (error != B_OK)
                return error;

        ref = NodeRef(st);

        return B_OK;
}


// #pragma mark - FileDescriptor


// constructor
FileDescriptor::FileDescriptor(int fd)
{
        this->fd = fd;
}

// destructor
FileDescriptor::~FileDescriptor()
{
        Close();
}

// Close
status_t
FileDescriptor::Close()
{
        if (fd >= 0) {
                int oldFD = fd;
                fd = -1;
                if (close(oldFD) < 0)
                        return errno;
        }

        return B_OK;
}

// Dup
status_t
FileDescriptor::Dup(Descriptor *&clone)
{
        int dupFD = dup(fd);
        if (dupFD < 0)
                return errno;

        clone = new FileDescriptor(dupFD);
        return B_OK;
}

// GetStat
status_t
FileDescriptor::GetStat(bool traverseLink, struct stat *st)
{
        if (fstat(fd, st) < 0)
                return errno;
        return B_OK;
}

// IsSystemFD
bool
FileDescriptor::IsSystemFD() const
{
        return true;
}


// #pragma mark - DirectoryDescriptor


// constructor
DirectoryDescriptor::DirectoryDescriptor(DIR *dir, const NodeRef &ref)
{
        this->dir = dir;
        this->ref = ref;
}

// destructor
DirectoryDescriptor::~DirectoryDescriptor()
{
        Close();
}

// Close
status_t
DirectoryDescriptor::Close()
{
        if (dir) {
                DIR *oldDir = dir;
                dir = NULL;
                if (closedir(oldDir) < 0)
                        return errno;
        }

        return B_OK;
}

// Dup
status_t
DirectoryDescriptor::Dup(Descriptor *&clone)
{
        string path;
        status_t error = get_path(fd, NULL, path);
        if (error != B_OK)
                return error;

        DIR *dupDir = opendir(path.c_str());
        if (!dupDir)
                return errno;

        clone = new DirectoryDescriptor(dupDir, ref);
        return B_OK;
}

// GetStat
status_t
DirectoryDescriptor::GetStat(bool traverseLink, struct stat *st)
{
        // get a usable path
        string realPath;
        status_t error = get_path(fd, NULL, realPath);
        if (error != B_OK)
                return error;

        // stat
        int result;
        result = stat(realPath.c_str(), st);

        if (result < 0)
                return errno;

        return B_OK;
}

// GetNodeRef
status_t
DirectoryDescriptor::GetNodeRef(NodeRef &ref)
{
        ref = this->ref;

        return B_OK;
}


// #pragma mark - SymlinkDescriptor


// constructor
SymlinkDescriptor::SymlinkDescriptor(const char *path)
{
        this->path = path;
}

// Close
status_t
SymlinkDescriptor::Close()
{
        return B_OK;
}

// Dup
status_t
SymlinkDescriptor::Dup(Descriptor *&clone)
{
        clone = new SymlinkDescriptor(path.c_str());
        return B_OK;
}

// GetStat
status_t
SymlinkDescriptor::GetStat(bool traverseLink, struct stat *st)
{
        // stat
        int result;
        if (traverseLink)
                result = stat(path.c_str(), st);
        else
                result = lstat(path.c_str(), st);

        if (result < 0)
                return errno;

        return B_OK;
}

// GetPath
status_t
SymlinkDescriptor::GetPath(string& path) const
{
        path = this->path;
        return B_OK;
}


// #pragma mark - AttributeDescriptor


AttributeDescriptor::AttributeDescriptor(int fileFD, const char* attribute,
        uint32 type, int openMode)
        :
        fFileFD(dup_maybe_system(fileFD)),
        fType(type),
        fOpenMode(openMode),
        fData(NULL),
        fDataSize(0)

{
        strlcpy(fAttribute, attribute, sizeof(fAttribute));
}


AttributeDescriptor::~AttributeDescriptor()
{
        Close();
}


status_t
AttributeDescriptor::Init()
{
        if (fFileFD < 0)
                return B_IO_ERROR;

        // stat the attribute
        attr_info info;
        if (fs_stat_attr(fFileFD, fAttribute, &info) < 0) {
                if (errno == B_ENTRY_NOT_FOUND) {
                        if ((fOpenMode & O_CREAT) == 0)
                                return errno;

                        // create the attribute
                        if (fs_write_attr(fFileFD, fAttribute, fType, 0, NULL, 0) < 0)
                                return errno;
                        return B_OK;
                }
                return errno;
        }

        if ((fOpenMode & O_TRUNC) == 0) {
                // truncate the attribute
                if (fs_write_attr(fFileFD, fAttribute, fType, 0, NULL, 0) < 0)
                        return errno;
                return B_OK;
        }

        // we have to read in the attribute data
        if (info.size == 0)
                return B_OK;

        fData = (uint8*)malloc(info.size);
        if (fData == NULL)
                return B_NO_MEMORY;

        fDataSize = info.size;

        ssize_t bytesRead = fs_read_attr(fFileFD, fAttribute, fType, 0, fData,
                fDataSize);
        if (bytesRead < 0)
                return errno;
        if ((size_t)bytesRead != fDataSize)
                return B_IO_ERROR;

        return B_OK;
}


status_t
AttributeDescriptor::Write(off_t offset, const void* buffer, size_t bufferSize)
{
        if (offset < 0)
                return B_BAD_VALUE;

        if ((fOpenMode & O_ACCMODE) != O_WRONLY
                && (fOpenMode & O_ACCMODE) != O_RDWR) {
                return B_NOT_ALLOWED;
        }

        // we may need to resize the buffer
        size_t minSize = (size_t)offset + bufferSize;
        if (minSize > fDataSize) {
                uint8* data = (uint8*)realloc(fData, minSize);
                if (data == NULL)
                        return B_NO_MEMORY;

                if ((size_t)offset > fDataSize)
                        memset(data + offset, 0, offset - fDataSize);

                fData = data;
                fDataSize = minSize;
        }

        // copy the data and write all of it
        if (bufferSize == 0)
                return B_OK;

        memcpy((uint8*)fData + offset, buffer, bufferSize);

        ssize_t bytesWritten = fs_write_attr(fFileFD, fAttribute, fType, 0,
                fData, fDataSize);
        if (bytesWritten < 0)
                return errno;
        if ((size_t)bytesWritten != fDataSize)
                return B_IO_ERROR;

        return B_OK;
}


status_t
AttributeDescriptor::Close()
{
        if (fFileFD < 0)
                return B_BAD_VALUE;

        close_maybe_system(fFileFD);
        fFileFD = -1;

        free(fData);
        fData = NULL;
        fDataSize = 0;

        return B_OK;
}


status_t
AttributeDescriptor::Dup(Descriptor*& clone)
{
        return B_NOT_SUPPORTED;
}


status_t
AttributeDescriptor::GetStat(bool traverseLink, struct stat* st)
{
        return B_NOT_SUPPORTED;
}


// #pragma mark - AttrDirDescriptor


// constructor
AttrDirDescriptor::AttrDirDescriptor(DIR *dir, const NodeRef &ref)
        : DirectoryDescriptor(dir, ref)
{
}

// destructor
AttrDirDescriptor::~AttrDirDescriptor()
{
        Close();
}

// Close
status_t
AttrDirDescriptor::Close()
{
        if (dir) {
                DIR *oldDir = dir;
                dir = NULL;
                if (fs_close_attr_dir(oldDir) < 0)
                        return errno;
        }

        return B_OK;
}

// Dup
status_t
AttrDirDescriptor::Dup(Descriptor *&clone)
{
        // we don't allow dup()int attr dir descriptors
        return B_FILE_ERROR;
}

// GetStat
status_t
AttrDirDescriptor::GetStat(bool traverseLink, struct stat *st)
{
        // we don't allow stat()int attr dir descriptors
        return B_FILE_ERROR;
}

// GetNodeRef
status_t
AttrDirDescriptor::GetNodeRef(NodeRef &ref)
{
        ref = this->ref;

        return B_OK;
}


// get_descriptor
Descriptor *
get_descriptor(int fd)
{
        if (!sDescriptors)
                return NULL;
        DescriptorMap::iterator it = sDescriptors->find(fd);
        if (it == sDescriptors->end())
                return NULL;
        return it->second;
}

// add_descriptor
int
add_descriptor(Descriptor *descriptor)
{
        if (!sDescriptors)
                sDescriptors = new DescriptorMap;

        int fd = -1;
        if (FileDescriptor *file = dynamic_cast<FileDescriptor*>(descriptor)) {
                fd = file->fd;
        } else {
                // find a free slot
                for (fd = kVirtualDescriptorStart;
                        sDescriptors->find(fd) != sDescriptors->end();
                        fd++) {
                }
        }

        (*sDescriptors)[fd] = descriptor;
        descriptor->fd = fd;

        return fd;
}

// delete_descriptor
status_t
delete_descriptor(int fd)
{
        DescriptorMap::iterator it = sDescriptors->find(fd);
        if (it == sDescriptors->end())
                return B_FILE_ERROR;

        status_t error = it->second->Close();
        delete it->second;
        sDescriptors->erase(it);

        if (sDescriptors->size() == 0) {
                delete sDescriptors;
                sDescriptors = NULL;
        }
        return error;
}


bool
is_unknown_or_system_descriptor(int fd)
{
        Descriptor* descriptor = get_descriptor(fd);
        return descriptor == NULL || descriptor->IsSystemFD();
}


} // namespace BPrivate