/*
** The Sleuth Kit
**
** Copyright (c) 2013 Basis Technology Corp.  All rights reserved
** Contact: Brian Carrier [carrier <at> sleuthkit [dot] org]
**
** This software is distributed under the Common Public License 1.0
**
*/

/**
 * \file fatfs_utils.c
 * Contains utility functions for processing FAT file systems. 
 */

#include "tsk_fs_i.h"
#include "tsk_fatfs.h"
#include <assert.h>

/**
 * \internal
 * Tests whether a pointer argument is set to NULL. If the pointer is NULL,
 * sets a TSK_ERR_FS_ARG error with an error message that includes a parameter
 * name and a function name supplied by the caller.
 *
 * @param a_ptr The pointer to test for NULL.
 * @param a_param_name The name of the parameter for which the pointer was
 * passed as an argument.
 * @param a_func_name The name of the function for which a_param is a 
 * parameter.
 * @return Returns 1 if the pointer is NULL, 0 otherwise.
 */
uint8_t
fatfs_ptr_arg_is_null(void *a_ptr, const char *a_param_name, const char *a_func_name)
{
    const char *func_name = "fatfs_ptr_arg_is_null";

    assert(a_param_name != NULL);
    assert(a_func_name != NULL);

    if (a_ptr == NULL) {
        tsk_error_reset();
        tsk_error_set_errno(TSK_ERR_FS_ARG);
        if ((a_param_name != NULL) && (a_func_name != NULL)) { 
            tsk_error_set_errstr("%s: %s is NULL", a_param_name, a_func_name);
        }
        else {
            tsk_error_set_errstr("%s: NULL pointer", func_name);
        }

        return 1;
    }

    return 0;
}

/**
 * \internal
 * Tests whether an inode address is in the range of valid inode addresses for
 * a given file system.
 *
 * @param a_fatfs Generic FAT file system info structure.
 * @param a_inum An inode address. 
 * @return Returns 1 if the address is in range, 0 otherwise.
 */
uint8_t
fatfs_inum_is_in_range(FATFS_INFO *a_fatfs, TSK_INUM_T a_inum)
{
    const char *func_name = "fatfs_inum_is_in_range";
    TSK_FS_INFO *fs = (TSK_FS_INFO*)a_fatfs; 

    assert(a_fatfs != NULL);

    if (fatfs_ptr_arg_is_null(a_fatfs, "a_fatfs", func_name)) {
        return 0;
    }

    if ((a_inum < fs->first_inum) || (a_inum > fs->last_inum)) {
        return 0;
    }

    return 1;
}

/**
 * \internal
 * Tests whether an inode address argument is in the range of valid inode
 * addresses for a given file system. If the address is out of range,
 * sets a TSK_ERR_FS_ARG error with an error message that includes the inode
 * address and a function name supplied by the caller.
 *
 * @param a_fatfs Generic FAT file system info structure.
 * @param a_inum An inode address. 
 * @param a_func_name The name of the function that received the inode address 
 * as an argument.
 * @return Returns 1 if the address is in range, 0 otherwise.
 */
uint8_t
fatfs_inum_arg_is_in_range(FATFS_INFO *a_fatfs, TSK_INUM_T a_inum, const char *a_func_name)
{
    const char *func_name = "fatfs_inum_arg_is_in_range";

    assert(a_fatfs != NULL);
    assert(a_func_name != NULL);

    if (fatfs_ptr_arg_is_null(a_fatfs, "a_fatfs", func_name)) {
        return 0;
    }

    if (!fatfs_inum_is_in_range(a_fatfs, a_inum)) {
        tsk_error_reset();
        tsk_error_set_errno(TSK_ERR_FS_ARG);
        if (a_func_name != NULL) {
            tsk_error_set_errstr("%s: inode address: %" PRIuINUM " out of range", a_func_name, a_inum);
        }
        else {
            tsk_error_set_errstr("%s: inode address: %" PRIuINUM " out of range", func_name, a_inum);
        }

        return 0;
    }              
    return 1;
}

