/*

 * Copyright (c) 2015, 2017, 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 <assert.h>

#include <sys/stat.h>

#include <ctype.h>

#ifdef DEBUG_ARGFILE

  #ifndef NO_JNI

    #define NO_JNI

  #endif

  #define JLI_ReportMessage(...) printf(__VA_ARGS__)

  #define JDK_JAVA_OPTIONS "JDK_JAVA_OPTIONS"

  int IsWhiteSpaceOption(const char* name) { return 1; }

#else

  #include "java.h"

#endif

#include "jli_util.h"

#include "emessages.h"

#define MAX_ARGF_SIZE 0x7fffffffL

static char* clone_substring(const char *begin, size_t len) {

    char *rv = (char *) JLI_MemAlloc(len + 1);

    memcpy(rv, begin, len);

    rv[len] = '\0';

    return rv;

}

enum STATE {

    FIND_NEXT,

    IN_COMMENT,

    IN_QUOTE,

    IN_ESCAPE,

    SKIP_LEAD_WS,

    IN_TOKEN

};

typedef struct {

    enum STATE state;

    const char* cptr;

    const char* eob;

    char quote_char;

    JLI_List parts;

} __ctx_args;

#define NOT_FOUND -1

static int firstAppArgIndex = NOT_FOUND;

static jboolean expectingNoDashArg = JNI_FALSE;

// Initialize to 1, as the first argument is the app name and not preprocessed

static size_t argsCount = 1;

static jboolean stopExpansion = JNI_FALSE;

static jboolean relaunch = JNI_FALSE;

void JLI_InitArgProcessing(jboolean hasJavaArgs, jboolean disableArgFile) {

    // No expansion for relaunch

    if (argsCount != 1) {

        relaunch = JNI_TRUE;

        stopExpansion = JNI_TRUE;

        argsCount = 1;

    } else {

        stopExpansion = disableArgFile;

    }

    expectingNoDashArg = JNI_FALSE;

    // for tools, this value remains 0 all the time.

    firstAppArgIndex = hasJavaArgs ? 0: NOT_FOUND;

}

    // Will be 0 for tools

    return firstAppArgIndex;

}

static void checkArg(const char *arg) {

    size_t idx = 0;

    argsCount++;

    // All arguments arrive here must be a launcher argument,

    // ie. by now, all argfile expansions must have been performed.

    if (*arg == '-') {

        expectingNoDashArg = JNI_FALSE;

        if (IsWhiteSpaceOption(arg)) {

            // expect an argument

            expectingNoDashArg = JNI_TRUE;

            if (JLI_StrCmp(arg, "-jar") == 0 ||

                JLI_StrCmp(arg, "--module") == 0 ||

                JLI_StrCmp(arg, "-m") == 0) {

                // This is tricky, we do expect NoDashArg

                // But that is considered main class to stop expansion

                expectingNoDashArg = JNI_FALSE;

                // We can not just update the idx here because if -jar @file

                // still need expansion of @file to get the argument for -jar

            }

        } else if (JLI_StrCmp(arg, "--disable-@files") == 0) {

            stopExpansion = JNI_TRUE;

        }

    } else {

        if (!expectingNoDashArg) {

            // this is main class, argsCount is index to next arg

            idx = argsCount;

        }

        expectingNoDashArg = JNI_FALSE;

    }

    // only update on java mode and not yet found main class

    if (firstAppArgIndex == NOT_FOUND && idx != 0) {

        firstAppArgIndex = (int) idx;

    }

}

/*

       [\n\r]   +------------+                        +------------+ [\n\r]

      +---------+ IN_COMMENT +<------+                | IN_ESCAPE  +---------+

      |         +------------+       |                +------------+         |

      |    [#]       ^               |[#]                 ^     |            |

      |   +----------+               |                [\\]|     |[^\n\r]     |

      v   |                          |                    |     v            |

+------------+ [^ \t\n\r\f]  +------------+['"]>      +------------+         |

| FIND_NEXT  +-------------->+ IN_TOKEN   +-----------+ IN_QUOTE   +         |

+------------+               +------------+   <[quote]+------------+         |

  |   ^                          |                       |  ^   ^            |

  |   |               [ \t\n\r\f]|                 [\n\r]|  |   |[^ \t\n\r\f]v

  |   +--------------------------+-----------------------+  |  +--------------+

  |                       ['"]                              |  | SKIP_LEAD_WS |

  +---------------------------------------------------------+  +--------------+

*/

