/*

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

#ifdef LINUX

#include "JavaVirtualMachine.h"

#include "LinuxPlatform.h"

#include "PlatformString.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>

#define LINUX_PACKAGER_TMP_DIR "/.java/packager/tmp"

TString GetEnv(const TString &name) {

    TString result;

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

    if (value != NULL) {

       result = value;

    }

    return result;

}

    FMainThread = pthread_self();

}

LinuxPlatform::~LinuxPlatform(void) {

}

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

    fflush(stdout);

}

void LinuxPlatform::ShowMessage(TString description) {

    TString appname = GetModuleFileName();

    appname = FilePath::ExtractFileName(appname);

}

    // Not Implemented.

    return NULL;

}

    // Not Implemented.

    return NULL;

}

TString LinuxPlatform::GetModuleFileName() {

    ssize_t len = 0;

    TString result;

    DynamicBuffer<TCHAR> buffer(MAX_PATH);

        buffer[len] = '\0';

        result = buffer.GetData();

    }

    return result;

}

void LinuxPlatform::SetCurrentDirectory(TString Value) {

    chdir(PlatformString(Value).toPlatformString());

}

TString LinuxPlatform::GetPackageRootDirectory() {

    TString filename = GetModuleFileName();

    return FilePath::ExtractFilePath(filename);

}

TString LinuxPlatform::GetAppDataDirectory() {

    TString result;

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

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

    }

    return result;

}

ISectionalPropertyContainer* LinuxPlatform::GetConfigFile(TString FileName) {

    IniFile *result = new IniFile();

    if (result->LoadFromFile(FileName) == false) {

        Helpers::LoadOldConfigFile(FileName, result);

    }

    return result;

}

TString LinuxPlatform::GetBundledJVMLibraryFileName(TString RuntimePath) {

        "lib/libjli.so";

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

            "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_PACKAGER_TMP_DIR);

}

void LinuxPlatform::reactivateAnotherInstance() {

    if (singleInstanceProcessId == 0) {

        printf("Unable to reactivate another instance, PID is undefined");

        return;

    }

    const ProcessReactivator reactivator(singleInstanceProcessId);

}

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;

}

#ifdef DEBUG

bool LinuxPlatform::IsNativeDebuggerPresent() {

    // gdb opens file descriptors stdin=3, stdout=4, stderr=5 whereas

    // a typical prog uses only stdin=0, stdout=1, stderr=2.

    bool result = false;

    FILE *fd = fopen("/tmp", "r");

    if (fileno(fd) > 5) {

        result = true;

    }

    fclose(fd);

    return result;

}

int LinuxPlatform::GetProcessID() {

    int pid = getpid();

    return pid;

}

#endif //DEBUG

/** 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

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

    printf((format), ##__VA_ARGS__)

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

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

    strdup((strSource))

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

    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;

}

    strcasecmp((x), (y))

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

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

    strlen((x))

    strstr((x), (y))

    strchr((x), (y))

    strrchr((x), (y))

    strpbrk((x), (y))

    getenv((x))

    putenv((x))

    strcmp((x), (y))

    strcpy((x), (y))

    strcat((x), (y))

    atoi((x))

    fopen((x), (y))

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

    remove((x))

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

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

// the following 2 conversions

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

// since there is no memory allocated for the

// string conversions

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

// Ensure have space for zero-terminator.

#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

 *

 *  UTF-8 encoding:

 *

 *   Range A:  0x0000 - 0x007F

 *                               0 | bits 0 - 7

 *   Range B : 0x0080 - 0x07FF  :

 *                               110 | bits 6 - 10

 *                               10  | bits 0 - 5

 *   Range C : 0x0800 - 0xFFFF  :

 *                               1110 | bits 12-15

 *                               10   | bits  6-11

 *                               10   | bits  0-5

 */

static void RemoveNonAsciiUTF8FromBuffer(char *buf) {

    char* p;

    char* q;

    char c;

    p = q = buf;

    while(*p != '\0') {

        c = *p;

        if ( (c & 0x80) == 0) {

            /* Range A */

            *q++ = *p;

            NEXT_CHAR(p);

        } else if ((c & 0xE0) == 0xC0){

            /* Range B */

            *q++ = (char)0xFF;

            NEXT_CHAR(p);

            NEXT_CHAR_OR_BREAK(p);

        } else {

            /* Range C */

            *q++ = (char)0xFF;

            NEXT_CHAR(p);

            SKIP_CHARS_OR_BREAK(p, 2);

        }

    }

    /* Null terminate string */

    *q = '\0';

}

static TCHAR* SkipWhiteSpace(TCHAR *p) {

    if (p != NULL) {

        while(iswspace(*p))

            NEXT_CHAR_OR_BREAK(p);

    }

    return p;

}

static TCHAR* SkipXMLName(TCHAR *p) {

    TCHAR c = *p;

    /* Check if start of token */

    if ( ('a' <= c && c <= 'z') ||

         ('A' <= c && c <= 'Z') ||

         c == '_' || c == ':') {

        while( ('a' <= c && c <= 'z') ||

               ('A' <= c && c <= 'Z') ||

               ('0' <= c && c <= '9') ||

               c == '_' || c == ':' || c == '.' || c == '-' ) {

            NEXT_CHAR(p);

            c = *p;

            if (c == '\0') break;

        }

    }

    return p;

}

static TCHAR* SkipXMLComment(TCHAR *p) {

    if (p != NULL) {