/**
 * \internal
 * Convert a DOS time stamp into a UNIX time stamp. A DOS time stamp consists
 * of a date with the year specified as an offset from 1980. A UNIX time stamp
 * is seconds since January 1, 1970 in UTC.
 *
 * @param date Date part of a DOS time stamp.
 * @param time Time part of a DOS time stamp. 
 * @param timetens Tenths of seconds part of a DOS time stamp, range is 0-199.
 * @return A UNIX time stamp.
 */
time_t
fatfs_dos_2_unix_time(uint16_t date, uint16_t time, uint8_t timetens)
{
    struct tm tm1;
    time_t ret;

    if (date == 0)
        return 0;

    memset(&tm1, 0, sizeof(struct tm));

    tm1.tm_sec = ((time & FATFS_SEC_MASK) >> FATFS_SEC_SHIFT) * 2;
    if ((tm1.tm_sec < 0) || (tm1.tm_sec > 60))
        tm1.tm_sec = 0;

    /* The ctimetens value has a range of 0 to 199 */
    if (timetens >= 100)
        tm1.tm_sec++;

    tm1.tm_min = ((time & FATFS_MIN_MASK) >> FATFS_MIN_SHIFT);
    if ((tm1.tm_min < 0) || (tm1.tm_min > 59))
        tm1.tm_min = 0;

    tm1.tm_hour = ((time & FATFS_HOUR_MASK) >> FATFS_HOUR_SHIFT);
    if ((tm1.tm_hour < 0) || (tm1.tm_hour > 23))
        tm1.tm_hour = 0;

    tm1.tm_mday = ((date & FATFS_DAY_MASK) >> FATFS_DAY_SHIFT);
    if ((tm1.tm_mday < 1) || (tm1.tm_mday > 31))
        tm1.tm_mday = 0;

    tm1.tm_mon = ((date & FATFS_MON_MASK) >> FATFS_MON_SHIFT) - 1;
    if ((tm1.tm_mon < 0) || (tm1.tm_mon > 11))
        tm1.tm_mon = 0;

    /* There is a limit to the year because the UNIX time value is
     * a 32-bit value
     * the maximum UNIX time is Tue Jan 19 03:14:07 2038 */
    tm1.tm_year = ((date & FATFS_YEAR_MASK) >> FATFS_YEAR_SHIFT) + 80;
    if ((tm1.tm_year < 0) || (tm1.tm_year > 137))
        tm1.tm_year = 0;

    /* set the daylight savings variable to -1 so that mktime() figures
     * it out */
    tm1.tm_isdst = -1;

    ret = mktime(&tm1);

    if (ret < 0) {
        if (tsk_verbose)
            tsk_fprintf(stderr,
                "fatfs_dos_2_unix_time: Error running mktime() on: %d:%d:%d %d/%d/%d\n",
                ((time & FATFS_HOUR_MASK) >> FATFS_HOUR_SHIFT),
                ((time & FATFS_MIN_MASK) >> FATFS_MIN_SHIFT),
                ((time & FATFS_SEC_MASK) >> FATFS_SEC_SHIFT) * 2,
                ((date & FATFS_MON_MASK) >> FATFS_MON_SHIFT) - 1,
                ((date & FATFS_DAY_MASK) >> FATFS_DAY_SHIFT),
                ((date & FATFS_YEAR_MASK) >> FATFS_YEAR_SHIFT) + 80);
        return 0;
    }

    return ret;
}

/**
 * \internal
 * Converts the tenths of seconds part a DOS time stamp into nanoseconds.
 * of a date with the year specified as an offset from 1980. A UNIX time stamp
 * is seconds since January 1, 1970 in UTC.
 *
 * @param timetens Tenths of seconds part of a DOS time stamp, range is 0-199.
 * @return A duration in nanoseconds.
 */
uint32_t
fatfs_dos_2_nanosec(uint8_t timetens)
{
    timetens %= 100;
    return timetens * 10000000;
}