static char* nextToken(__ctx_args *pctx) {

    const char* nextc = pctx->cptr;

    const char* const eob = pctx->eob;

    const char* anchor = nextc;

    char *token;

    for (; nextc < eob; nextc++) {

        register char ch = *nextc;

        // Skip white space characters

        if (pctx->state == FIND_NEXT || pctx->state == SKIP_LEAD_WS) {

            while (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t' || ch == '\f') {

                nextc++;

                if (nextc >= eob) {

                    return NULL;

                }

                ch = *nextc;

            }

            pctx->state = (pctx->state == FIND_NEXT) ? IN_TOKEN : IN_QUOTE;

            anchor = nextc;

        // Deal with escape sequences

        } else if (pctx->state == IN_ESCAPE) {

            // concatenation directive

            if (ch == '\n' || ch == '\r') {

                pctx->state = SKIP_LEAD_WS;

            } else {

            // escaped character

                char* escaped = (char*) JLI_MemAlloc(2 * sizeof(char));

                escaped[1] = '\0';

                switch (ch) {

                    case 'n':

                        escaped[0] = '\n';

                        break;

                    case 'r':

                        escaped[0] = '\r';

                        break;

                    case 't':

                        escaped[0] = '\t';

                        break;

                    case 'f':

                        escaped[0] = '\f';

                        break;

                    default:

                        escaped[0] = ch;

                        break;

                }

                JLI_List_add(pctx->parts, escaped);

                pctx->state = IN_QUOTE;

            }

            // anchor to next character

            anchor = nextc + 1;

            continue;

        // ignore comment to EOL

        } else if (pctx->state == IN_COMMENT) {

            while (ch != '\n' && ch != '\r') {

                nextc++;

                if (nextc > eob) {

                    return NULL;

                }

                ch = *nextc;

            }

            pctx->state = FIND_NEXT;

            continue;

        }

        assert(pctx->state != IN_ESCAPE);

        assert(pctx->state != FIND_NEXT);

        assert(pctx->state != SKIP_LEAD_WS);

        assert(pctx->state != IN_COMMENT);

        switch(ch) {

            case ' ':

            case '\t':

            case '\f':

                if (pctx->state == IN_QUOTE) {

                    continue;

                }

                // fall through

            case '\n':

            case '\r':

                if (pctx->parts->size == 0) {

                    token = clone_substring(anchor, nextc - anchor);

                } else {

                    JLI_List_addSubstring(pctx->parts, anchor, nextc - anchor);

                    token = JLI_List_combine(pctx->parts);

                    JLI_List_free(pctx->parts);

                    pctx->parts = JLI_List_new(4);

                }

                pctx->cptr = nextc + 1;

                pctx->state = FIND_NEXT;

                return token;

            case '#':

                if (pctx->state == IN_QUOTE) {

                    continue;

                }

                pctx->state = IN_COMMENT;

                break;

            case '\\':

                if (pctx->state != IN_QUOTE) {

                    continue;

                }

                JLI_List_addSubstring(pctx->parts, anchor, nextc - anchor);

                pctx->state = IN_ESCAPE;

                break;

            case '\'':

            case '"':

                if (pctx->state == IN_QUOTE && pctx->quote_char != ch) {

                    // not matching quote

                    continue;

                }

                // partial before quote

                if (anchor != nextc) {

                    JLI_List_addSubstring(pctx->parts, anchor, nextc - anchor);

                }

                // anchor after quote character

                anchor = nextc + 1;

                if (pctx->state == IN_TOKEN) {

                    pctx->quote_char = ch;

                    pctx->state = IN_QUOTE;

                } else {

                    pctx->state = IN_TOKEN;

                }

                break;

            default:

                break;

        }

    }

    assert(nextc == eob);

    if (anchor != nextc) {

        // not yet return until end of stream, we have part of a token.

        JLI_List_addSubstring(pctx->parts, anchor, nextc - anchor);

    }

    return NULL;

}

static JLI_List readArgFile(FILE *file) {

    char buf[4096];

    JLI_List rv;

    __ctx_args ctx;

    size_t size;

    char *token;

    ctx.state = FIND_NEXT;

    ctx.parts = JLI_List_new(4);

    /* arbitrarily pick 8, seems to be a reasonable number of arguments */

    rv = JLI_List_new(8);

    while (!feof(file)) {

        size = fread(buf, sizeof(char), sizeof(buf), file);

        if (ferror(file)) {

            JLI_List_free(rv);

            return NULL;

        }

        /* nextc is next character to read from the buffer

         * eob is the end of input

         * token is the copied token value, NULL if no a complete token

         */

        ctx.cptr = buf;

        ctx.eob = buf + size;

        token = nextToken(&ctx);

        while (token != NULL) {

            checkArg(token);

            JLI_List_add(rv, token);

            token = nextToken(&ctx);

        }

    }

    // remaining partial token

    if (ctx.state == IN_TOKEN || ctx.state == IN_QUOTE) {

        if (ctx.parts->size != 0) {

            JLI_List_add(rv, JLI_List_combine(ctx.parts));

        }

    }

    JLI_List_free(ctx.parts);

    return rv;

}

/*

 * if the arg represent a file, that is, prefix with a single '@',

 * return a list of arguments from the file.

 * otherwise, return NULL.

 */

