/*
 * Copyright 2007-2009, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2002, Tyler Dauwalder.
 *
 * This file may be used under the terms of the MIT License.
 */

/*!
        <h5>iso9660</h5>
        The standard to which this module is written is ECMA-119 second
        edition, a freely available iso9660 equivalent.

        <h5>Joliet</h5>
        Joliet support comes courtesy of the following document:

        http://www-plateau.cs.berkeley.edu/people/chaffee/jolspec.htm

        As specified there, the existence of any of the following escape
        sequences in a supplementary volume descriptor's "escape sequences"
        field denotes a Joliet volume descriptor using unicode ucs-2
        character encoding (2-byte characters, big-endian):

        - UCS-2 Level 1: 0x252F40 == "%/@"
        - UCS-2 Level 2: 0x252F43 == "%/C"
        - UCS-2 Level 3: 0x252F45 == "%/E"

        The following UCS-2 characters are considered illegal (we allow them,
        printing out a warning if encountered):

        - All values between 0x0000 and 0x001f inclusive == control chars
        - 0x002A == '*'
        - 0x002F == '/'
        - 0x003A == ':'
        - 0x003B == ';'
        - 0x003F == '?'
        - 0x005C == '\'
*/

#include "iso9660_identify.h"

#ifndef FS_SHELL
#       include <errno.h>
#       include <stdlib.h>
#       include <string.h>
#       include <unistd.h>
#       include <stdio.h>

#       include <ByteOrder.h>
#       include <fs_info.h>
#       include <KernelExport.h>
#endif

#include "iso9660.h"

//#define TRACE(x) ;
#define TRACE(x) dprintf x


static const char *kISO9660Signature = "CD001";
static const uint32 kVolumeDescriptorLength = 2048;
#define ISO9660_VOLUME_IDENTIFIER_LENGTH 32
#define ISO9660_ESCAPE_SEQUENCE_LENGTH 32

//! Volume descriptor types
typedef enum {
        ISO9660VD_BOOT,
        ISO9660VD_PRIMARY,
        ISO9660VD_SUPPLEMENTARY,
        ISO9660VD_PARTITION,
        ISO9660VD_TERMINATOR = 255
} iso9660_descriptor_type;

/*! \brief The portion of the volume descriptor common to all
    descriptor types.
*/
typedef struct iso9660_common_descriptor {
        uint8   type;
        char    standard_identifier[5]; // should be 'CD001'
        uint8   version;
        // Remaining bytes are unused
} __attribute__((packed)) iso9660_common_volume_descriptor;

typedef struct iso9660_volume_descriptor {
        iso9660_common_descriptor common;
        uint8   flags;
        char    system_identifier[32];
        char    identifier[ISO9660_VOLUME_IDENTIFIER_LENGTH];
        uint8   _reserved0[8];
        uint32  size;
        uint32  size_big_endian;
        char    escape_sequences[ISO9660_ESCAPE_SEQUENCE_LENGTH];
                                // unused on primary descriptor
        uint16  set_size;
        uint16  set_size_big_endian;
        uint16  sequence_number;
        uint16  sequence_number_big_endian;
        uint16  logical_block_size;
        uint16  logical_block_size_big_endian;
        uint32  path_table_size;
        uint32  path_table_size_big_endian;
        uint32  _reserved1[4];
        uint8   root_directory_record[34];
        char    set_identifier[28];
        // Remaining bytes are disinteresting to us
} __attribute__((packed)) iso9660_volume_descriptor;

typedef struct iso9660_directory_record {
        uint8   length;
        uint8   extended_attribute_record_length;
        uint32  location;
        uint32  location_big_endian;
        uint32  data_length;
        uint8   _reserved[14];
        uint16  volume_space;
} __attribute__((packed)) iso9660_directory_record;


static void dump_directory_record(iso9660_directory_record *record,
        const char *indent);


//      #pragma mark -


/*! \brief Creates a new iso9660_info struct with empty volume names.

        \note Use the applicable set_XYZ_volume_name() functions rather than
        messing with the volume name data members directly.
*/
iso9660_info::iso9660_info()
        :
        iso9660_name(NULL),
        joliet_name(NULL)
{
}


