#include "java.h"

#define USE_STDERR JNI_TRUE

static jboolean printVersion = JNI_FALSE; /* print and exit */

static jboolean showVersion = JNI_FALSE; /* print but continue */

static jboolean printUsage = JNI_FALSE; /* print and exit*/

static jboolean printXUsage = JNI_FALSE; /* print and exit*/

static char *showSettings = NULL; /* print but continue */

static const char *_program_name;

static const char *_launcher_name;

static jboolean _is_java_args = JNI_FALSE;

static const char *_fVersion;

static const char *_dVersion;

static jboolean _wc_enabled = JNI_FALSE;

static jint _ergo_policy = DEFAULT_POLICY;

static char* splash_file_entry = NULL;

static char* splash_jar_entry = NULL;

static JavaVMOption *options;

static int numOptions, maxOptions;

static void SetClassPath(const char *s);

static void SelectVersion(int argc, char **argv, char **main_class);

static void SetJvmEnvironment(int argc, char **argv);

static jboolean ParseArguments(int *pargc, char ***pargv,

int *pmode, char **pwhat,

int *pret, const char *jrepath);

static jboolean InitializeJVM(JavaVM **pvm, JNIEnv **penv,

InvocationFunctions *ifn);

static jstring NewPlatformString(JNIEnv *env, char *s);

static jclass LoadMainClass(JNIEnv *env, int mode, char *name);

static jclass GetApplicationClass(JNIEnv *env);

static void TranslateApplicationArgs(int jargc, const char **jargv, int *pargc, char ***pargv);

static jboolean AddApplicationOptions(int cpathc, const char **cpathv);

static void SetApplicationClassPath(const char**);

static void PrintJavaVersion(JNIEnv *env, jboolean extraLF);

static void PrintUsage(JNIEnv* env, jboolean doXUsage);

static void ShowSettings(JNIEnv* env, char *optString);

static void SetPaths(int argc, char **argv);

static void DumpState();

static jboolean RemovableOption(char *option);

#define INIT_MAX_KNOWN_VMS 10

enum vmdesc_flag {

};

struct vmdesc {

};

static struct vmdesc *knownVMs = NULL;

static int knownVMsCount = 0;

static int knownVMsLimit = 0;

static void GrowKnownVMs();

static int KnownVMIndex(const char* name);

static void FreeKnownVMs();

static jboolean IsWildCardEnabled();

#define ARG_CHECK(AC_arg_count, AC_failure_message, AC_questionable_arg) \

do { \

if (AC_arg_count < 1) { \

JLI_ReportErrorMessage(AC_failure_message, AC_questionable_arg); \

printUsage = JNI_TRUE; \

*pret = 1; \

return JNI_TRUE; \

} \

} while (JNI_FALSE)

static jlong threadStackSize = 0; /* stack size of the new thread */

static jlong maxHeapSize = 0; /* max heap size */

static jlong initialHeapSize = 0; /* inital heap size */

JLI_Launch(int argc, char ** argv, /* main argc, argc */

)

{

int mode = LM_UNKNOWN;

char *what = NULL;

char *cpath = 0;

char *main_class = NULL;

int ret;

InvocationFunctions ifn;

jlong start, end;

char jvmpath[MAXPATHLEN];

char jrepath[MAXPATHLEN];

char jvmcfg[MAXPATHLEN];

_fVersion = fullversion;

_dVersion = dotversion;

_launcher_name = lname;

_program_name = pname;

_is_java_args = javaargs;

_wc_enabled = cpwildcard;

_ergo_policy = ergo;

InitLauncher(javaw);

DumpState();

if (JLI_IsTraceLauncher()) {

int i;

printf("Command line args:\n");

for (i = 0; i < argc ; i++) {

printf("argv[%d] = %s\n", i, argv[i]);

}

AddOption("-Dsun.java.launcher.diag=true", NULL);

}

/*

SelectVersion(argc, argv, &main_class);

CreateExecutionEnvironment(&argc, &argv,

jrepath, sizeof(jrepath),

jvmpath, sizeof(jvmpath),

jvmcfg, sizeof(jvmcfg));

if (!IsJavaArgs()) {

SetJvmEnvironment(argc,argv);

}

ifn.CreateJavaVM = 0;

ifn.GetDefaultJavaVMInitArgs = 0;

if (JLI_IsTraceLauncher()) {

start = CounterGet();

}

if (!LoadJavaVM(jvmpath, &ifn)) {

return(6);

}

if (JLI_IsTraceLauncher()) {

end = CounterGet();

}

JLI_TraceLauncher("%ld micro seconds to LoadJavaVM\n",

(long)(jint)Counter2Micros(end-start));

++argv;

--argc;

if (IsJavaArgs()) {

/* Preprocess wrapper arguments */

TranslateApplicationArgs(jargc, jargv, &argc, &argv);

if (!AddApplicationOptions(appclassc, appclassv)) {

return(1);

}

} else {

/* Set default CLASSPATH */

cpath = getenv("CLASSPATH");

if (cpath == NULL) {

cpath = ".";

}

SetClassPath(cpath);

}

