/*

 * Copyright (c) 2014, 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 "Platform.h"

#include "JavaVirtualMachine.h"

#include "LinuxPlatform.h"

#include "PlatformString.h"

#include "IniFile.h"

#include "Helpers.h"

#include "FilePath.h"

#include <stdlib.h>

#include <pwd.h>

#include <sys/file.h>

#include <sys/stat.h>

#include <errno.h>

#include <unistd.h>

#include <sys/types.h>

#include <limits.h>

#include <signal.h>

#define LINUX_JPACKAGE_TMP_DIR "/.java/jpackage/tmp"

TString GetEnv(const TString &name) {

    TString result;

    char *value = ::getenv((TCHAR*) name.c_str());

    if (value != NULL) {

        result = value;

    }

    return result;

}

LinuxPlatform::LinuxPlatform(void) : Platform(),

PosixPlatform() {

    FMainThread = pthread_self();

}

LinuxPlatform::~LinuxPlatform(void) {

}

TString LinuxPlatform::GetPackageAppDirectory() {

    return FilePath::IncludeTrailingSeparator(

            GetPackageRootDirectory()) + _T("app");

}

TString LinuxPlatform::GetAppName() {

    TString result = GetModuleFileName();

    result = FilePath::ExtractFileName(result);

    return result;

}

TString LinuxPlatform::GetPackageLauncherDirectory() {

    return FilePath::IncludeTrailingSeparator(

            GetPackageRootDirectory()) + _T("bin");

}

TString LinuxPlatform::GetPackageRuntimeBinDirectory() {

}

void LinuxPlatform::ShowMessage(TString title, TString description) {

    printf("%s %s\n", PlatformString(title).toPlatformString(),

            PlatformString(description).toPlatformString());

    fflush(stdout);

}

void LinuxPlatform::ShowMessage(TString description) {

    TString appname = GetModuleFileName();

    appname = FilePath::ExtractFileName(appname);

    ShowMessage(PlatformString(appname).toPlatformString(),

            PlatformString(description).toPlatformString());

}

TCHAR* LinuxPlatform::ConvertStringToFileSystemString(TCHAR* Source,

        bool &release) {

    // Not Implemented.

    return NULL;

}

TCHAR* LinuxPlatform::ConvertFileSystemStringToString(TCHAR* Source,

        bool &release) {

    // Not Implemented.

    return NULL;

}

TString LinuxPlatform::GetModuleFileName() {

    ssize_t len = 0;

    TString result;

    DynamicBuffer<TCHAR> buffer(MAX_PATH);

    if (buffer.GetData() == NULL) {

        return result;

    }

    if ((len = readlink("/proc/self/exe", buffer.GetData(),

            MAX_PATH - 1)) != -1) {

        buffer[len] = '\0';

        result = buffer.GetData();

    }

    return result;

}

TString LinuxPlatform::GetPackageRootDirectory() {

    TString result;

    TString filename = GetModuleFileName();

    TString binPath = FilePath::ExtractFilePath(filename);

    size_t slash = binPath.find_last_of(TRAILING_PATHSEPARATOR);

    if (slash != TString::npos) {

        result = binPath.substr(0, slash);

    }

    return result;

}

TString LinuxPlatform::GetAppDataDirectory() {

    TString result;

    TString home = GetEnv(_T("HOME"));

    if (home.empty() == false) {

        result += FilePath::IncludeTrailingSeparator(home) + _T(".local");

    }

    return result;

}

ISectionalPropertyContainer* LinuxPlatform::GetConfigFile(TString FileName) {

    IniFile *result = new IniFile();

    if (result == NULL) {

        return NULL;

    }

    result->LoadFromFile(FileName);

    return result;

}

TString LinuxPlatform::GetBundledJavaLibraryFileName(TString RuntimePath) {

    TString result = FilePath::IncludeTrailingSeparator(RuntimePath) +

            "lib/libjli.so";

    if (FilePath::FileExists(result) == false) {

        result = FilePath::IncludeTrailingSeparator(RuntimePath) +

                "lib/jli/libjli.so";

        if (FilePath::FileExists(result) == false) {

            printf("Cannot find libjli.so!");

        }

    }

    return result;

}

bool LinuxPlatform::IsMainThread() {

    bool result = (FMainThread == pthread_self());

    return result;

}

TString LinuxPlatform::getTmpDirString() {

    return TString(LINUX_JPACKAGE_TMP_DIR);

}

TPlatformNumber LinuxPlatform::GetMemorySize() {

    long pages = sysconf(_SC_PHYS_PAGES);

    long page_size = sysconf(_SC_PAGE_SIZE);

    TPlatformNumber result = pages * page_size;

    result = result / 1048576; // Convert from bytes to megabytes.

    return result;

}

void PosixProcess::Cleanup() {

    if (FOutputHandle != 0) {

        close(FOutputHandle);

        FOutputHandle = 0;

    }

    if (FInputHandle != 0) {

        close(FInputHandle);

        FInputHandle = 0;

    }

}

#define PIPE_READ 0

#define PIPE_WRITE 1

bool PosixProcess::Execute(const TString Application,

        const std::vector<TString> Arguments, bool AWait) {

    bool result = false;

    if (FRunning == false) {

        FRunning = true;

        int handles[2];

        if (pipe(handles) == -1) {

            return false;

        }

        struct sigaction sa;

        sa.sa_handler = SIG_IGN;

        sigemptyset(&sa.sa_mask);

        sa.sa_flags = 0;

        FChildPID = fork();

        // PID returned by vfork is 0 for the child process and the

        // PID of the child process for the parent.

        if (FChildPID == -1) {

            // Error

            TString message = PlatformString::Format(

                    _T("Error: Unable to create process %s"),

                    Application.data());

            throw Exception(message);

        } else if (FChildPID == 0) {

            Cleanup();

            TString command = Application;

            for (std::vector<TString>::const_iterator iterator =

                    Arguments.begin(); iterator != Arguments.end();

                    iterator++) {

                command += TString(_T(" ")) + *iterator;

            }

#ifdef DEBUG

            printf("%s\n", command.data());

#endif // DEBUG

            dup2(handles[PIPE_READ], STDIN_FILENO);

            dup2(handles[PIPE_WRITE], STDOUT_FILENO);

            close(handles[PIPE_READ]);

            close(handles[PIPE_WRITE]);

            execl("/bin/sh", "sh", "-c", command.data(), (char *) 0);

            _exit(127);

        } else {

            FOutputHandle = handles[PIPE_READ];

            FInputHandle = handles[PIPE_WRITE];

            if (AWait == true) {

                ReadOutput();

                Wait();

                Cleanup();

                FRunning = false;

                result = true;

            } else {

                result = true;

            }

        }

    }

    return result;

}

//----------------------------------------------------------------------------

#ifndef __UNIX_JPACKAGE_PLATFORM__

#define __UNIX_JPACKAGE_PLATFORM__

/** Provide an abstraction for difference in the platform APIs,

     e.g. string manipulation functions, etc. */