iso9660_info::~iso9660_info()
{
        free(iso9660_name);
        free(joliet_name);
}


/*! \brief Returns true if a valid volume name exists.
*/
bool
iso9660_info::IsValid()
{
        return iso9660_name != NULL || joliet_name != NULL;
}


/*! \brief Sets the iso9660 volume name.

        \param name UTF-8 string containing the name.
        \param length The length (in bytes) of the string.
*/
void
iso9660_info::SetISO9660Name(const char *name, uint32 length)
{
        _SetString(&iso9660_name, name, length);
}


/*! \brief Sets the Joliet volume name.

        \param name UTF-8 string containing the name.
        \param length The length (in bytes) of the string.
*/
void
iso9660_info::SetJolietName(const char *name, uint32 length)
{
        _SetString(&joliet_name, name, length);
}


/*! \brief Returns the volume name of highest precedence.

        Currently, the ordering is (decreasingly):
        - Joliet
        - iso9660
*/
const char*
iso9660_info::PreferredName()
{
        if (joliet_name)
                return joliet_name;

        return iso9660_name;
}


/*! \brief Copies the given string into the old string, managing memory
        deallocation and allocation as necessary.
*/
void
iso9660_info::_SetString(char **string, const char *newString,
        uint32 newLength)
{
        if (string == NULL)
                return;

        TRACE(("iso9660_info::set_string(%p ('%s'), '%s', %u)\n", string,
                *string, newString, (unsigned)newLength));

        char *&oldString = *string;
        free(oldString);

        if (newString) {
                oldString = (char*)malloc(newLength + 1);
                if (oldString != NULL) {
                        memcpy(oldString, newString, newLength);
                        oldString[newLength] = '\0';
                }
        } else
                oldString = NULL;
}


//      #pragma mark - C functions


/*! \brief Converts the given unicode character to utf8.
*/
static void
unicode_to_utf8(uint32 c, char **out)
{
        char *s = *out;

        if (c < 0x80)
                *(s++) = c;
        else if (c < 0x800) {
                *(s++) = 0xc0 | (c >> 6);
                *(s++) = 0x80 | (c & 0x3f);
        } else if (c < 0x10000) {
                *(s++) = 0xe0 | (c >> 12);
                *(s++) = 0x80 | ((c >> 6) & 0x3f);
                *(s++) = 0x80 | (c & 0x3f);
        } else if (c <= 0x10ffff) {
                *(s++) = 0xf0 | (c >> 18);
                *(s++) = 0x80 | ((c >> 12) & 0x3f);
                *(s++) = 0x80 | ((c >> 6) & 0x3f);
                *(s++) = 0x80 | (c & 0x3f);
        }
        *out = s;
}


static const char*
descriptor_type_to_string(iso9660_descriptor_type type)
{
        switch (type) {
                case ISO9660VD_BOOT:
                        return "boot";
                case ISO9660VD_PRIMARY:
                        return "primary";
                case ISO9660VD_SUPPLEMENTARY:
                        return "supplementary";
                case ISO9660VD_PARTITION:
                        return "partiton";
                case ISO9660VD_TERMINATOR:
                        return "terminator";
                default:
                        return "invalid";
        }
}


static void
dump_common_descriptor(iso9660_common_descriptor *common,
        const char *indent, bool printHeader)
{
        if (printHeader)
                TRACE(("%siso9660_common_descriptor:\n", indent));

        TRACE(("%s  volume descriptor type: %d (%s)\n", indent,
                common->type, descriptor_type_to_string(
                        (iso9660_descriptor_type)common->type)));
        TRACE(("%s  standard identifier:    %.5s (%s)\n", indent,
                common->standard_identifier,
                strncmp(common->standard_identifier, kISO9660Signature, 5) == 0
                        ? "valid" : "INVALID"));
        TRACE(("%s  version:                %d\n", indent, common->version));
}