/* Parse command line options; if the return value of

if (!ParseArguments(&argc, &argv, &mode, &what, &ret, jrepath))

{

return(ret);

}

/* Override class path if -jar flag was specified */

if (mode == LM_JAR) {

SetClassPath(what); /* Override class path */

}

/* set the -Dsun.java.command pseudo property */

SetJavaCommandLineProp(what, argc, argv);

/* Set the -Dsun.java.launcher pseudo property */

SetJavaLauncherProp();

/* set the -Dsun.java.launcher.* platform properties */

SetJavaLauncherPlatformProps();

return JVMInit(&ifn, threadStackSize, argc, argv, mode, what, ret);

}

#define LEAVE() \

do { \

if ((*vm)->DetachCurrentThread(vm) != JNI_OK) { \

JLI_ReportErrorMessage(JVM_ERROR2); \

ret = 1; \

} \

if (JNI_TRUE) { \

(*vm)->DestroyJavaVM(vm); \

return ret; \

} \

} while (JNI_FALSE)

#define CHECK_EXCEPTION_NULL_LEAVE(CENL_exception) \

do { \

if ((*env)->ExceptionOccurred(env)) { \

JLI_ReportExceptionDescription(env); \

LEAVE(); \

} \

if ((CENL_exception) == NULL) { \

JLI_ReportErrorMessage(JNI_ERROR); \

LEAVE(); \

} \

} while (JNI_FALSE)

#define CHECK_EXCEPTION_LEAVE(CEL_return_value) \

do { \

if ((*env)->ExceptionOccurred(env)) { \

JLI_ReportExceptionDescription(env); \

ret = (CEL_return_value); \

LEAVE(); \

} \

} while (JNI_FALSE)

int JNICALL

JavaMain(void * _args)