static JLI_List expandArgFile(const char *arg) {

    FILE *fptr;

    struct stat st;

    JLI_List rv;

    /* failed to access the file */

    if (stat(arg, &st) != 0) {

        JLI_ReportMessage(CFG_ERROR6, arg);

        exit(1);

    }

    if (st.st_size > MAX_ARGF_SIZE) {

        JLI_ReportMessage(CFG_ERROR10, MAX_ARGF_SIZE);

        exit(1);

    }

    fptr = fopen(arg, "r");

    /* arg file cannot be openned */

    if (fptr == NULL) {

        JLI_ReportMessage(CFG_ERROR6, arg);

        exit(1);

    }

    rv = readArgFile(fptr);

    fclose(fptr);

    /* error occurred reading the file */

    if (rv == NULL) {

        JLI_ReportMessage(DLL_ERROR4, arg);

        exit(1);

    }

    return rv;

}

JLI_List JLI_PreprocessArg(const char *arg)

{

    JLI_List rv;

    if (firstAppArgIndex > 0) {

        // In user application arg, no more work.

        return NULL;

    }

    if (stopExpansion) {

        // still looking for user application arg

        checkArg(arg);

        return NULL;

    }

    if (arg[0] != '@') {

        checkArg(arg);

        return NULL;

    }

    if (arg[1] == '\0') {

        // @ by itself is an argument

        checkArg(arg);

        return NULL;

    }

    arg++;

    if (arg[0] == '@') {

        // escaped @argument

        rv = JLI_List_new(1);

        checkArg(arg);

        JLI_List_add(rv, JLI_StringDup(arg));

    } else {

        rv = expandArgFile(arg);

    }

    return rv;

}

int isTerminalOpt(char *arg) {

    return JLI_StrCmp(arg, "-jar") == 0 ||

           JLI_StrCmp(arg, "-m") == 0 ||

           JLI_StrCmp(arg, "--module") == 0 ||

           JLI_StrCmp(arg, "--dry-run") == 0 ||

           JLI_StrCmp(arg, "-h") == 0 ||

           JLI_StrCmp(arg, "-?") == 0 ||

           JLI_StrCmp(arg, "-help") == 0 ||

           JLI_StrCmp(arg, "--help") == 0 ||

           JLI_StrCmp(arg, "-X") == 0 ||

           JLI_StrCmp(arg, "--help-extra") == 0 ||

           JLI_StrCmp(arg, "-version") == 0 ||

           JLI_StrCmp(arg, "--version") == 0 ||

           JLI_StrCmp(arg, "-fullversion") == 0 ||

           JLI_StrCmp(arg, "--full-version") == 0;

}

jboolean JLI_AddArgsFromEnvVar(JLI_List args, const char *var_name) {

    char *env = getenv(var_name);

    char *p, *arg;

    char quote;

    JLI_List argsInFile;

    if (firstAppArgIndex == 0) {

        // Not 'java', return

        return JNI_FALSE;

    }

    if (relaunch) {

        return JNI_FALSE;

    }

    if (NULL == env) {

        return JNI_FALSE;

    }

    JLI_ReportMessage(ARG_INFO_ENVVAR, var_name, env);

    // This is retained until the process terminates as it is saved as the args

    p = JLI_MemAlloc(JLI_StrLen(env) + 1);

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

        while (*env != '\0' && isspace(*env)) {

            env++;

        }

        // Trailing space

        if (*env == '\0') {

            break;

        }

        arg = p;

        while (*env != '\0' && !isspace(*env)) {

            if (*env == '"' || *env == '\'') {

                quote = *env++;

                while (*env != quote && *env != '\0') {

                    *p++ = *env++;

                }

                if (*env == '\0') {

                    JLI_ReportMessage(ARG_ERROR8, var_name);

                    exit(1);

                }

                env++;

            } else {

                *p++ = *env++;

            }

        }

        *p++ = '\0';

        argsInFile = JLI_PreprocessArg(arg);

        if (NULL == argsInFile) {

            if (isTerminalOpt(arg)) {

                JLI_ReportMessage(ARG_ERROR9, arg, var_name);

                exit(1);

            }

            JLI_List_add(args, arg);

        } else {

            size_t cnt, idx;

            char *argFile = arg;

            cnt = argsInFile->size;

            for (idx = 0; idx < cnt; idx++) {

                arg = argsInFile->elements[idx];

                if (isTerminalOpt(arg)) {

                    JLI_ReportMessage(ARG_ERROR10, arg, argFile, var_name);

                    exit(1);

                }

                JLI_List_add(args, arg);

            }

            // Shallow free, we reuse the string to avoid copy

            JLI_MemFree(argsInFile->elements);

            JLI_MemFree(argsInFile);

        }

        /*

         * Check if main-class is specified after argument being checked. It

         * must always appear after expansion, as a main-class could be specified

         * indirectly into environment variable via an @argfile, and it must be

         * caught now.

         */

        if (firstAppArgIndex != NOT_FOUND) {

            JLI_ReportMessage(ARG_ERROR11, var_name);

            exit(1);

        }