static void
dump_primary_descriptor(iso9660_volume_descriptor *primary,
        const char *indent, bool printHeader)
{
        if (printHeader)
                TRACE(("%siso9660_primary_descriptor:\n", indent));

        dump_common_descriptor(&primary->common, indent, false);
        TRACE(("%s  identifier:             '%.32s'\n", indent,
                primary->identifier));
        TRACE(("%s  size:                   %d\n", indent,
                (int)B_LENDIAN_TO_HOST_INT32(primary->size)));
        TRACE(("%s  set size:               %d\n", indent,
                (int)B_LENDIAN_TO_HOST_INT32(primary->set_size)));
        TRACE(("%s  sequence number:        %d\n", indent,
                (int)B_LENDIAN_TO_HOST_INT32(primary->sequence_number)));
        TRACE(("%s  logical block size:     %d\n", indent,
                (int)B_LENDIAN_TO_HOST_INT32(primary->logical_block_size)));
        TRACE(("%s  path table size:        %d\n", indent,
                (int)B_LENDIAN_TO_HOST_INT32(primary->path_table_size)));
        TRACE(("%s  set identifier:         %.28s\n", indent,
                primary->set_identifier));
        dump_directory_record((iso9660_directory_record*)
                primary->root_directory_record, indent);
}


static void
dump_supplementary_descriptor(iso9660_volume_descriptor *supplementary,
        const char *indent, bool printHeader)
{
        if (printHeader)
                TRACE(("%siso9660_supplementary_descriptor:\n", indent));

        dump_primary_descriptor(supplementary, indent, false);
        TRACE(("%s  escape sequences:      ", indent));
        for (int i = 0; i < ISO9660_ESCAPE_SEQUENCE_LENGTH; i++) {
                TRACE((" %2x", supplementary->escape_sequences[i]));
                if (i == ISO9660_ESCAPE_SEQUENCE_LENGTH / 2 - 1)
                        TRACE(("\n                          "));
        }
        TRACE(("\n"));
}


static void
dump_directory_record(iso9660_directory_record *record, const char *indent)
{
        TRACE(("%s  root directory record:\n", indent));
        TRACE(("%s    length:               %d\n", indent, record->length));
        TRACE(("%s    location:             %d\n", indent,
                (int)B_LENDIAN_TO_HOST_INT32(record->location)));
        TRACE(("%s    data length:          %d\n", indent,
                (int)B_LENDIAN_TO_HOST_INT32(record->data_length)));
        TRACE(("%s    volume space:         %d\n", indent,
                B_LENDIAN_TO_HOST_INT16(record->volume_space)));
}


static status_t
check_common_descriptor(iso9660_common_descriptor *common)
{
        if (common == NULL)
                return B_BAD_VALUE;

        return strncmp(common->standard_identifier, kISO9660Signature, 5) == 0
                ? B_OK : B_BAD_DATA;
}


//      #pragma mark - Public functions


