/*

 * Copyright (c) 1999, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#include <stdlib.h>

#include <stdio.h>

#include <strings.h>

#include <time.h>

#include <limits.h>

#include <errno.h>

#include <stddef.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <string.h>

#include <dirent.h>

#include <unistd.h>

#if defined(__solaris__)

#include <libscf.h>

#endif

#include "jvm.h"

#include "TimeZone_md.h"

static char *isFileIdentical(char* buf, size_t size, char *pathname);

#define SKIP_SPACE(p)   while (*p == ' ' || *p == '\t') p++;

#define RESTARTABLE(_cmd, _result) do { \

  do { \

    _result = _cmd; \

  } while((_result == -1) && (errno == EINTR)); \

} while(0)

#if !defined(__solaris__) || defined(__sparcv9) || defined(amd64)

#define fileopen        fopen

#define filegets        fgets

#define fileclose       fclose

#endif

#if defined(_ALLBSD_SOURCE)

#define stat64 stat

#define lstat64 lstat

#define fstat64 fstat

#endif

#if defined(__linux__) || defined(_ALLBSD_SOURCE)

static const char *ETC_TIMEZONE_FILE = "/etc/timezone";

static const char *ZONEINFO_DIR = "/usr/share/zoneinfo";

static const char *DEFAULT_ZONEINFO_FILE = "/etc/localtime";

#else

static const char *SYS_INIT_FILE = "/etc/default/init";

static const char *ZONEINFO_DIR = "/usr/share/lib/zoneinfo";

static const char *DEFAULT_ZONEINFO_FILE = "/usr/share/lib/zoneinfo/localtime";

#endif /* defined(__linux__) || defined(_ALLBSD_SOURCE) */

static const char popularZones[][4] = {"UTC", "GMT"};

#if defined(_AIX)

static const char *ETC_ENVIRONMENT_FILE = "/etc/environment";

#endif

#if defined(__linux__) || defined(MACOSX) || defined(__solaris__)

/*

 * Returns a pointer to the zone ID portion of the given zoneinfo file

 * name, or NULL if the given string doesn't contain "zoneinfo/".

 */

static char *

getZoneName(char *str)

{

    static const char *zidir = "zoneinfo/";

    char *pos = strstr((const char *)str, zidir);

    if (pos == NULL) {

        return NULL;

    }

    return pos + strlen(zidir);

}

/*

 * Returns a path name created from the given 'dir' and 'name' under

 * UNIX. This function allocates memory for the pathname calling

 * malloc(). NULL is returned if malloc() fails.

 */

static char *

getPathName(const char *dir, const char *name) {

    char *path;

    path = (char *) malloc(strlen(dir) + strlen(name) + 2);

    if (path == NULL) {

        return NULL;

    }

    return strcat(strcat(strcpy(path, dir), "/"), name);

}

/*

 * Scans the specified directory and its subdirectories to find a

 * zoneinfo file which has the same content as /etc/localtime on Linux

 * or /usr/share/lib/zoneinfo/localtime on Solaris given in 'buf'.

 * If file is symbolic link, then the contents it points to are in buf.

 * Returns a zone ID if found, otherwise, NULL is returned.

 */

static char *

findZoneinfoFile(char *buf, size_t size, const char *dir)

{

    DIR *dirp = NULL;

    struct dirent *dp = NULL;

    char *pathname = NULL;

    char *tz = NULL;

    int res;

    if (strcmp(dir, ZONEINFO_DIR) == 0) {

        /* fast path for 1st iteration */

        for (unsigned int i = 0; i < sizeof (popularZones) / sizeof (popularZones[0]); i++) {

            pathname = getPathName(dir, popularZones[i]);

            if (pathname == NULL) {

                continue;

            }

            tz = isFileIdentical(buf, size, pathname);

            free((void *) pathname);

            pathname = NULL;

            if (tz != NULL) {

                return tz;

            }

        }

    }

    dirp = opendir(dir);

    if (dirp == NULL) {

        return NULL;

    }

    while ((dp = readdir(dirp)) != NULL) {

        /*

         * Skip '.' and '..' (and possibly other .* files)

         */

        if (dp->d_name[0] == '.') {

            continue;

        }

        /*

         * Skip "ROC", "posixrules", and "localtime".

         */

        if ((strcmp(dp->d_name, "ROC") == 0)

            || (strcmp(dp->d_name, "posixrules") == 0)

#if defined(__solaris__)

            /*

             * Skip the "src" and "tab" directories on Solaris.

             */

            || (strcmp(dp->d_name, "src") == 0)

            || (strcmp(dp->d_name, "tab") == 0)

#endif

            || (strcmp(dp->d_name, "localtime") == 0)) {

            continue;

        }

        pathname = getPathName(dir, dp->d_name);

        if (pathname == NULL) {

            break;

        }

        tz = isFileIdentical(buf, size, pathname);

        free((void *) pathname);

        pathname = NULL;

        if (tz != NULL) {

           break;

        }

    }

    if (dirp != NULL) {

        (void) closedir(dirp);

    }

    return tz;

}

