编程语言
首页 > 编程语言> > 《jdk8u源码分析》5.4.ExecJRE

《jdk8u源码分析》5.4.ExecJRE

作者:互联网

src/windows/bin/java_md.c::ExecJRE

/*
 * Given a path to a jre to execute, this routine checks if this process
 * is indeed that jre.  If not, it exec's that jre.
 *
 * We want to actually check the paths rather than just the version string
 * built into the executable, so that given version specification will yield
 * the exact same Java environment, regardless of the version of the arbitrary
 * launcher we start with.
 */
void
ExecJRE(char *jre, char **argv) {
    jint     len;
    char    path[MAXPATHLEN + 1];
	//program name:java
    const char *progname = GetProgramName();

    /*
     * Resolve the real path to the currently running launcher.
     */
    //获取当前进程已加载模块的文件的完整路径,该模块必须由当前进程加载,存入path变量中
    len = GetModuleFileName(NULL, path, MAXPATHLEN + 1);
    if (len == 0 || len > MAXPATHLEN) {
        JLI_ReportErrorMessageSys(JRE_ERROR9, progname);
        exit(1);
    }

    //ExecJRE: old: C:\Program Files (x86)\Common Files\Oracle\Java\javapath\java.exe
    JLI_TraceLauncher("ExecJRE: old: %s\n", path);
	//ExecJRE: new: C:\Tools\Java\open-jre1.8.0_202
    JLI_TraceLauncher("ExecJRE: new: %s\n", jre);


    /*
     * If the path to the selected JRE directory is a match to the initial
     * portion of the path to the currently executing JRE, we have a winner!
     * If so, just return.
     */
    //判断项目中是否包含jre运行时环境
    //比较jre, path,比较长度:strlen(jre),如果相等直接return
    if (JLI_StrNCaseCmp(jre, path, JLI_StrLen(jre)) == 0)
        return;                 /* I am the droid you were looking for */

    /*
     * If this isn't the selected version, exec the selected version.
     */
    //拼接java命令绝对路径:C:\Tools\Java\open-jre1.8.0_202\bin\java.exe
    JLI_Snprintf(path, sizeof(path), "%s\\bin\\%s.exe", jre, progname);

    /*
     * Although Windows has an execv() entrypoint, it doesn't actually
     * overlay a process: it can only create a new process and terminate
     * the old process.  Therefore, any processes waiting on the initial
     * process wake up and they shouldn't.  Hence, a chain of pseudo-zombie
     * processes must be retained to maintain the proper wait semantics.
     * Fortunately the image size of the launcher isn't too large at this
     * time.
     *
     * If it weren't for this semantic flaw, the code below would be ...
     *
     *     execv(path, argv);
     *     JLI_ReportErrorMessage("Error: Exec of %s failed\n", path);
     *     exit(1);
     *
     * The incorrect exec semantics could be addressed by:
     *
     *     exit((int)spawnv(_P_WAIT, path, argv));
     *
     * Unfortunately, a bug in Windows spawn/exec impementation prevents
     * this from completely working.  All the Windows POSIX process creation
     * interfaces are implemented as wrappers around the native Windows
     * function CreateProcess().  CreateProcess() takes a single string
     * to specify command line options and arguments, so the POSIX routine
     * wrappers build a single string from the argv[] array and in the
     * process, any quoting information is lost.
     *
     * The solution to this to get the original command line, to process it
     * to remove the new multiple JRE options (if any) as was done for argv
     * in the common SelectVersion() routine and finally to pass it directly
     * to the native CreateProcess() Windows process control interface.
     */
    {
        char    *cmdline;
        char    *p;
        char    *np;
        char    *ocl;
        char    *ccl;
        char    *unquoted;
        DWORD   exitCode;
        STARTUPINFO si;
        PROCESS_INFORMATION pi;

        /*
         * The following code block gets and processes the original command
         * line, replacing the argv[0] equivalent in the command line with
         * the path to the new executable and removing the appropriate
         * Multiple JRE support options. Note that similar logic exists
         * in the platform independent SelectVersion routine, but is
         * replicated here due to the syntax of CreateProcess().
         *
         * The magic "+ 4" characters added to the command line length are
         * 2 possible quotes around the path (argv[0]), a space after the
         * path and a terminating null character.
         */
        //命令行返回数据结构:char *argv[],查看MSDN《Parsing C Command-Line Arguments》
        ocl = GetCommandLine();
        np = ccl = JLI_StringDup(ocl);
        //丢弃第一个参数:argv[0] = java
        p = nextarg(&np);               /* Discard argv[0] */
        cmdline = (char *)JLI_MemAlloc(JLI_StrLen(path) + JLI_StrLen(np) + 4);
        if (JLI_StrChr(path, (int)' ') == NULL && JLI_StrChr(path, (int)'\t') == NULL)
            cmdline = JLI_StrCpy(cmdline, path);
        else
            cmdline = JLI_StrCat(JLI_StrCat(JLI_StrCpy(cmdline, "\""), path), "\"");

        while (*np != (char)0) {                /* While more command-line */
        	//获取命令行参数arg[i](i >= 1),处理反斜杠转义字符
            p = nextarg(&np);
            if (*p != (char)0) {                /* If a token was isolated */
            	//移除双引号
                unquoted = unquote(p);
                //拼接以'-'开始的命令行参数
                if (*unquoted == '-') {         /* Looks like an option */
		            //argv[7] = -classpath
		            //argv[8] = xx1.jar;xx2.jar;...
		            //argv[9] = com.johnjoe.study.Test
		            //argv[10] = -cp
		            //argv[11] = xxx.jar
		            //因为argv中-classpath和-cp的特殊处理
                    if (JLI_StrCmp(unquoted, "-classpath") == 0 ||
                      JLI_StrCmp(unquoted, "-cp") == 0) {       /* Unique cp syntax */
                      	//拼接命令行参数
                        cmdline = JLI_StrCat(JLI_StrCat(cmdline, " "), p);
                        p = nextarg(&np);
                        if (*p != (char)0)      /* If a token was isolated */
                        	//拼接参数配置的lib(jar)包目录
                            cmdline = JLI_StrCat(JLI_StrCat(cmdline, " "), p);
                        //过滤参数:-version, -jre-restrict-search, -no-jre-restrict-search
                        //其余参数全部原样拼接
                    } else if (JLI_StrNCmp(unquoted, "-version:", 9) != 0 &&
                      JLI_StrCmp(unquoted, "-jre-restrict-search") != 0 &&
                      JLI_StrCmp(unquoted, "-no-jre-restrict-search") != 0) {
                        cmdline = JLI_StrCat(JLI_StrCat(cmdline, " "), p);
                    }
                } else {                        /* End of options */
                	//拼接当前循环取出的命令行参数
                    cmdline = JLI_StrCat(JLI_StrCat(cmdline, " "), p);
                    //拼接剩余命令行参数并退出循环
                    cmdline = JLI_StrCat(JLI_StrCat(cmdline, " "), np);
                    JLI_MemFree((void *)unquoted);
                    break;
                }
                JLI_MemFree((void *)unquoted);
            }
        }
        JLI_MemFree((void *)ccl);

        if (JLI_IsTraceLauncher()) {
            np = ccl = JLI_StringDup(cmdline);
            p = nextarg(&np);//p与cmdline相等
			//ReExec Command: C:\Tools\Java\open-jre1.8.0_202\bin\java.exe (C:\Tools\Java\open-jre1.8.0_202\bin\java.exe)
            printf("ReExec Command: %s (%s)\n", path, p);
            //ReExec Args: -jar test.jar
            printf("ReExec Args: %s\n", np);
            JLI_MemFree((void *)ccl);
        }
        //刷新stdou, stderr流缓冲区
        (void)fflush(stdout);
        (void)fflush(stderr);

        /*
         * The following code is modeled after a model presented in the
         * Microsoft Technical Article "Moving Unix Applications to
         * Windows NT" (March 6, 1994) and "Creating Processes" on MSDN
         * (Februrary 2005).  It approximates UNIX spawn semantics with
         * the parent waiting for termination of the child.
         */
        memset(&si, 0, sizeof(si));
        si.cb =sizeof(STARTUPINFO);
        memset(&pi, 0, sizeof(pi));
        
		//启动新的进程执行命令行
        if (!CreateProcess((LPCTSTR)path,       /* executable name */
          (LPTSTR)cmdline,                      /* command line */
          (LPSECURITY_ATTRIBUTES)NULL,          /* process security attr. */
          (LPSECURITY_ATTRIBUTES)NULL,          /* thread security attr. */
          (BOOL)TRUE,                           /* inherits system handles */
          (DWORD)0,                             /* creation flags */
          (LPVOID)NULL,                         /* environment block */
          (LPCTSTR)NULL,                        /* current directory */
          (LPSTARTUPINFO)&si,                   /* (in) startup information */
          (LPPROCESS_INFORMATION)&pi)) {        /* (out) process information */
            JLI_ReportErrorMessageSys(SYS_ERROR1, path);
            exit(1);
        }

		//等待执行完成,超时时间设置为INT.MAX_VALUE: 0xFFFFFFFF
        if (WaitForSingleObject(pi.hProcess, INFINITE) != WAIT_FAILED) {
        	//获取退出代码
            if (GetExitCodeProcess(pi.hProcess, &exitCode) == FALSE)
                exitCode = 1;
        } else {
            JLI_ReportErrorMessage(SYS_ERROR2);
            exitCode = 1;
        }

		//关闭线程、进程句柄
        CloseHandle(pi.hThread);
        CloseHandle(pi.hProcess);
        
		//终止新的进程
        exit(exitCode);
    }
}

