jk_vm_default.c

Tomcat 4.1与WebServer集成组件的源代码包.

    }
    return JK_FALSE;
}

/* Add more guessing, based on various vm layouts */

/* Some guessing - to spare the user ( who might know less
   than we do ).
*/
#ifdef WIN32
/* On WIN32 use the Registry couse Java itself relies on that.
*/
#define JAVASOFT_REGKEY "SOFTWARE\\JavaSoft\\Java Runtime Environment\\"

static char* jk2_vm_guessJvmDll(jk_env_t *env, jk_map_t *props,
                         jk_vm_t *jkvm)
{
    HKEY hkjs;
    static char jvm[MAX_PATH+1];
    char reg[MAX_PATH+1];
    char *cver;
    jk_pool_t *p=props->pool;
    unsigned int err, klen = MAX_PATH;
    
   strcpy(reg, JAVASOFT_REGKEY);
   cver = &reg[sizeof(JAVASOFT_REGKEY)-1];
    if( (err=RegOpenKeyEx(HKEY_LOCAL_MACHINE, reg,
                       0, KEY_READ, &hkjs) ) != ERROR_SUCCESS) {
        env->l->jkLog(env, env->l, JK_LOG_INFO,
                      "jni.guessJvmDll() failed to open Registry key\n");
       return NULL;
   }
    if( (err=RegQueryValueEx(hkjs, "CurrentVersion", NULL, NULL, 
                           (unsigned char *)cver, &klen) ) != ERROR_SUCCESS) {
        env->l->jkLog(env, env->l, JK_LOG_INFO,
                      "jni.guessJvmDll() failed obtaining Current Version\n");
       RegCloseKey(hkjs);
       return NULL;
   }
    RegCloseKey(hkjs);
    if( (err=RegOpenKeyEx(HKEY_LOCAL_MACHINE, reg,
                       0, KEY_READ, &hkjs) ) != ERROR_SUCCESS) {
        env->l->jkLog(env, env->l, JK_LOG_INFO,
                      "jni.guessJvmDll() failed to open Registry key\n");
       return NULL;
   }
   klen = MAX_PATH;
    if( (err=RegQueryValueEx(hkjs, "RuntimeLib", NULL, NULL, 
                           (unsigned char *)jvm, &klen) ) != ERROR_SUCCESS) {
        env->l->jkLog(env, env->l, JK_LOG_INFO,
                      "jni.guessJvmDll() failed obtaining Runtime Library\n");
       RegCloseKey(hkjs);
       return NULL;
   }
    RegCloseKey(hkjs);

    return jvm;
}
#else
static char* jk2_vm_guessJvmDll(jk_env_t *env, jk_map_t *props,
                         jk_vm_t *jkvm)
{
    char *jvm;
    jk_pool_t *p=props->pool;
    const char **current=defaultVM_PATH;
    
    /* We need at least JAVA_HOME ( either env or in settings )
     */
    while( *current != NULL ) {
        jvm = jk2_config_replaceProperties(env, props, p,
                                           (char *)p->pstrdup( env, p, *current ) );

        if( jvm!=NULL && jk2_file_exists(env, jvm)) {
            char *ldlib;
            env->l->jkLog(env, env->l, JK_LOG_INFO,
                         "jni.guessJvmDll() trying %s\n", jvm);
            /* Check if the LD_LIBRARY_PATH points to the discovered jvm.
             * XXX only tested on Linux.
             */
#if defined(LINUX)
            ldlib = getenv(PATH_ENV_VARIABLE);
            if (ldlib && strlen(ldlib)) {
                char *token;
                
                token = strtok(ldlib, PATH_SEPARATOR_STR);
                while (token != NULL) {
                    if (strncmp(token, jvm, strlen(token)) == 0) {
                        env->l->jkLog(env, env->l, JK_LOG_INFO,
                                      "jni.guessJvmDll() found %s in %s.\n", jvm, token);
                        return jvm;
                    } 
                    token = strtok(NULL, PATH_SEPARATOR_STR);                   
                }
                env->l->jkLog(env, env->l, JK_LOG_INFO,
                              "jni.guessJvmDll() could not find %s in the " \ 
                              "LD_LIBRARY_PATH\n",
                              jvm);
                return NULL;                                    
            }
            env->l->jkLog(env, env->l, JK_LOG_INFO,
                          "jni.guessJvmDll() LD_LIBRARY_PATH " \
                          "environment var is not set\n");
            return NULL;                                
#else
            return jvm;
#endif
        }

        env->l->jkLog(env, env->l, JK_LOG_INFO,
                      "jni.guessJvmDll() failed %s\n", jvm);
        current++;
    }
    
    env->l->jkLog(env, env->l, JK_LOG_INFO,
                  "jni.guessJvmDll() failed\n");
        
    return NULL;
}
#endif

