/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved. The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef KERNEL
#define KERNEL
#endif

#include <sys/param.h>
#include <sys/time.h>
#include <sys/conf.h>
#include <sys/sysmacros.h>
#include <sys/vfs.h>
#include <sys/debug.h>
#include <sys/errno.h>
#include <sys/cmn_err.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/byteorder.h>
#include <sys/types.h>
#include <sys/fs/pc_fs.h>
#include <sys/fs/pc_label.h>
#include <sys/fs/pc_dir.h>
#include <sys/fs/pc_node.h>

/*
 * Convert time between DOS formats:
 *      - years since 1980
 *      - months/days/hours/minutes/seconds, local TZ
 * and the UNIX format (seconds since 01/01/1970, 00:00:00 UT).
 *
 * Timezones are adjusted for via mount option arg (secondswest),
 * but daylight savings time corrections are not made. Calculated
 * time may therefore end up being wrong by an hour, but this:
 *      a) will happen as well if media is interchanged between
 *         two DOS/Windows-based systems that use different
 *         timezone settings
 *      b) is the best option we have unless we decide to put
 *         a full ctime(3C) framework into the kernel, including
 *         all conversion tables - AND keeping them current ...
 */

int pc_tvtopct(timestruc_t *, struct pctime *);
void pc_pcttotv(struct pctime *, int64_t *);

/*
 * Macros/Definitons required to convert between DOS-style and
 * UNIX-style time recording.
 * DOS year zero is 1980.
 */
static int daysinmonth[] =
            { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

#define YEAR_ZERO       1980
#define YZ_SECS (((8 * 365) + (2 * 366)) * 86400)
#define FAT_ENDOFTIME   \
        LE_16(23 << HOURSHIFT | 59 << MINSHIFT | (59/2) << SECSHIFT)
#define FAT_ENDOFDATE   \
        LE_16(127 << YEARSHIFT | 12 << MONSHIFT | 31 << DAYSHIFT)
#define leap_year(y) \
        (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))

#define YEN     "\xc2\xa5"      /* Yen Sign UTF-8 character */
#define LRO     "\xe2\x80\xad"  /* Left-To-Right Override UTF-8 character */
#define RLO     "\xe2\x80\xae"  /* Right-To-Left Override UTF-8 character */

static int
days_in_year(int y)
{
        return (leap_year((y)) ? 366 : 365);
}

static int
days_in_month(int m, int y)
{
        if (m == 2 && leap_year(y))
                return (29);
        else
                return (daysinmonth[m-1]);
}

struct pcfs_args pc_tz; /* this is set by pcfs_mount */

/*
 * Convert time from UNIX to DOS format.
 * Return EOVERFLOW in case no valid DOS time representation
 * exists for the given UNIX time.
 */
int
pc_tvtopct(
        timestruc_t     *tvp,           /* UNIX time input */
        struct pctime *pctp)            /* pctime output */
{
        uint_t year, month, day, hour, min, sec;
        int64_t unixtime;

        unixtime = (int64_t)tvp->tv_sec;
        unixtime -= YZ_SECS;
        unixtime -= pc_tz.secondswest;
        if (unixtime <= 0) {
                /*
                 * "before beginning of all time" for DOS ...
                 */
                return (EOVERFLOW);
        }
        for (year = YEAR_ZERO; unixtime >= days_in_year(year) * 86400;
            year++)
                unixtime -= 86400 * days_in_year(year);

        if (year > 127 + YEAR_ZERO) {
                /*
                 * "past end of all time" for DOS - can happen
                 * on a 64bit kernel via utimes() syscall ...
                 */
                return (EOVERFLOW);
        }

        for (month = 1; unixtime >= 86400 * days_in_month(month, year);
            month++)
                unixtime -= 86400 * days_in_month(month, year);

        year -= YEAR_ZERO;

        day = (int)(unixtime / 86400);
        unixtime -= 86400 * day++;      /* counting starts at 1 */

        hour = (int)(unixtime / 3600);
        unixtime -= 3600 * hour;

        min = (int)(unixtime / 60);
        unixtime -= 60 * min;

        sec = (int)unixtime;

        PC_DPRINTF3(1, "ux2pc date: %d.%d.%d\n", day, month, YEAR_ZERO + year);
        PC_DPRINTF3(1, "ux2pc time: %dh%dm%ds\n", hour, min, sec);
        PC_DPRINTF1(1, "ux2pc unixtime: %lld\n", (long long)(unixtime));

        ASSERT(year >= 0 && year < 128);
        ASSERT(month >= 1 && month <= 12);
        ASSERT(day >= 1 && day <= days_in_month(month, year));
        ASSERT(hour < 24);
        ASSERT(min < 60);
        ASSERT(sec < 60);

        pctp->pct_time =
            LE_16(hour << HOURSHIFT | min << MINSHIFT | (sec / 2) << SECSHIFT);
        pctp->pct_date =
            LE_16(year << YEARSHIFT | month << MONSHIFT | day << DAYSHIFT);

        return (0);
}

/*
 * Convert time from DOS to UNIX time format.
 * Since FAT timestamps cannot be expressed in 32bit time_t,
 * the calculation is performed using 64bit values. It's up to
 * the caller to decide what to do for out-of-UNIX-range values.
 */