src/windows/bin/java_md.c::nextarg

/*
 * Local helper routine to isolate a single token (option or argument)
 * from the command line.
 *
 * This routine accepts a pointer to a character pointer.  The first
 * token (as defined by MSDN command-line argument syntax) is isolated
 * from that string.
 *
 * Upon return, the input character pointer pointed to by the parameter s
 * is updated to point to the remainding, unscanned, portion of the string,
 * or to a null character if the entire string has been consummed.
 *
 * This function returns a pointer to a null-terminated string which
 * contains the isolated first token, or to the null character if no
 * token could be isolated.
 *
 * Note the side effect of modifying the input string s by the insertion
 * of a null character, making it two strings.
 *
 * See "Parsing C Command-Line Arguments" in the MSDN Library for the
 * parsing rule details.  The rule summary from that specification is:
 *
 *  * Arguments are delimited by white space, which is either a space or a tab.
 *
 *  * A string surrounded by double quotation marks is interpreted as a single
 *    argument, regardless of white space contained within. A quoted string can
 *    be embedded in an argument. Note that the caret (^) is not recognized as
 *    an escape character or delimiter.
 *
 *  * A double quotation mark preceded by a backslash, \", is interpreted as a
 *    literal double quotation mark (").
 *
 *  * Backslashes are interpreted literally, unless they immediately precede a
 *    double quotation mark.
 *
 *  * If an even number of backslashes is followed by a double quotation mark,
 *    then one backslash (\) is placed in the argv array for every pair of
 *    backslashes (\\), and the double quotation mark (") is interpreted as a
 *    string delimiter.
 *
 *  * If an odd number of backslashes is followed by a double quotation mark,
 *    then one backslash (\) is placed in the argv array for every pair of
 *    backslashes (\\) and the double quotation mark is interpreted as an
 *    escape sequence by the remaining backslash, causing a literal double
 *    quotation mark (") to be placed in argv.
 * 
 * 在MSDN Library转换规则明细查看“C命令行参数转换”。根据规范,总结规则如下:
 * 
 * * 参数被空格(' ')或制表符('\t')等空白符号分割。
 * 
 * * 被双引号包围起来的字符串被认为是一个参数,无论里面是否包含空白符号(' ' | '\t')。
 *   被引起来的字符串可以嵌入到参数中。注意:插入符(^)不会被当作转义符或分隔符。
 * 
 * * 双引号前面加一个反斜杠,组成转义字符,转义成单个双引号(")。
 * 
 * * 反斜杠按字面解释,除非放在双引号之前。
 * 
 * * 如果偶数个反斜杠后面跟一个双引号, 则每对反斜杠组成转义字符,
 *   转义成单个反斜杠存储在 argv 数组中。
 * 
 * * 如果奇数个反斜杠后面跟一个双引号, 则每对反斜杠组成转义字符,
 *   转义成单个反斜杠存储在 argv 数组中。双引号作为字符串分隔符。
 */