static int jk2_vm_initVM(jk_env_t *env, jk_vm_t *jkvm)
{
    int jvm_version;
    JDK1_1InitArgs vm_args11;
    jk_map_t *props=jkvm->properties;
    JavaVMInitArgs vm_args;
    JNIEnv *penv;
    JavaVMOption options[JK2_MAXOPTIONS * 2];
    JavaVM *jvm;
    int optn = 0, err, classn = 0, classl = 0, i;
    char *classpath = NULL;

    /** Make sure we have the vm dll */
    if( jkvm->jvm_dll_path ==NULL ||
        ! jk2_file_exists(env, jkvm->jvm_dll_path )) {
        jkvm->jvm_dll_path=jk2_vm_guessJvmDll( env, props, jkvm  );
    }
    
    if( jkvm->jvm_dll_path==NULL ) {
        jkvm->jvm_dll_path=
            jk2_config_replaceProperties(env, props, props->pool,"libjvm.${so}");
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "vm.init(): no jvm_dll_path, will use LD_LIBRARY_PATH %s\n",
                      jkvm->jvm_dll_path);
    } else {
        env->l->jkLog(env, env->l, JK_LOG_INFO, "vm.init(): Jni lib: %s\n",
                      jkvm->jvm_dll_path );
    }

    err=jk2_vm_loadJvm(env, jkvm );

    if( err!=JK_OK ) {
        env->l->jkLog(env, env->l, JK_LOG_EMERG,
                      "jni.loadJvm() Error - can't load jvm dll\n");
        /* [V] no detach needed here */
        return JK_ERR;
    }

    
#if defined LINUX && defined APACHE2_SIGHACK
    /* [V] This message is important. If there are signal mask issues,    *
     *     the JVM usually hangs when a new thread tries to attach to it  */
    /* XXX do we need to do that on _each_ attach or only when we create
       the vm ??? */
    jk2_linux_signal_hack(); 
#endif

    /* That's kind of strange - if we have JNI_VERSION_1_2 I assume
       we also have 1.2, what do we detect ???? */

    /* [V] Idea: ask for 1.2. If the JVM is 1.1 it will return 1.1 instead  */
    /*     Note: asking for 1.1 won't work, 'cause 1.2 JVMs will return 1.1 */
    vm_args11.version = JNI_VERSION_1_2;

    if(0 != jni_get_default_java_vm_init_args(&vm_args11)) {
    	env->l->jkLog(env, env->l, JK_LOG_EMERG,
                      "vm.detect() Fail-> can't get default vm init args\n"); 
        return JK_ERR;
    }

    jvm_version= vm_args11.version;

    if(jvm_version != JNI_VERSION_1_2 ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
                      "vm.detect() found: %X expecting 1.2\n", jvm_version);
        return JK_ERR;
    }

    for (classn = 0; classn < jkvm->nClasspath; classn++)
        classl += strlen(jkvm->classpath[classn]);
    if (classl) {
        classpath = jkvm->pool->calloc(env, jkvm->pool, 
                                       classl + classn + sizeof("-Djava.class.path="));
        strcpy(classpath, "-Djava.class.path=");
        strcat(classpath, jkvm->classpath[0]);        
        for (i = 1; i < classn; i++) {
            strcat(classpath, PATH_SEPARATOR_STR);
            strcat(classpath, jkvm->classpath[i]);
        }
    }
    while(jkvm->options[optn]) {
        if (jkvm->mbean->debug > 1)
            env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                          "vm.openJvm2() Option: %s\n", jkvm->options[optn]);
        /* Pass it "as is" */
        options[optn].optionString = jkvm->options[optn];
        optn++;
    }
    if (classpath) {
        if (jkvm->mbean->debug > 1)
            env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                          "vm.openJvm2() Classpath: %s\n", classpath);
        options[optn++].optionString = classpath;
    }
    
    /* Set the abort and exit hooks */
    options[optn].optionString = "exit";
    options[optn++].extraInfo = jk2_jni_exit_hook;
    options[optn].optionString = "abort";
    options[optn++].extraInfo = jk2_jni_abort_hook;
    
    vm_args.version = JNI_VERSION_1_2;
    vm_args.options = options;
    vm_args.nOptions = optn;    
    vm_args.ignoreUnrecognized = JNI_TRUE;

    err=jni_create_java_vm(&jvm, &penv, &vm_args);
    
    if (JNI_EEXIST == err) {
        int vmCount;
        
        env->l->jkLog(env, env->l, JK_LOG_INFO,
                      "vm.open2() try to attach to existing vm.\n");

        err=jni_get_created_java_vms(&jvm, 1, &vmCount);
        
        if (NULL == jvm) {
            env->l->jkLog(env, env->l, JK_LOG_INFO,
                          "vm.open1() error attaching %d\n", err);
            return JK_ERR;
        }

        jkvm->jvm=(void *)jvm;
        return JK_OK;
    } else if( err!=0 ) {
    	env->l->jkLog(env, env->l, JK_LOG_EMERG,
                      "Fail-> could not create JVM, code: %d \n", err); 
        return JK_ERR;
    }

    jkvm->jvm=(void *)jvm;

    env->l->jkLog(env, env->l, JK_LOG_INFO,
                  "vm.open2() done\n");

    return JK_OK;
}