{

JavaMainArgs *args = (JavaMainArgs *)_args;

int argc = args->argc;

char **argv = args->argv;

int mode = args->mode;

char *what = args->what;

InvocationFunctions ifn = args->ifn;

JavaVM *vm = 0;

JNIEnv *env = 0;

jclass mainClass = NULL;

jclass appClass = NULL; // actual application class being launched

jmethodID mainID;

jobjectArray mainArgs;

int ret = 0;

jlong start, end;

RegisterThread();

/* Initialize the virtual machine */

start = CounterGet();

if (!InitializeJVM(&vm, &env, &ifn)) {

JLI_ReportErrorMessage(JVM_ERROR1);

exit(1);

}

if (showSettings != NULL) {

ShowSettings(env, showSettings);

CHECK_EXCEPTION_LEAVE(1);

}

if (printVersion || showVersion) {

PrintJavaVersion(env, showVersion);

CHECK_EXCEPTION_LEAVE(0);

if (printVersion) {

LEAVE();

}

}

/* If the user specified neither a class name nor a JAR file */

if (printXUsage || printUsage || what == 0 || mode == LM_UNKNOWN) {

PrintUsage(env, printXUsage);

CHECK_EXCEPTION_LEAVE(1);

LEAVE();

}

FreeKnownVMs(); /* after last possible PrintUsage() */

if (JLI_IsTraceLauncher()) {

end = CounterGet();

JLI_TraceLauncher("%ld micro seconds to InitializeJVM\n",

(long)(jint)Counter2Micros(end-start));

}

/* At this stage, argc/argv have the application's arguments */

if (JLI_IsTraceLauncher()){

int i;

printf("%s is '%s'\n", launchModeNames[mode], what);

printf("App's argc is %d\n", argc);

for (i=0; i < argc; i++) {

printf(" argv[%2d] = '%s'\n", i, argv[i]);

}

}

ret = 1;

/*

mainClass = LoadMainClass(env, mode, what);

CHECK_EXCEPTION_NULL_LEAVE(mainClass);

/*

appClass = GetApplicationClass(env);

NULL_CHECK_RETURN_VALUE(appClass, -1);

/*

PostJVMInit(env, appClass, vm);

CHECK_EXCEPTION_LEAVE(1);

/*

mainID = (*env)->GetStaticMethodID(env, mainClass, "main",

"([Ljava/lang/String;)V");

CHECK_EXCEPTION_NULL_LEAVE(mainID);

/* Build platform specific argument array */

mainArgs = CreateApplicationArgs(env, argv, argc);

CHECK_EXCEPTION_NULL_LEAVE(mainArgs);

/* Invoke main method. */

(*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);

/*

ret = (*env)->ExceptionOccurred(env) == NULL ? 0 : 1;

LEAVE();

}

char *

CheckJvmType(int *pargc, char ***argv, jboolean speculative) {

int i, argi;

int argc;

char **newArgv;

int newArgvIdx = 0;

int isVMType;

int jvmidx = -1;

char *jvmtype = getenv("JDK_ALTERNATE_VM");

argc = *pargc;

/* To make things simpler we always copy the argv array */

newArgv = JLI_MemAlloc((argc + 1) * sizeof(char *));

/* The program name is always present */

newArgv[newArgvIdx++] = (*argv)[0];

for (argi = 1; argi < argc; argi++) {

char *arg = (*argv)[argi];

isVMType = 0;

if (IsJavaArgs()) {

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

newArgv[newArgvIdx++] = arg;

continue;

}

} else {

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

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

newArgv[newArgvIdx++] = arg;

argi++;

if (argi < argc) {

newArgv[newArgvIdx++] = (*argv)[argi];

}

continue;

}

if (arg[0] != '-') break;

}

/* Did the user pass an explicit VM type? */

i = KnownVMIndex(arg);

if (i >= 0) {

jvmtype = knownVMs[jvmidx = i].name + 1; /* skip the - */

isVMType = 1;

*pargc = *pargc - 1;

}

/* Did the user specify an "alternate" VM? */

else if (JLI_StrCCmp(arg, "-XXaltjvm=") == 0 || JLI_StrCCmp(arg, "-J-XXaltjvm=") == 0) {

isVMType = 1;

jvmtype = arg+((arg[1]=='X')? 10 : 12);

jvmidx = -1;

}

if (!isVMType) {

newArgv[newArgvIdx++] = arg;

}

}

/*

while (argi < argc) {

newArgv[newArgvIdx++] = (*argv)[argi];

argi++;

}

/* argv is null-terminated */

newArgv[newArgvIdx] = 0;

/* Copy back argv */

*argv = newArgv;

*pargc = newArgvIdx;

/* use the default VM type if not specified (no alias processing) */

if (jvmtype == NULL) {

char* result = knownVMs[0].name+1;

/* Use a different VM type if we are on a server class machine? */

if ((knownVMs[0].flag == VM_IF_SERVER_CLASS) &&

(ServerClassMachine() == JNI_TRUE)) {

result = knownVMs[0].server_class+1;

}

JLI_TraceLauncher("Default VM: %s\n", result);

return result;

}

/* if using an alternate VM, no alias processing */

if (jvmidx < 0)

return jvmtype;

/* Resolve aliases first */

{

int loopCount = 0;

while (knownVMs[jvmidx].flag == VM_ALIASED_TO) {

int nextIdx = KnownVMIndex(knownVMs[jvmidx].alias);

if (loopCount > knownVMsCount) {

if (!speculative) {

JLI_ReportErrorMessage(CFG_ERROR1);

exit(1);

} else {

return "ERROR";

/* break; */

}

}

if (nextIdx < 0) {

if (!speculative) {

JLI_ReportErrorMessage(CFG_ERROR2, knownVMs[jvmidx].alias);

exit(1);

} else {

return "ERROR";

}

}

jvmidx = nextIdx;

jvmtype = knownVMs[jvmidx].name+1;

loopCount++;

}

}