#include <stdio.h>

#include <string.h>

#include <strings.h>

#include <sys/stat.h>

#define TCHAR char

#define _T(x) x

#define JPACKAGE_MULTIBYTE_SNPRINTF snprintf

#define JPACKAGE_SNPRINTF(buffer, sizeOfBuffer, count, format, ...) \

    snprintf((buffer), (count), (format), __VA_ARGS__)

#define JPACKAGE_PRINTF(format, ...) \

    printf((format), ##__VA_ARGS__)

#define JPACKAGE_FPRINTF(dest, format, ...) \

    fprintf((dest), (format), __VA_ARGS__)

#define JPACKAGE_SSCANF(buf, format, ...) \

    sscanf((buf), (format), __VA_ARGS__)

#define JPACKAGE_STRDUP(strSource) \

    strdup((strSource))

//return "error code" (like on Windows)

static int JPACKAGE_STRNCPY(char *strDest, size_t numberOfElements,

        const char *strSource, size_t count) {

    char *s = strncpy(strDest, strSource, count);

    // Duplicate behavior of the Windows' _tcsncpy_s() by adding a NULL

    // terminator at the end of the string.

    if (count < numberOfElements) {

        s[count] = '\0';

    } else {

        s[numberOfElements - 1] = '\0';

    }

    return (s == strDest) ? 0 : 1;

}

#define JPACKAGE_STRICMP(x, y) \

    strcasecmp((x), (y))

#define JPACKAGE_STRNICMP(x, y, cnt) \

    strncasecmp((x), (y), (cnt))

#define JPACKAGE_STRNCMP(x, y, cnt) \

    strncmp((x), (y), (cnt))

#define JPACKAGE_STRLEN(x) \

    strlen((x))

#define JPACKAGE_STRSTR(x, y) \

    strstr((x), (y))

#define JPACKAGE_STRCHR(x, y) \

    strchr((x), (y))

#define JPACKAGE_STRRCHR(x, y) \

    strrchr((x), (y))

#define JPACKAGE_STRPBRK(x, y) \

    strpbrk((x), (y))

#define JPACKAGE_GETENV(x) \

    getenv((x))

#define JPACKAGE_PUTENV(x) \

    putenv((x))

#define JPACKAGE_STRCMP(x, y) \

    strcmp((x), (y))

#define JPACKAGE_STRCPY(x, y) \

    strcpy((x), (y))

#define JPACKAGE_STRCAT(x, y) \

    strcat((x), (y))

#define JPACKAGE_ATOI(x) \

    atoi((x))

#define JPACKAGE_FOPEN(x, y) \

    fopen((x), (y))

#define JPACKAGE_FGETS(x, y, z) \

    fgets((x), (y), (z))

#define JPACKAGE_REMOVE(x) \

    remove((x))

#define JPACKAGE_SPAWNV(mode, cmd, args) \

    spawnv((mode), (cmd), (args))

#define JPACKAGE_ISDIGIT(ch) isdigit(ch)

// for non-unicode, just return the input string for

// the following 2 conversions

#define JPACKAGE_NEW_MULTIBYTE(message) message

#define JPACKAGE_NEW_FROM_MULTIBYTE(message) message

// for non-unicode, no-op for the relase operation

// since there is no memory allocated for the

// string conversions

#define JPACKAGE_RELEASE_MULTIBYTE(tmpMBCS)

#define JPACKAGE_RELEASE_FROM_MULTIBYTE(tmpMBCS)

// The size will be used for converting from 1 byte to 1 byte encoding.

// Ensure have space for zero-terminator.

#define JPACKAGE_GET_SIZE_FOR_ENCODING(message, theLength) (theLength + 1)

#endif

#define xmlTagType    0

#define xmlPCDataType 1

typedef struct _xmlNode XMLNode;

typedef struct _xmlAttribute XMLAttribute;

struct _xmlNode {

    int _type; // Type of node: tag, pcdata, cdate

    TCHAR* _name; // Contents of node

    XMLNode* _next; // Next node at same level

    XMLNode* _sub; // First sub-node

    XMLAttribute* _attributes; // List of attributes

};

struct _xmlAttribute {

    TCHAR* _name; // Name of attribute

    TCHAR* _value; // Value of attribute

    XMLAttribute* _next; // Next attribute for this tag

};

// Public interface

static void RemoveNonAsciiUTF8FromBuffer(char *buf);

XMLNode* ParseXMLDocument(TCHAR* buf);

void FreeXMLDocument(XMLNode* root);

// Utility methods for parsing document

XMLNode* FindXMLChild(XMLNode* root, const TCHAR* name);

TCHAR* FindXMLAttribute(XMLAttribute* attr, const TCHAR* name);

// Debugging

void PrintXMLDocument(XMLNode* node, int indt);

#include <sys/types.h>

#include <sys/stat.h>

#include <setjmp.h>

#include <stdlib.h>

#include <wctype.h>

#define JWS_assert(s, msg)      \

    if (!(s)) { Abort(msg); }

// Internal declarations

static XMLNode* ParseXMLElement(void);

static XMLAttribute* ParseXMLAttribute(void);

static TCHAR* SkipWhiteSpace(TCHAR *p);

static TCHAR* SkipXMLName(TCHAR *p);

static TCHAR* SkipXMLComment(TCHAR *p);

static TCHAR* SkipXMLDocType(TCHAR *p);

static TCHAR* SkipXMLProlog(TCHAR *p);

static TCHAR* SkipPCData(TCHAR *p);

static int IsPCData(TCHAR *p);

static void ConvertBuiltInEntities(TCHAR* p);

static void SetToken(int type, TCHAR* start, TCHAR* end);

static void GetNextToken(void);

static XMLNode* CreateXMLNode(int type, TCHAR* name);

static XMLAttribute* CreateXMLAttribute(TCHAR *name, TCHAR* value);

static XMLNode* ParseXMLElement(void);

static XMLAttribute* ParseXMLAttribute(void);

static void FreeXMLAttribute(XMLAttribute* attr);

static void PrintXMLAttributes(XMLAttribute* attr);

static void indent(int indt);

static jmp_buf jmpbuf;

static XMLNode* root_node = NULL;

/** definition of error codes for setjmp/longjmp,

 *  that can be handled in ParseXMLDocument()

 */

#define JMP_NO_ERROR     0

#define JMP_OUT_OF_RANGE 1

#define NEXT_CHAR(p) { \

    if (*p != 0) { \

        p++; \

    } else { \

        longjmp(jmpbuf, JMP_OUT_OF_RANGE); \

    } \

}

#define NEXT_CHAR_OR_BREAK(p) { \

    if (*p != 0) { \

        p++; \

    } else { \

        break; \

    } \

}

#define NEXT_CHAR_OR_RETURN(p) { \

    if (*p != 0) { \

        p++; \

    } else { \

        return; \

    } \

}

#define SKIP_CHARS(p,n) { \

    int i; \

    for (i = 0; i < (n); i++) { \

        if (*p != 0) { \

            p++; \

        } else { \

           longjmp(jmpbuf, JMP_OUT_OF_RANGE); \

        } \

    } \

}

#define SKIP_CHARS_OR_BREAK(p,n) { \

    int i; \

    for (i = 0; i < (n); i++) { \

        if (*p != 0) { \

            p++; \

        } else { \

            break; \

        } \

    } \

    if (i < (n)) { \

        break; \

    } \

}

/** Iterates through the null-terminated buffer (i.e., C string) and

 *  replaces all UTF-8 encoded character >255 with 255

 *

 *  UTF-8 encoding:

 *

 *   Range A:  0x0000 - 0x007F