static void jk2_vm_destroy(jk_env_t *env, jk_vm_t *jkvm)
{
    int err;
    JavaVM *jvm = (JavaVM *)jkvm->jvm;
    
    if (jvm == NULL || jk2_jni_abort_signaled) {
        return;
    }

    err= (*jvm)->DestroyJavaVM(jvm);
    if(err == 0 ) {
        env->l->jkLog(env, env->l, JK_LOG_INFO, 
                      "vm.destroy() ok\n");
    } else {
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
                      "vm.destroy() cannot destroy the JVM.\n");
    }
}

static int JK_METHOD
jk2_jk_vm_setProperty(jk_env_t *env, jk_bean_t *mbean, char *name, void *valueP )
{
    jk_vm_t *jkvm=mbean->object;
    char *value=valueP;
    
    if( strcmp( name, "OPT" )==0 ) {
        if (jkvm->nOptions < JK2_MAXOPTIONS) {
            jkvm->options[jkvm->nOptions]=value;
            jkvm->nOptions++;
        }
    } else if( strcmp( name, "JVM" )==0 ) {
        jkvm->jvm_dll_path=value;
    }
    else if( strcmp( name, "classpath" )==0 ) {
        if (jkvm->nClasspath < JK2_MAXOPTIONS) {
            jkvm->classpath[jkvm->nClasspath]=value;
            jkvm->nClasspath++;
        }
    } else {
        return JK_ERR;
    }

    return JK_OK;
}


int JK_METHOD jk2_vm_factory(jk_env_t *env, jk_pool_t *pool,
                             jk_bean_t *result, char *type, char *name)
{
    jk_vm_t *jkvm;
    jk_workerEnv_t *workerEnv;
    
    workerEnv=env->getByName( env, "workerEnv" );
    
    /* TODO: use timeframe for child generation
     * 
    */
    if (workerEnv->childGeneration > 10) {
        result->disabled = 1;
        return JK_OK;
    }
    jkvm = (jk_vm_t *)pool->calloc(env, pool, sizeof(jk_vm_t ));

    jkvm->pool=pool;

    jkvm->jvm_dll_path = NULL;
    jkvm->nOptions =0;

    jkvm->init=jk2_vm_initVM;
    jkvm->attach=jk2_vm_attach;
    jkvm->detach=jk2_vm_detach;
    jkvm->destroy=jk2_vm_destroy;
    
    result->object=jkvm;
    result->setAttribute=jk2_jk_vm_setProperty;
    jkvm->mbean=result;

    jkvm->properties=workerEnv->initData;

    workerEnv->vm=jkvm;
    
    return JK_OK;
}

#endif /* Java2 */

#else /* HAVE_JNI */

int JK_METHOD jk2_vm_factory(jk_env_t *env, jk_pool_t *pool,
                             jk_bean_t *result, char *type, char *name)
{
    result->disabled=1;
    return JK_OK;
}
#endif