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


#include <ctype.h>
#include <errno.h>
#include <string.h>

#include <new>

#include <KernelExport.h>

#include <AutoDeleter.h>
#include <ddm_modules.h>
#include <disk_device_types.h>

#include <vmdk.h>

//#define TRACE_VMDK 1
#ifdef _BOOT_MODE
#       include <boot/partitions.h>
#       include <util/kernel_cpp.h>
#       undef TRACE_VMDK
#else
#       include <DiskDeviceTypes.h>
#endif

#if TRACE_VMDK
#       define TRACE(x...) dprintf("vmdk: " x)
#else
#       define TRACE(x...) do { } while (false)
#endif


// module name
#define VMDK_PARTITION_MODULE_NAME "partitioning_systems/vmdk/v1"


// #pragma mark - VMDK header/descriptor parsing


static const off_t kMaxDescriptorSize = 64 * 1024;


struct VmdkCookie {
        VmdkCookie(off_t contentOffset, off_t contentSize)
                :
                contentOffset(contentOffset),
                contentSize(contentSize)
        {
        }

        off_t   contentOffset;
        off_t   contentSize;
};


enum {
        TOKEN_END,
        TOKEN_STRING,
        TOKEN_ASSIGN
};

struct Token {
        int                     type;
        size_t          length;
        char            string[1024];

        void SetToEnd()
        {
                type = TOKEN_END;
                string[0] = '\0';
                length = 0;
        }

        void SetToAssign()
        {
                type = TOKEN_ASSIGN;
                string[0] = '=';
                string[1] = '\0';
                length = 0;
        }

        void SetToString()
        {
                type = TOKEN_STRING;
                string[0] = '\0';
                length = 0;
        }

        void PushChar(char c)
        {
                if (length + 1 < sizeof(string)) {
                        string[length++] = c;
                        string[length] = '\0';
                }
        }

        bool operator==(const char* other) const
        {
                return strcmp(string, other) == 0;
        }

        bool operator!=(const char* other) const
        {
                return !(*this == other);
        }
};


static status_t
read_file(int fd, off_t offset, void* buffer, size_t size)
{
        ssize_t bytesRead = pread(fd, buffer, size, offset);
        if (bytesRead < 0)
                return errno;

        return (size_t)bytesRead == size ? B_OK : B_ERROR;
}


static int
next_token(char*& line, const char* lineEnd, Token& token)
{
        // skip whitespace
        while (line != lineEnd && isspace(*line))
                line++;

        // comment/end of line
        if (line == lineEnd || *line == '#') {
                token.SetToEnd();
                return token.type;
        }

        switch (*line) {
                case '=':
                {
                        line++;
                        token.SetToAssign();
                        return token.type;
                }

                case '"':
                {
                        // quoted string
                        token.SetToString();
                        line++;
                        while (line != lineEnd) {
                                if (*line == '"') {
                                        // end of string
                                        line++;
                                        break;
                                }

                                if (*line == '\\') {
                                        // escaped char
                                        line++;
                                        if (line == lineEnd)
                                                break;
                                }

                                token.PushChar(*(line++));
                        }

                        return token.type;
                }

                default:
                {
                        // unquoted string
                        token.SetToString();
                        while (line != lineEnd && *line != '#' && *line != '='
                                && !isspace(*line)) {
                                token.PushChar(*(line++));
                        }
                        return token.type;
                }
        }
}