/*

 * Checks if the file pointed to by pathname matches

 * the data contents in buf.

 * Returns a representation of the timezone file name

 * if file match is found, otherwise NULL.

 */

static char *

isFileIdentical(char *buf, size_t size, char *pathname)

{

    char *possibleMatch = NULL;

    struct stat64 statbuf;

    char *dbuf = NULL;

    int fd = -1;

    int res;

    RESTARTABLE(stat64(pathname, &statbuf), res);

    if (res == -1) {

        return NULL;

    }

    if (S_ISDIR(statbuf.st_mode)) {

        possibleMatch  = findZoneinfoFile(buf, size, pathname);

    } else if (S_ISREG(statbuf.st_mode) && (size_t)statbuf.st_size == size) {

        dbuf = (char *) malloc(size);

        if (dbuf == NULL) {

            return NULL;

        }

        RESTARTABLE(open(pathname, O_RDONLY), fd);

        if (fd == -1) {

            goto freedata;

        }

        RESTARTABLE(read(fd, dbuf, size), res);

        if (res != (ssize_t) size) {

            goto freedata;

        }

        if (memcmp(buf, dbuf, size) == 0) {

            possibleMatch = getZoneName(pathname);

            if (possibleMatch != NULL) {

                possibleMatch = strdup(possibleMatch);

            }

        }

        freedata:

        free((void *) dbuf);

        (void) close(fd);

    }

    return possibleMatch;

}

#if defined(__linux__) || defined(MACOSX)

/*

 * Performs Linux specific mapping and returns a zone ID

 * if found. Otherwise, NULL is returned.

 */

static char *

getPlatformTimeZoneID()

{

    struct stat64 statbuf;

    char *tz = NULL;

    FILE *fp;

    int fd;

    char *buf;

    size_t size;

    int res;

#if defined(__linux__)

    /*

     * Try reading the /etc/timezone file for Debian distros. There's

     * no spec of the file format available. This parsing assumes that

     * there's one line of an Olson tzid followed by a '\n', no

     * leading or trailing spaces, no comments.

     */

    if ((fp = fopen(ETC_TIMEZONE_FILE, "r")) != NULL) {

        char line[256];

        if (fgets(line, sizeof(line), fp) != NULL) {

            char *p = strchr(line, '\n');

            if (p != NULL) {

                *p = '\0';

            }

            if (strlen(line) > 0) {

                tz = strdup(line);

            }

        }

        (void) fclose(fp);

        if (tz != NULL) {

            return tz;

        }

    }

#endif /* defined(__linux__) */

    /*

     * Next, try /etc/localtime to find the zone ID.

     */

    RESTARTABLE(lstat64(DEFAULT_ZONEINFO_FILE, &statbuf), res);

    if (res == -1) {

        return NULL;

    }

    /*

     * If it's a symlink, get the link name and its zone ID part. (The

     * older versions of timeconfig created a symlink as described in

     * the Red Hat man page. It was changed in 1999 to create a copy

     * of a zoneinfo file. It's no longer possible to get the zone ID

     * from /etc/localtime.)

     */

    if (S_ISLNK(statbuf.st_mode)) {

        char linkbuf[PATH_MAX+1];

        int len;

        if ((len = readlink(DEFAULT_ZONEINFO_FILE, linkbuf, sizeof(linkbuf)-1)) == -1) {

            jio_fprintf(stderr, (const char *) "can't get a symlink of %s\n",

                        DEFAULT_ZONEINFO_FILE);

            return NULL;

        }

        linkbuf[len] = '\0';

        tz = getZoneName(linkbuf);

        if (tz != NULL) {

            tz = strdup(tz);

            return tz;

        }

    }

    /*

     * If it's a regular file, we need to find out the same zoneinfo file

     * that has been copied as /etc/localtime.

     * If initial symbolic link resolution failed, we should treat target

     * file as a regular file.

     */

    RESTARTABLE(open(DEFAULT_ZONEINFO_FILE, O_RDONLY), fd);

    if (fd == -1) {

        return NULL;

    }

    RESTARTABLE(fstat64(fd, &statbuf), res);

    if (res == -1) {

        (void) close(fd);

        return NULL;

    }

    size = (size_t) statbuf.st_size;

    buf = (char *) malloc(size);

    if (buf == NULL) {

        (void) close(fd);

        return NULL;

    }

    RESTARTABLE(read(fd, buf, size), res);

    if (res != (ssize_t) size) {

        (void) close(fd);

        free((void *) buf);

        return NULL;

    }

    (void) close(fd);

    tz = findZoneinfoFile(buf, size, ZONEINFO_DIR);

    free((void *) buf);

    return tz;

}