/** 
 * \internal
 * Cleans up a string so that it contains only ASCII characters. Useful when
 *
 * @param name The string
 */
void
fatfs_cleanup_ascii(char *str)
{
    const char *func_name = "fatfs_cleanup_ascii";

    assert(str != NULL);

    if (!fatfs_ptr_arg_is_null(str, "str", func_name)) {
        int i;
        for (i = 0; str[i] != '\0'; i++) {
            if ((unsigned char) (str[i]) > 0x7e) {
                str[i] = '^';
            }
        }
    }
}

/**
 * \internal
 * Converts a UTF-16 string from an inode into a null-terminated UTF-8 string. If the 
 * conversion fails, sets a TSK_ERR_FS_UNICODE error with an error message 
 * that includes the inode address and a description of the UTF-16 string
 * supplied by the caller.
 *
 * Unlike tsk_UTF16toUTF8, a_src and a_dest will not be updated to point 
 * to where the conversion stopped reading/writing.
 *
 * @param a_fatfs Generic FAT file system info structure.
 * @param a_src The UTF-16 string to convert.
 * @param a_src_len The number of UTF16 items in a_src.
 * @param a_dest The buffer for the UTF-8 string.
 * @param a_dest_len The number of bytes in a_dest.
 * @param a_inum The address of the source inode, used if an error message is
 * generated.
 * @param a_desc A description of the source string, used if an error message 
 * is generated.
 * @return TSKConversionResult.
 */
TSKConversionResult
fatfs_utf16_inode_str_2_utf8(FATFS_INFO *a_fatfs, UTF16 *a_src, size_t a_src_len, UTF8 *a_dest, size_t a_dest_len, TSK_INUM_T a_inum, const char *a_desc)
{
    const char *func_name = "fatfs_copy_utf16_str";
    TSK_FS_INFO *fs = &(a_fatfs->fs_info);
    TSKConversionResult conv_result = TSKconversionOK;
    UTF8* dest_start;
    UTF8* dest_end;
    
    assert(a_fatfs != NULL);
    assert(a_src != NULL);
    assert(a_src_len > 0);
    assert(a_dest != NULL);
    assert(a_dest_len > 0);
    assert(a_desc != NULL);

    if (fatfs_ptr_arg_is_null(a_fatfs, "a_fatfs", func_name)) {
        return TSKsourceIllegal; 
    }

    if (fatfs_ptr_arg_is_null(a_fatfs, "a_src", func_name)) {
        return TSKsourceExhausted; 
    }

    if (a_src_len <= 0) {
        return TSKsourceExhausted; 
    }

    if (fatfs_ptr_arg_is_null(a_fatfs, "a_dest", func_name)) {
        return TSKtargetExhausted; 
    }

    if (a_dest_len <= 0) {
        return TSKtargetExhausted; 
    }

    if (fatfs_ptr_arg_is_null(a_fatfs, "a_desc", func_name)) {
        return TSKsourceIllegal; 
    }

    /* Do the conversion. Note that a_dest and a_src will point to where the conversion
     * stopped reading/writing. */
    dest_start = a_dest;
    dest_end = (UTF8*)&a_dest[a_dest_len];
    conv_result = tsk_UTF16toUTF8(fs->endian, (const UTF16**)&a_src, (UTF16*)&a_src[a_src_len], &a_dest, dest_end, TSKlenientConversion);

    if (conv_result != TSKconversionOK) {
        tsk_error_reset();
        tsk_error_set_errno(TSK_ERR_FS_UNICODE);
        tsk_error_set_errstr("%s: Error converting %s for inum %"PRIuINUM" from UTF16 to UTF8: %d", func_name, a_desc, a_inum, conv_result);
        *a_dest = '\0';
        return conv_result;
    }

    /* Make sure the result is NULL-terminated. */
    if((uintptr_t)a_dest >= (uintptr_t)dest_end)
        dest_start[a_dest_len - 1] = '\0';
    else
        *a_dest = '\0';

    return conv_result;
}