switch (knownVMs[jvmidx].flag) {

case VM_WARN:

if (!speculative) {

JLI_ReportErrorMessage(CFG_WARN1, jvmtype, knownVMs[0].name + 1);

}

/* fall through */

case VM_IGNORE:

jvmtype = knownVMs[jvmidx=0].name + 1;

/* fall through */

case VM_KNOWN:

break;

case VM_ERROR:

if (!speculative) {

JLI_ReportErrorMessage(CFG_ERROR3, jvmtype);

exit(1);

} else {

return "ERROR";

}

}

return jvmtype;

}

static void

SetJvmEnvironment(int argc, char **argv) {

static const char* NMT_Env_Name = "NMT_LEVEL_";

int i;

for (i = 0; i < argc; i++) {

char *arg = argv[i];

/*

if (i > 0) {

char *prev = argv[i - 1];

// skip non-dash arg preceded by class path specifiers

if (*arg != '-' &&

((JLI_StrCmp(prev, "-cp") == 0

|| JLI_StrCmp(prev, "-classpath") == 0))) {

continue;

}

if (*arg != '-'

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

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

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

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

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

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

return;

}

}

/*

if (JLI_StrCCmp(arg, "-XX:NativeMemoryTracking=") == 0) {

int retval;

// get what follows this parameter, include "="

size_t pnlen = JLI_StrLen("-XX:NativeMemoryTracking=");

if (JLI_StrLen(arg) > pnlen) {

char* value = arg + pnlen;

size_t pbuflen = pnlen + JLI_StrLen(value) + 10; // 10 max pid digits

/*

char * pbuf = (char*)JLI_MemAlloc(pbuflen);

JLI_Snprintf(pbuf, pbuflen, "%s%d=%s", NMT_Env_Name, JLI_GetPid(), value);

retval = JLI_PutEnv(pbuf);

if (JLI_IsTraceLauncher()) {

char* envName;

char* envBuf;

// ensures that malloc successful

envName = (char*)JLI_MemAlloc(pbuflen);

JLI_Snprintf(envName, pbuflen, "%s%d", NMT_Env_Name, JLI_GetPid());

printf("TRACER_MARKER: NativeMemoryTracking: env var is %s\n",envName);

printf("TRACER_MARKER: NativeMemoryTracking: putenv arg %s\n",pbuf);

envBuf = getenv(envName);

printf("TRACER_MARKER: NativeMemoryTracking: got value %s\n",envBuf);

free(envName);

}

}

}

}

}

static int

parse_size(const char *s, jlong *result) {

jlong n = 0;

int args_read = sscanf(s, jlong_format_specifier(), &n);

if (args_read != 1) {

return 0;

}

while (*s != '\0' && *s >= '0' && *s <= '9') {

s++;

}

// 4705540: illegal if more characters are found after the first non-digit

if (JLI_StrLen(s) > 1) {

return 0;

}

switch (*s) {

case 'T': case 't':

*result = n * GB * KB;

return 1;

case 'G': case 'g':

*result = n * GB;

return 1;

case 'M': case 'm':

*result = n * MB;

return 1;

case 'K': case 'k':

*result = n * KB;

return 1;

case '\0':

*result = n;

return 1;

default:

/* Create JVM with default stack and let VM handle malformed -Xss string*/

return 0;

}

}

AddOption(char *str, void *info)

{

/*

if (numOptions >= maxOptions) {

if (options == 0) {

maxOptions = 4;

options = JLI_MemAlloc(maxOptions * sizeof(JavaVMOption));

} else {

JavaVMOption *tmp;

maxOptions *= 2;

tmp = JLI_MemAlloc(maxOptions * sizeof(JavaVMOption));

memcpy(tmp, options, numOptions * sizeof(JavaVMOption));

JLI_MemFree(options);

options = tmp;

}

}

options[numOptions].optionString = str;

options[numOptions++].extraInfo = info;

if (JLI_StrCCmp(str, "-Xss") == 0) {

jlong tmp;

if (parse_size(str + 4, &tmp)) {

threadStackSize = tmp;

}

}

if (JLI_StrCCmp(str, "-Xmx") == 0) {

jlong tmp;

if (parse_size(str + 4, &tmp)) {

maxHeapSize = tmp;

}

}

if (JLI_StrCCmp(str, "-Xms") == 0) {

jlong tmp;

if (parse_size(str + 4, &tmp)) {

initialHeapSize = tmp;

}

}

}

static void

SetClassPath(const char *s)

{

char *def;

const char *orig = s;

static const char format[] = "-Djava.class.path=%s";

/*

if (s == NULL)

return;

s = JLI_WildcardExpandClasspath(s);

if (sizeof(format) - 2 + JLI_StrLen(s) < JLI_StrLen(s))

// s is corrupted after wildcard expansion

return;

def = JLI_MemAlloc(sizeof(format)

- 2 /* strlen("%s") */

+ JLI_StrLen(s));