#elif defined(__solaris__)

#if !defined(__sparcv9) && !defined(amd64)

/*

 * Those file* functions mimic the UNIX stream io functions. This is

 * because of the limitation of the number of open files on Solaris

 * (32-bit mode only) due to the System V ABI.

 */

#define BUFFER_SIZE     4096

static struct iobuffer {

    int     magic;      /* -1 to distinguish from the real FILE */

    int     fd;         /* file descriptor */

    char    *buffer;    /* pointer to buffer */

    char    *ptr;       /* current read pointer */

    char    *endptr;    /* end pointer */

};

static int

fileclose(FILE *stream)

{

    struct iobuffer *iop = (struct iobuffer *) stream;

    if (iop->magic != -1) {

        return fclose(stream);

    }

    if (iop == NULL) {

        return 0;

    }

    close(iop->fd);

    free((void *)iop->buffer);

    free((void *)iop);

    return 0;

}

static FILE *

fileopen(const char *fname, const char *fmode)

{

    FILE *fp;

    int fd;

    struct iobuffer *iop;

    if ((fp = fopen(fname, fmode)) != NULL) {

        return fp;

    }

    /*

     * It assumes read open.

     */

    RESTARTABLE(open(fname, O_RDONLY), fd);

    if (fd == -1) {

        return NULL;

    }

    /*

     * Allocate struct iobuffer and its buffer

     */

    iop = malloc(sizeof(struct iobuffer));

    if (iop == NULL) {

        (void) close(fd);

        errno = ENOMEM;

        return NULL;

    }

    iop->magic = -1;

    iop->fd = fd;

    iop->buffer = malloc(BUFFER_SIZE);

    if (iop->buffer == NULL) {

        (void) close(fd);

        free((void *) iop);

        errno = ENOMEM;

        return NULL;

    }

    iop->ptr = iop->buffer;

    iop->endptr = iop->buffer;

    return (FILE *)iop;

}

/*

 * This implementation assumes that n is large enough and the line

 * separator is '\n'.

 */

static char *

filegets(char *s, int n, FILE *stream)

{

    struct iobuffer *iop = (struct iobuffer *) stream;

    char *p;

    if (iop->magic != -1) {

        return fgets(s, n, stream);

    }

    p = s;

    for (;;) {

        char c;

        if (iop->ptr == iop->endptr) {

            ssize_t len;

            RESTARTABLE(read(iop->fd, (void *)iop->buffer, BUFFER_SIZE), len);

            if (len == -1) {

                return NULL;

            }

            if (len == 0) {

                *p = 0;

                if (s == p) {

                    return NULL;

                }

                return s;

            }

            iop->ptr = iop->buffer;

            iop->endptr = iop->buffer + len;

        }

        c = *iop->ptr++;

        *p++ = c;

        if ((p - s) == (n - 1)) {

            *p = 0;

            return s;

        }

        if (c == '\n') {

            *p = 0;

            return s;

        }

    }

    /*NOTREACHED*/

}

#endif /* !defined(__sparcv9) && !defined(amd64) */

/*

 * Performs Solaris dependent mapping. Returns a zone ID if

 * found. Otherwise, NULL is returned.  Solaris libc looks up

 * "/etc/default/init" to get the default TZ value if TZ is not defined

 * as an environment variable.

 */

static char *

getPlatformTimeZoneID()

{

    char *tz = NULL;

    FILE *fp;

    /*

     * Try the TZ entry in /etc/default/init.

     */

    if ((fp = fileopen(SYS_INIT_FILE, "r")) != NULL) {

        char line[256];

        char quote = '\0';

        while (filegets(line, sizeof(line), fp) != NULL) {

            char *p = line;

            char *s;

            char c;