static status_t
parse_vmdk_header(int fd, off_t fileSize, VmdkCookie*& _cookie)
{
        // read the header
        SparseExtentHeader header;
        status_t error = read_file(fd, 0, &header, sizeof(header));
        if (error != B_OK)
                return error;

        // check the header
        if (header.magicNumber != VMDK_SPARSE_MAGICNUMBER) {
                TRACE("Error: Header magic mismatch!\n");
                return B_BAD_DATA;
        }

        if (header.version != VMDK_SPARSE_VERSION) {
                TRACE("Error: Header version mismatch!\n");
                return B_BAD_DATA;
        }

        if (header.overHead > (uint64_t)fileSize / 512) {
                TRACE("Error: Header overHead invalid!\n");
                return B_BAD_DATA;
        }
        off_t headerSize = header.overHead * 512;

        if (header.descriptorOffset < (sizeof(header) + 511) / 512
                || header.descriptorOffset >= header.overHead
                || header.descriptorSize == 0
                || header.overHead - header.descriptorOffset < header.descriptorSize) {
                TRACE("Error: Invalid descriptor location!\n");
                return B_BAD_DATA;
        }
        off_t descriptorOffset = header.descriptorOffset * 512;
        off_t descriptorSize = header.descriptorSize * 512;

        if (descriptorSize > kMaxDescriptorSize) {
                TRACE("Error: Unsupported descriptor size!\n");
                return B_UNSUPPORTED;
        }

        // read descriptor
        char* descriptor = (char*)malloc(descriptorSize + 1);
        if (descriptor == NULL) {
                TRACE("Error: Descriptor allocation failed!\n");
                return B_NO_MEMORY;
        }
        MemoryDeleter descriptorDeleter(descriptor);

        error = read_file(fd, descriptorOffset, descriptor, descriptorSize);
        if (error != B_OK)
                return error;

        // determine the actual descriptor size
        descriptor[descriptorSize] = '\0';
        descriptorSize = strlen(descriptor);

        // parse descriptor
        uint64_t extendOffset = 0;
        uint64_t extendSize = 0;

        char* line = descriptor;
        char* descriptorEnd = line + descriptorSize;
        while (line < descriptorEnd) {
                // determine the end of the line
                char* lineEnd = strchr(line, '\n');
                if (lineEnd != NULL)
                        *lineEnd = '\0';
                else
                        lineEnd = descriptorEnd;

                Token token;
                if (next_token(line, lineEnd, token) == TOKEN_END) {
                        line = lineEnd + 1;
                        continue;
                }

                Token token2;
                switch (next_token(line, lineEnd, token2)) {
                        case TOKEN_END:
                                break;

                        case TOKEN_ASSIGN:
                                if (next_token(line, lineEnd, token2) != TOKEN_STRING) {
                                        TRACE("Line not understood: %s = ?\n", token.string);
                                        break;
                                }

                                if (token == "version") {
                                        if (token2 != "1") {
                                                TRACE("Unsupported descriptor version: %s\n",
                                                        token2.string);
                                                return B_UNSUPPORTED;
                                        }
                                } else if (token == "createType") {
                                        if (token2 != "monolithicFlat") {
                                                TRACE("Unsupported descriptor createType: %s\n",
                                                        token2.string);
                                                return B_UNSUPPORTED;
                                        }
                                }

                                break;

                        case TOKEN_STRING:
                                if (token != "RW")
                                        break;

                                extendSize = strtoll(token2.string, NULL, 0);
                                if (extendSize == 0) {
                                        TRACE("Bad extend size.\n");
                                        return B_BAD_DATA;
                                }

                                if (next_token(line, lineEnd, token) != TOKEN_STRING
                                        || token != "FLAT"
                                        || next_token(line, lineEnd, token) != TOKEN_STRING
                                                // image name
                                        || next_token(line, lineEnd, token2) != TOKEN_STRING) {
                                        TRACE("Invalid/unsupported extend line\n");
                                        break;
                                }

                                extendOffset = strtoll(token2.string, NULL, 0);
                                if (extendOffset == 0) {
                                        TRACE("Bad extend offset.\n");
                                        return B_BAD_DATA;
                                }

                                break;
                }

                line = lineEnd + 1;
        }

        if (extendOffset < (uint64_t)headerSize / 512
                || extendOffset >= (uint64_t)fileSize / 512
                || extendSize == 0
                || (uint64_t)fileSize / 512 - extendOffset < extendSize) {
                TRACE("Error: Invalid extend location!\n");
                return B_BAD_DATA;
        }

        TRACE("descriptor len: %lld\n", descriptorSize);
        TRACE("header size:    %lld\n", headerSize);
        TRACE("file size:      %lld\n", fileSize);
        TRACE("extend offset:  %lld\n", extendOffset * 512);
        TRACE("extend size:    %lld\n", extendSize * 512);

        VmdkCookie* cookie = new(std::nothrow) VmdkCookie(extendOffset * 512,
                extendSize * 512);
        if (cookie == NULL)
                return B_NO_MEMORY;

        _cookie = cookie;
        return B_OK;
}


