/*

 *

 *

 *

 */

#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;

}

LinuxPlatform::LinuxPlatform(void) : Platform(), GenericPlatform(), PosixPlatform() {

    FMainThread = pthread_self();

}

LinuxPlatform::~LinuxPlatform(void) {

}

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 ((len = readlink("/proc/self/exe", buffer.GetData(), MAX_PATH - 1)) != -1) {

        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) {

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

    }

    return result;

}

ISectionalPropertyContainer* LinuxPlatform::GetConfigFile(TString FileName) {

    IniFile *result = new IniFile();

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

        // New property file format was not found, attempt to load old property file format.

        Helpers::LoadOldConfigFile(FileName, result);

    }

    return result;

}

TString LinuxPlatform::GetBundledJVMLibraryFileName(TString RuntimePath) {

    TString result = FilePath::IncludeTrailingSeparater(RuntimePath) +

        "lib/jli/libjli.so";

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

        result = FilePath::IncludeTrailingSeparater(RuntimePath) +

            "lib/jli/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

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

#ifndef __UNIX_DEPLOY_PLATFORM__

#define __UNIX_DEPLOY_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 DEPLOY_MULTIBYTE_SNPRINTF snprintf

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

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

#define DEPLOY_PRINTF(format, ...) \

    printf((format), ##__VA_ARGS__)

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

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

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

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

#define DEPLOY_STRDUP(strSource) \

    strdup((strSource))

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

static int DEPLOY_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;

}

static int DEPLOY_STRNCAT(char *strDest, size_t numberOfElements, const char *strSource, size_t count) {

    // strncat always return null terminated string

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

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

}

#define DEPLOY_STRICMP(x, y) \

    strcasecmp((x), (y))

#define DEPLOY_STRNICMP(x, y, cnt) \

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

#define DEPLOY_STRNCMP(x, y, cnt) \

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

#define DEPLOY_STRLEN(x) \

    strlen((x))

#define DEPLOY_STRSTR(x, y) \

    strstr((x), (y))

#define DEPLOY_STRCHR(x, y) \

    strchr((x), (y))

#define DEPLOY_STRRCHR(x, y) \

    strrchr((x), (y))

#define DEPLOY_STRPBRK(x, y) \

    strpbrk((x), (y))

#define DEPLOY_GETENV(x) \

    getenv((x))

#define DEPLOY_PUTENV(x) \

    putenv((x))

#define DEPLOY_STRCMP(x, y) \

    strcmp((x), (y))

#define DEPLOY_STRCPY(x, y) \

    strcpy((x), (y))

#define DEPLOY_STRCAT(x, y) \

    strcat((x), (y))

#define DEPLOY_ATOI(x) \

    atoi((x))

static int getFileSize(TCHAR* filename) {

    struct stat statBuf;

    if (stat(filename, &statBuf) == 0) {

        return statBuf.st_size;

    }

    return -1;

}

#define DEPLOY_FILE_SIZE(filename) getFileSize(filename)

#define DEPLOY_FOPEN(x, y) \

    fopen((x), (y))

#define DEPLOY_FGETS(x, y, z) \

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

#define DEPLOY_REMOVE(x) \

    remove((x))

#define DEPLOY_SPAWNV(mode, cmd, args) \

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

#define DEPLOY_ISDIGIT(ch) isdigit(ch)

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

// the following 2 conversions

#define DEPLOY_NEW_MULTIBYTE(message) message

#define DEPLOY_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 DEPLOY_RELEASE_MULTIBYTE(tmpMBCS)

#define DEPLOY_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 DEPLOY_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

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

    /* We are not using NEXT_CHAR() to check if *q is NULL, as q is output location

       and offset for q is smaller than for p. */

    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) {

        if (DEPLOY_STRNCMP(p, _T("<!--"), 4) == 0) {

            SKIP_CHARS(p, 4);

            do {

                if (DEPLOY_STRNCMP(p, _T("-->"), 3) == 0) {

                    SKIP_CHARS(p, 3);

                    return p;

                }

                NEXT_CHAR(p);

            } while(*p != '\0');

        }

    }

    return p;

}

static TCHAR* SkipXMLDocType(TCHAR *p) {

    if (p != NULL) {

        if (DEPLOY_STRNCMP(p, _T("<!"), 2) == 0) {

            SKIP_CHARS(p, 2);

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

                if (*p == '>') {

                    NEXT_CHAR(p);

                    return p;

                }

                NEXT_CHAR(p);

            }

        }

    }

    return p;

}

static TCHAR* SkipXMLProlog(TCHAR *p) {

    if (p != NULL) {

        if (DEPLOY_STRNCMP(p, _T("<?"), 2) == 0) {

            SKIP_CHARS(p, 2);

            do {

                if (DEPLOY_STRNCMP(p, _T("?>"), 2) == 0) {

                    SKIP_CHARS(p, 2);

                    return p;

                }

                NEXT_CHAR(p);

            } while(*p != '\0');

        }