sprintf(def, format, s);

AddOption(def, NULL);

if (s != orig)

JLI_MemFree((char *) s);

}

static void

SelectVersion(int argc, char **argv, char **main_class)

{

char *arg;

char **new_argv;

char **new_argp;

char *operand;

char *version = NULL;

char *jre = NULL;

int jarflag = 0;

int headlessflag = 0;

int restrict_search = -1; /* -1 implies not known */

manifest_info info;

char env_entry[MAXNAMELEN + 24] = ENV_ENTRY "=";

char *splash_file_name = NULL;

char *splash_jar_name = NULL;

char *env_in;

int res;

/*

if ((env_in = getenv(ENV_ENTRY)) != NULL) {

if (*env_in != '\0')

*main_class = JLI_StringDup(env_in);

return;

}

/*

new_argv = JLI_MemAlloc((argc + 1) * sizeof(char*));

new_argv[0] = argv[0];

new_argp = &new_argv[1];

argc--;

argv++;

while ((arg = *argv) != 0 && *arg == '-') {

if (JLI_StrCCmp(arg, "-version:") == 0) {

version = arg + 9;

} else if (JLI_StrCmp(arg, "-jre-restrict-search") == 0) {

restrict_search = 1;

} else if (JLI_StrCmp(arg, "-no-jre-restrict-search") == 0) {

restrict_search = 0;

} else {

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

jarflag = 1;

/* deal with "unfortunate" classpath syntax */

if ((JLI_StrCmp(arg, "-classpath") == 0 || JLI_StrCmp(arg, "-cp") == 0) &&

(argc >= 2)) {

*new_argp++ = arg;

argc--;

argv++;

arg = *argv;

}

/*

if (JLI_StrCmp(arg, "-Djava.awt.headless=true") == 0) {

headlessflag = 1;

} else if (JLI_StrCCmp(arg, "-Djava.awt.headless=") == 0) {

headlessflag = 0;

} else if (JLI_StrCCmp(arg, "-splash:") == 0) {

splash_file_name = arg+8;

}

*new_argp++ = arg;

}

argc--;

argv++;

}

if (argc <= 0) { /* No operand? Possibly legit with -[full]version */

operand = NULL;

} else {

argc--;

*new_argp++ = operand = *argv++;

}

while (argc-- > 0) /* Copy over [argument...] */

*new_argp++ = *argv++;

*new_argp = NULL;

/*

if (jarflag && operand) {

if ((res = JLI_ParseManifest(operand, &info)) != 0) {

if (res == -1)

JLI_ReportErrorMessage(JAR_ERROR2, operand);

else

JLI_ReportErrorMessage(JAR_ERROR3, operand);

exit(1);

}

/*

if (!headlessflag && !splash_file_name && info.splashscreen_image_file_name) {

splash_file_name = info.splashscreen_image_file_name;

splash_jar_name = operand;

}

} else {

info.manifest_version = NULL;

info.main_class = NULL;

info.jre_version = NULL;

info.jre_restrict_search = 0;

}

/*

if (splash_file_name && !headlessflag) {

char* splash_file_entry = JLI_MemAlloc(JLI_StrLen(SPLASH_FILE_ENV_ENTRY "=")+JLI_StrLen(splash_file_name)+1);

JLI_StrCpy(splash_file_entry, SPLASH_FILE_ENV_ENTRY "=");

JLI_StrCat(splash_file_entry, splash_file_name);

putenv(splash_file_entry);

}

if (splash_jar_name && !headlessflag) {

char* splash_jar_entry = JLI_MemAlloc(JLI_StrLen(SPLASH_JAR_ENV_ENTRY "=")+JLI_StrLen(splash_jar_name)+1);

JLI_StrCpy(splash_jar_entry, SPLASH_JAR_ENV_ENTRY "=");

JLI_StrCat(splash_jar_entry, splash_jar_name);

putenv(splash_jar_entry);

}

/*

if (version != NULL)