// iso9660_fs_identify
/*! \brief Returns true if the given partition is a valid iso9660 partition.

        See fs_identify_hook() for more information.

        \todo Fill in partitionInfo->mounted_at with something useful.
*/
status_t
iso9660_fs_identify(int deviceFD, iso9660_info *info)
{
        char buffer[ISO_PVD_SIZE];
        bool exit = false;
        bool found = false;
        status_t error = B_OK;

        TRACE(("identify(%d, %p)\n", deviceFD, info));
        off_t offset = 0x8000;

        // Read through the volume descriptors looking for a primary descriptor.
        // If for some reason there are more than one primary descriptor, the
        // volume name from the last encountered descriptor will be used.
        while (!error && !exit) {// && count++ < 10) {
                iso9660_common_descriptor *common = NULL;

                // Read the block containing the current descriptor
                error = read_pos(deviceFD, offset, (void *)&buffer, ISO_PVD_SIZE);
                offset += ISO_PVD_SIZE;
                if (error < ISO_PVD_SIZE)
                        break;

                common = (iso9660_common_descriptor*)buffer;
                error = check_common_descriptor(common);
                if (error < B_OK)
                        break;

//              dump_common_descriptor(common, "", true);

                // Handle each type of descriptor appropriately
                TRACE(("found %s descriptor\n", descriptor_type_to_string(
                        (iso9660_descriptor_type)common->type)));
                found = true;

                switch (common->type) {
                        case ISO9660VD_BOOT:
                                break;

                        case ISO9660VD_PRIMARY:
                        {
                                iso9660_volume_descriptor *primary
                                        = (iso9660_volume_descriptor*)buffer;
                                int i;

                                dump_primary_descriptor(primary, "  ", true);

                                // Cut off any trailing spaces from the volume id. Note
                                // that this allows for spaces INSIDE the volume id, even
                                // though that's not technically allowed by the standard;
                                // this was necessary to support certain RedHat 6.2 CD-ROMs
                                // from a certain Linux company who shall remain unnamed. ;-)
                                for (i = ISO9660_VOLUME_IDENTIFIER_LENGTH - 1; i >= 0;
                                                i--) {
                                        if (primary->identifier[i] != 0x20)
                                                break;
                                }

                                // Give a holler if the iso9660 name is already set
                                if (info->iso9660_name) {
                                        char name[ISO9660_VOLUME_IDENTIFIER_LENGTH + 1];
                                        strlcpy(name, primary->identifier, i + 1);
                                        TRACE(("duplicate iso9660 volume name found, using "
                                                "latter (`%s') instead of former (`%s')\n", name,
                                                info->iso9660_name));
                                }

                                info->SetISO9660Name(primary->identifier, i + 1);
                                info->max_blocks = B_LENDIAN_TO_HOST_INT32(primary->set_size);
                                break;
                        }

                        case ISO9660VD_SUPPLEMENTARY:
                        {
                                iso9660_volume_descriptor *supplementary
                                        = (iso9660_volume_descriptor*)buffer;
                                dump_supplementary_descriptor(supplementary, "  ", true);

                                // Copy and null terminate the escape sequences
                                char escapes[ISO9660_ESCAPE_SEQUENCE_LENGTH + 1];
                                strlcpy(escapes, supplementary->escape_sequences,
                                        ISO9660_ESCAPE_SEQUENCE_LENGTH + 1);

                                // Check for a Joliet VD
                                if (strstr(escapes, "%/@") || strstr(escapes, "%/C")
                                        || strstr(escapes, "%/E")) {
                                        char name[(ISO9660_VOLUME_IDENTIFIER_LENGTH * 3 / 2) + 1];
                                                // Since we're dealing with 16-bit Unicode, each
                                                // UTF-8 sequence will be at most 3 bytes long.
                                        char *pos = name;
                                        uint16 ch;

                                        // Walk thru the unicode volume name, converting to utf8 as we go.
                                        for (int i = 0; (ch = B_BENDIAN_TO_HOST_INT16(
                                                                ((uint16*)supplementary->identifier)[i]))
                                                        && i < ISO9660_VOLUME_IDENTIFIER_LENGTH; i++) {
                                                // Give a warning if the character is technically
                                                // illegal
                                                if (ch <= 0x001F || ch == '*' || ch == '/'
                                                    || ch == ':' || ch == ';'
                                                    || ch == '?' || ch == '\\') {
                                                        TRACE(("warning: illegal Joliet character "
                                                                "found: 0%4x\n", ch));
                                                }

                                                // Convert to utf-8
                                                unicode_to_utf8(ch, &pos);
                                        }
                                        pos[0] = '\0';

                                        // Give a holler if the joliet name is already set
                                        if (info->joliet_name) {
                                                TRACE(("duplicate joliet volume name found, using "
                                                        "latter (`%s') instead of former (`%s')\n",
                                                        name, info->joliet_name));
                                        }

                                        info->SetJolietName(name, pos - name);
                                }
                                break;
                        }

                        case ISO9660VD_PARTITION:
                                break;

                        case ISO9660VD_TERMINATOR:
                                exit = true;
                                break;

                        default:
                                break;
                }
        }

        return found ? B_OK : error;
}