// ******** 移除第一个命令行参数的斜杠 *********
static char*
nextarg(char** s) {
    char    *p = *s;
    char    *head;
    int     slashes = 0;//斜杠数量
    int     inquote = 0;//是否在引号中

    /*
     * Strip leading whitespace, which MSDN defines as only space or tab.
     * (Hence, no locale specific "isspace" here.)
     */
    //移除最前面的空白字符(' ' | '\t'), 并设为返回结果
    while (*p != (char)0 && (*p == ' ' || *p == '\t'))
        p++;
    head = p;                   /* Save the start of the token to return */

    /*
     * Isolate a token from the command line.
     */
    //根据空白字符(' ' | '\t')逐个剥离命令行参数
    while (*p != (char)0 && (inquote || !(*p == ' ' || *p == '\t'))) {
        if (*p == '\\' && *(p+1) == '"' && slashes % 2 == 0)
            p++;
        else if (*p == '"')
            inquote = !inquote;
        slashes = (*p++ == '\\') ? slashes + 1 : 0;
    }

    /*
     * If the token isolated isn't already terminated in a "char zero",
     * then replace the whitespace character with one and move to the
     * next character.
     * 如果剩余的命令行未以(char)0结束,用(char)0替换空白字符并将指针移动到下一个字符。???
     */
    //如果字符串指针首字符不为空字符,指针后移一个字符并赋值为空字符 (Dev C++执行抛异常)
    if (*p != (char)0)
        *p++ = (char)0;

    /*
     * Update the parameter to point to the head of the remaining string
     * reflecting the command line and return a pointer to the leading
     * token which was isolated from the command line.
     */
    //s指向剥离一个命令行参数后的字符串
    *s = p;
    return (head);
}