void
pc_pcttotv(
        struct pctime *pctp,            /* DOS time input */
        int64_t *unixtime)              /* caller converts to time_t */
{
        uint_t year, month, day, hour, min, sec;

        sec = 2 * ((LE_16(pctp->pct_time) >> SECSHIFT) & SECMASK);
        min = (LE_16(pctp->pct_time) >> MINSHIFT) & MINMASK;
        hour = (LE_16(pctp->pct_time) >> HOURSHIFT) & HOURMASK;
        day = (LE_16(pctp->pct_date) >> DAYSHIFT) & DAYMASK;
        month = (LE_16(pctp->pct_date) >> MONSHIFT) & MONMASK;
        year = (LE_16(pctp->pct_date) >> YEARSHIFT) & YEARMASK;
        year += YEAR_ZERO;

        /*
         * Basic sanity checks. The FAT timestamp bitfields allow for
         * impossible dates/times - return the "FAT epoch" for these.
         */
        if (pctp->pct_date == 0) {
                year = YEAR_ZERO;
                month = 1;
                day = 1;
        }
        if (month > 12 || month < 1 ||
            day < 1 || day > days_in_month(month, year) ||
            hour > 23 || min > 59 || sec > 59) {
                cmn_err(CE_NOTE, "impossible FAT timestamp, "
                    "d/m/y %d/%d/%d, h:m:s %d:%d:%d",
                    day, month, year, hour, min, sec);
                *unixtime = YZ_SECS + pc_tz.secondswest;
                return;
        }

        PC_DPRINTF3(1, "pc2ux date: %d.%d.%d\n", day, month, year);
        PC_DPRINTF3(1, "pc2ux time: %dh%dm%ds\n", hour, min, sec);

        *unixtime = (int64_t)sec;
        *unixtime += 60 * (int64_t)min;
        *unixtime += 3600 * (int64_t)hour;
        *unixtime += 86400 * (int64_t)(day -1);
        while (month > 1) {
                month--;
                *unixtime += 86400 * (int64_t)days_in_month(month, year);
        }
        while (year > YEAR_ZERO) {
                year--;
                *unixtime += 86400 * (int64_t)days_in_year(year);
        }
        /*
         * For FAT, the beginning of all time is 01/01/1980,
         * and years are counted relative to that.
         * We adjust this base value by the timezone offset
         * that is passed in to pcfs at mount time.
         */
        *unixtime += YZ_SECS;
        *unixtime += pc_tz.secondswest;

        /*
         * FAT epoch is past UNIX epoch - negative UNIX times
         * cannot result from the conversion.
         */
        ASSERT(*unixtime > 0);
        PC_DPRINTF1(1, "pc2ux unixtime: %lld\n", (long long)(*unixtime));
}

/*
 * Determine whether a character is valid for a long file name.
 * It is easier to determine by filtering out invalid characters.
 * Following are invalid characters in a long filename.
 *      / \ : * ? < > | "
 */
int
pc_valid_lfn_char(char c)
{
        const char *cp;
        int n;

        static const char invaltab[] = {
                "/\\:*?<>|\""
        };

        cp = invaltab;
        n = sizeof (invaltab) - 1;
        while (n--) {
                if (c == *cp++)
                        return (0);
        }
        return (1);
}

int
pc_valid_long_fn(char *namep, int utf8)
{
        char *tmp;
        int len, error;
        char *prohibited[13] = {
                "/", "\\", ":", "*", "?", "<", ">", "|", "\"", YEN, LRO, RLO,
                    NULL
        };

        if (utf8) {
                /* UTF-8 */
                if ((len = u8_validate(namep, strlen(namep), prohibited,
                    (U8_VALIDATE_ENTIRE|U8_VALIDATE_CHECK_ADDITIONAL),
                    &error)) < 0)
                        return (0);
                if (len > PCMAXNAMLEN)
                        return (0);
        } else {
                /* UTF-16 */
                for (tmp = namep; (*tmp != '\0') || (*(tmp+1) != '\0');
                    tmp += 2) {
                        if ((*(tmp+1) == '\0') && !pc_valid_lfn_char(*tmp))
                                return (0);

                        /* Prohibit the Yen character */
                        if ((*(tmp+1) == '\0') && (*tmp == '\xa5'))
                                return (0);

                        /* Prohibit the left-to-right override control char */
                        if ((*(tmp+1) == '\x20') && (*tmp == '\x2d'))
                                return (0);

                        /* Prohibit the right-to-left override control char */
                        if ((*(tmp+1) == '\x20') && (*tmp == '\x2e'))
                                return (0);
                }
                if ((tmp - namep) > (PCMAXNAMLEN * sizeof (uint16_t)))
                        return (0);
        }
        return (1);
}

int
pc_fname_ext_to_name(char *namep, char *fname, char *ext, int foldcase)
{
        int     i;
        char    *tp = namep;
        char    c;

        i = PCFNAMESIZE;
        while (i-- && ((c = *fname) != ' ')) {
                if (!(c == '.' || pc_validchar(c))) {
                        return (-1);
                }
                if (foldcase)
                        *tp++ = tolower(c);
                else
                        *tp++ = c;
                fname++;
        }
        if (*ext != ' ') {
                *tp++ = '.';
                i = PCFEXTSIZE;
                while (i-- && ((c = *ext) != ' ')) {
                        if (!pc_validchar(c)) {
                                return (-1);
                        }
                        if (foldcase)
                                *tp++ = tolower(c);
                        else
                                *tp++ = c;
                        ext++;
                }
        }
        *tp = '\0';
        return (0);
}