// #pragma mark - module hooks


static status_t
vmdk_std_ops(int32 op, ...)
{
        TRACE("vmdk_std_ops(0x%lx)\n", op);
        switch(op) {
                case B_MODULE_INIT:
                case B_MODULE_UNINIT:
                        return B_OK;
        }
        return B_ERROR;
}


static float
vmdk_identify_partition(int fd, partition_data* partition, void** _cookie)
{
        TRACE("vmdk_identify_partition(%d, %ld: %lld, %lld, %ld)\n", fd,
                partition->id, partition->offset, partition->size,
                partition->block_size);

        VmdkCookie* cookie;
        status_t error = parse_vmdk_header(fd, partition->size, cookie);
        if (error != B_OK)
                return -1;

        *_cookie = cookie;
        return 0.8f;
}


static status_t
vmdk_scan_partition(int fd, partition_data* partition, void* _cookie)
{
        TRACE("vmdk_scan_partition(%d, %ld: %lld, %lld, %ld)\n", fd,
                partition->id, partition->offset, partition->size,
                partition->block_size);

        VmdkCookie* cookie = (VmdkCookie*)_cookie;
        ObjectDeleter<VmdkCookie> cookieDeleter(cookie);

        // fill in the partition_data structure
        partition->status = B_PARTITION_VALID;
        partition->flags |= B_PARTITION_PARTITIONING_SYSTEM;
        partition->content_size = partition->size;
        // (no content_name and content_parameters)
        // (content_type is set by the system)
        partition->content_cookie = cookie;

        // child
        partition_data* child = create_child_partition(partition->id, 0,
                partition->offset + cookie->contentOffset, cookie->contentSize, -1);
        if (child == NULL) {
                partition->content_cookie = NULL;
                return B_ERROR;
        }

        child->block_size = partition->block_size;
        // (no name)
        child->type = strdup(kPartitionTypeUnrecognized);
        child->parameters = NULL;
        child->cookie = NULL;

        // check for allocation problems
        if (child->type == NULL) {
                partition->content_cookie = NULL;
                return B_NO_MEMORY;
        }

        cookieDeleter.Detach();
        return B_OK;
}


static void
vmdk_free_identify_partition_cookie(partition_data*/* partition*/, void* cookie)
{
        delete (VmdkCookie*)cookie;
}


static void
vmdk_free_partition_cookie(partition_data* partition)
{
        // called for the child partition -- it doesn't have a cookie
}


static void
vmdk_free_partition_content_cookie(partition_data* partition)
{
        delete (VmdkCookie*)partition->content_cookie;
}


#ifdef _BOOT_MODE
partition_module_info gVMwarePartitionModule =
#else
static partition_module_info vmdk_partition_module =
#endif
{
        {
                VMDK_PARTITION_MODULE_NAME,
                0,
                vmdk_std_ops
        },
        "vmdk",                                                         // short_name
        VMDK_PARTITION_NAME,                            // pretty_name

        // flags
        0,

        // scanning
        vmdk_identify_partition,                                // identify_partition
        vmdk_scan_partition,                                    // scan_partition
        vmdk_free_identify_partition_cookie,    // free_identify_partition_cookie
        vmdk_free_partition_cookie,                             // free_partition_cookie
        vmdk_free_partition_content_cookie,             // free_partition_content_cookie

#ifdef _BOOT_MODE
        NULL
#endif  // _BOOT_MODE
};


#ifndef _BOOT_MODE
extern "C" partition_module_info* modules[];
_EXPORT partition_module_info* modules[] =
{
        &vmdk_partition_module,
        NULL
};
#endif