src/windows/bin/java_md.c::unquote

/*
 * Local helper routine to return a string equivalent to the input string
 * s, but with quotes removed so the result is a string as would be found
 * in argv[].  The returned string should be freed by a call to JLI_MemFree().
 *
 * The rules for quoting (and escaped quotes) are:
 *
 *  1 A double quotation mark preceded by a backslash, \", is interpreted as a
 *    literal double quotation mark (").
 *
 *  2 Backslashes are interpreted literally, unless they immediately precede a
 *    double quotation mark.
 *
 *  3 If an even number of backslashes is followed by a double quotation mark,
 *    then one backslash (\) is placed in the argv array for every pair of
 *    backslashes (\\), and the double quotation mark (") is interpreted as a
 *    string delimiter.
 *
 *  4 If an odd number of backslashes is followed by a double quotation mark,
 *    then one backslash (\) is placed in the argv array for every pair of
 *    backslashes (\\) and the double quotation mark is interpreted as an
 *    escape sequence by the remaining backslash, causing a literal double
 *    quotation mark (") to be placed in argv.
 */
static char*
unquote(const char *s) {
    const char *p = s;          /* Pointer to the tail of the original string */
    char *un = (char*)JLI_MemAlloc(JLI_StrLen(s) + 1);  /* Ptr to unquoted string */
    char *pun = un;             /* Pointer to the tail of the unquoted string */
	//移除双引号并返回
    while (*p != '\0') {
        if (*p == '"') {
        	//双引号直接跳过,指向下一字符
            p++;
        } else if (*p == '\\') {
        	//JLI_StrSpn从第一个字符开始匹配,此处可以直接简写成1
        	//如果反斜杠后紧跟双引号直接跳过双引号,只输出反斜杠
            const char *q = p + JLI_StrSpn(p,"\\");
            if (*q == '"')
                do {
                    *pun++ = '\\';
                    p += 2;
                 } while (*p == '\\' && p < q);
            else
                while (p < q)
                    *pun++ = *p++;
        } else {
        	//其它字符直接输出
            *pun++ = *p++;
        }
    }
    //将pun指针的值设为空串
    *pun = '\0';
    return un;
}

标签:5.4,string,argv,char,cmdline,源码,jdk8u,path,JLI
来源: https://blog.csdn.net/weixin_37477523/article/details/88130677