hgomez 01/05/14 02:34:49 Added: jk/src/native/common jk_jni_worker.c jk_jni_worker.h Log: jni worker stuff Revision Changes Path 1.1 jakarta-tomcat-connectors/jk/src/native/common/jk_jni_worker.c Index: jk_jni_worker.c =================================================================== /* * Copyright (c) 1997-1999 The Java Apache Project. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * 3. All advertising materials mentioning features or use of this * software must display the following acknowledgment: * "This product includes software developed by the Java Apache * Project for use in the Apache JServ servlet engine project * <http://java.apache.org/>." * * 4. The names "Apache JServ", "Apache JServ Servlet Engine" and * "Java Apache Project" must not be used to endorse or promote products * derived from this software without prior written permission. * * 5. Products derived from this software may not be called "Apache JServ" * nor may "Apache" nor "Apache JServ" appear in their names without * prior written permission of the Java Apache Project. * * 6. Redistributions of any form whatsoever must retain the following * acknowledgment: * "This product includes software developed by the Java Apache * Project for use in the Apache JServ servlet engine project * <http://java.apache.org/>." * * THIS SOFTWARE IS PROVIDED BY THE JAVA APACHE PROJECT "AS IS" AND ANY * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE JAVA APACHE PROJECT OR * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. * * This software consists of voluntary contributions made by many * individuals on behalf of the Java Apache Group. For more information * on the Java Apache Project and the Apache JServ Servlet Engine project, * please see <http://java.apache.org/>. * */ /*************************************************************************** * Description: In process JNI worker * * Author: Gal Shachor <[EMAIL PROTECTED]> * * Based on: * * Version: $Revision: 1.1 $ * ***************************************************************************/ #if !defined(WIN32) && !defined(NETWARE) #include <dlfcn.h> #endif #include <jni.h> #include "jk_pool.h" #include "jk_jni_worker.h" #include "jk_util.h" #if defined LINUX && defined APACHE2_SIGHACK #include <pthread.h> #include <signal.h> #include <bits/signum.h> #endif #ifdef NETWARE #include <nwthread.h> #include <nwadv.h> #endif #ifndef JNI_VERSION_1_1 #define JNI_VERSION_1_1 0x00010001 #endif #define null_check(e) if ((e) == 0) return JK_FALSE jint (JNICALL *jni_get_default_java_vm_init_args)(void *) = NULL; jint (JNICALL *jni_create_java_vm)(JavaVM **, JNIEnv **, void *) = NULL; #define JAVA_BRIDGE_CLASS_NAME ("org/apache/tomcat/service/JNIEndpoint") static jk_worker_t *the_singleton_jni_worker = NULL; struct jni_worker { int was_verified; int was_initialized; jk_pool_t p; jk_pool_atom_t buf[TINY_POOL_SIZE]; /* * JVM Object pointer. */ JavaVM *jvm; /* * [V] JNIEnv used for boostraping from validate -> init w/o an attach */ JNIEnv *tmp_env; /* * Web Server to Java bridge, instance and class. */ jobject jk_java_bridge_object; jclass jk_java_bridge_class; /* * Java methods ids, to jump into the JVM */ jmethodID jk_startup_method; jmethodID jk_service_method; jmethodID jk_shutdown_method; /* * Command line for tomcat startup */ char *tomcat_cmd_line; /* * Classpath */ char *tomcat_classpath; /* * Full path to the jni javai/jvm dll */ char *jvm_dll_path; /* * Initial Java heap size */ unsigned tomcat_ms; /* * Max Java heap size */ unsigned tomcat_mx; /* * Java system properties */ char **sysprops; #ifdef JNI_VERSION_1_2 /* * Java 2 initialization options (-X... , -verbose etc.) */ char **java2opts; /* * Java 2 lax/strict option checking (bool) */ int java2lax; #endif /* * stdout and stderr file names for Java */ char *stdout_name; char *stderr_name; char *name; jk_worker_t worker; }; typedef struct jni_worker jni_worker_t; struct jni_endpoint { int attached; JNIEnv *env; jni_worker_t *worker; jk_endpoint_t endpoint; }; typedef struct jni_endpoint jni_endpoint_t; static int load_jvm_dll(jni_worker_t *p, jk_logger_t *l); static int open_jvm(jni_worker_t *p, JNIEnv **env, jk_logger_t *l); static int open_jvm1(jni_worker_t *p, JNIEnv **env, jk_logger_t *l); #ifdef JNI_VERSION_1_2 static int detect_jvm_version(jk_logger_t *l); static int open_jvm2(jni_worker_t *p, JNIEnv **env, jk_logger_t *l); #endif static int get_bridge_object(jni_worker_t *p, JNIEnv *env, jk_logger_t *l); static int get_method_ids(jni_worker_t *p, JNIEnv *env, jk_logger_t *l); static JNIEnv *attach_to_jvm(jni_worker_t *p, jk_logger_t *l); static void detach_from_jvm(jni_worker_t *p, jk_logger_t *l); #if defined LINUX && defined APACHE2_SIGHACK static void linux_signal_hack() { sigset_t newM; sigset_t old; sigemptyset(&newM); pthread_sigmask( SIG_SETMASK, &newM, &old ); sigdelset(&old, SIGUSR1 ); sigdelset(&old, SIGUSR2 ); sigdelset(&old, SIGUNUSED ); sigdelset(&old, SIGRTMIN ); sigdelset(&old, SIGRTMIN + 1 ); sigdelset(&old, SIGRTMIN + 2 ); pthread_sigmask( SIG_SETMASK, &old, NULL ); } static void print_signals( sigset_t *sset) { int sig; for (sig = 1; sig < 20; sig++) { if (sigismember(sset, sig)) {printf( " %d", sig);} } printf( "\n"); } #endif static int JK_METHOD service(jk_endpoint_t *e, jk_ws_service_t *s, jk_logger_t *l, int *is_recoverable_error) { jni_endpoint_t *p; jint rc; jk_log(l, JK_LOG_DEBUG, "Into service\n"); if(!e || !e->endpoint_private || !s) { jk_log(l, JK_LOG_EMERG, "In service, assert failed - invalid parameters\n"); return JK_FALSE; } p = e->endpoint_private; if(!is_recoverable_error) { return JK_FALSE; } if(!p->attached) { /* Try to attach */ if(!(p->env = attach_to_jvm(p->worker, l))) { jk_log(l, JK_LOG_EMERG, "Attach failed\n"); /* Is it recoverable ?? */ *is_recoverable_error = JK_TRUE; return JK_FALSE; } p->attached = JK_TRUE; } /* we are attached now */ /* * When we call the JVM we cannot know what happens * So we can not recover !!! */ *is_recoverable_error = JK_FALSE; jk_log(l, JK_LOG_DEBUG, "In service, calling Tomcat...\n"); rc = (*(p->env))->CallIntMethod(p->env, p->worker->jk_java_bridge_object, p->worker->jk_service_method, /* [V] For some reason gcc likes this pointer -> int -> jlong conversion, */ /* but not the direct pointer -> jlong conversion. I hope it's okay. */ (jlong)(int)s, (jlong)(int)l); /* [V] Righ now JNIEndpoint::service() only returns 1 or 0 */ if(rc) { jk_log(l, JK_LOG_DEBUG, "In service, Tomcat returned OK, done\n"); return JK_TRUE; } else { jk_log(l, JK_LOG_ERROR, "In service, Tomcat FAILED!\n"); return JK_FALSE; } } static int JK_METHOD done(jk_endpoint_t **e, jk_logger_t *l) { jni_endpoint_t *p; jk_log(l, JK_LOG_DEBUG, "Into done\n"); if(!e || !*e || !(*e)->endpoint_private) { jk_log(l, JK_LOG_EMERG, "In done, assert failed - invalid parameters\n"); return JK_FALSE; } p = (*e)->endpoint_private; if(p->attached) { detach_from_jvm(p->worker,l); } free(p); *e = NULL; jk_log(l, JK_LOG_DEBUG, "Done ok\n"); return JK_TRUE; } static int JK_METHOD validate(jk_worker_t *pThis, jk_map_t *props, jk_logger_t *l) { jni_worker_t *p; int mem_config = 0; char *str_config = NULL; JNIEnv *env; jk_log(l, JK_LOG_DEBUG, "Into validate\n"); if(! pThis || ! pThis->worker_private) { jk_log(l, JK_LOG_EMERG, "In validate, assert failed - invalid parameters\n"); return JK_FALSE; } p = pThis->worker_private; if(p->was_verified) { jk_log(l, JK_LOG_DEBUG, "validate, been here before, done\n"); return JK_TRUE; } if(jk_get_worker_mx(props, p->name, (unsigned int *)&mem_config)) { p->tomcat_mx = mem_config; } if(jk_get_worker_ms(props, p->name, (unsigned int *)&mem_config)) { p->tomcat_ms = mem_config; } if(jk_get_worker_classpath(props, p->name, &str_config)) { p->tomcat_classpath = jk_pool_strdup(&p->p, str_config); } if(!p->tomcat_classpath) { jk_log(l, JK_LOG_EMERG, "Fail-> no classpath\n"); return JK_FALSE; } if(jk_get_worker_jvm_path(props, p->name, &str_config)) { p->jvm_dll_path = jk_pool_strdup(&p->p, str_config); } if(!p->jvm_dll_path || !jk_file_exists(p->jvm_dll_path)) { jk_log(l, JK_LOG_EMERG, "Fail-> no jvm_dll_path\n"); return JK_FALSE; } if(jk_get_worker_cmd_line(props, p->name, &str_config)) { p->tomcat_cmd_line = jk_pool_strdup(&p->p, str_config); } if(jk_get_worker_stdout(props, p->name, &str_config)) { p->stdout_name = jk_pool_strdup(&p->p, str_config); } if(jk_get_worker_stderr(props, p->name, &str_config)) { p->stderr_name = jk_pool_strdup(&p->p, str_config); } if(jk_get_worker_sysprops(props, p->name, &str_config)) { p->sysprops = jk_parse_sysprops(&p->p, str_config); } #ifdef JNI_VERSION_1_2 if(jk_get_worker_str_prop(props, p->name, "java2opts", &str_config)) { /* jk_log(l, JK_LOG_DEBUG, "Got opts: %s\n", str_config); */ p->java2opts = jk_parse_sysprops(&p->p, str_config); } if(jk_get_worker_int_prop(props, p->name, "java2lax", &mem_config)) { p->java2lax = mem_config ? JK_TRUE : JK_FALSE; } #endif if(jk_get_worker_libpath(props, p->name, &str_config)) { jk_append_libpath(&p->p, str_config); } if(!load_jvm_dll(p, l)) { jk_log(l, JK_LOG_EMERG, "Fail-> can't load jvm dll\n"); /* [V] no detach needed here */ return JK_FALSE; } if(!open_jvm(p, &env, l)) { jk_log(l, JK_LOG_EMERG, "Fail-> can't open jvm\n"); /* [V] no detach needed here */ return JK_FALSE; } if(!get_bridge_object(p, env, l)) { jk_log(l, JK_LOG_EMERG, "Fail-> can't get bridge object\n"); /* [V] the detach here may segfault on 1.1 JVM... */ detach_from_jvm(p, l); return JK_FALSE; } if(!get_method_ids(p, env, l)) { jk_log(l, JK_LOG_EMERG, "Fail-> can't get method ids\n"); /* [V] the detach here may segfault on 1.1 JVM... */ detach_from_jvm(p, l); return JK_FALSE; } p->was_verified = JK_TRUE; p->tmp_env = env; jk_log(l, JK_LOG_DEBUG, "Done validate\n"); return JK_TRUE; } static int JK_METHOD init(jk_worker_t *pThis, jk_map_t *props, jk_logger_t *l) { jni_worker_t *p; JNIEnv *env; jk_log(l, JK_LOG_DEBUG, "Into init\n"); if(! pThis || ! pThis->worker_private) { jk_log(l, JK_LOG_EMERG, "In init, assert failed - invalid parameters\n"); return JK_FALSE; } p = pThis->worker_private; if(p->was_initialized) { jk_log(l, JK_LOG_DEBUG, "init, done (been here!)\n"); return JK_TRUE; } if(!p->jvm || !p->jk_java_bridge_object || !p->jk_service_method || !p->jk_startup_method || !p->jk_shutdown_method) { jk_log(l, JK_LOG_EMERG, "Fail-> worker not set completely\n"); return JK_FALSE; } /* [V] init is called from the same thread that called validate */ /* there is no need to attach to the JVM, just get the env */ /* if(env = attach_to_jvm(p,l)) { */ if((env = p->tmp_env)) { jstring cmd_line = NULL; jstring stdout_name = NULL; jstring stderr_name = NULL; jint rc = 0; if(p->tomcat_cmd_line) { cmd_line = (*env)->NewStringUTF(env, p->tomcat_cmd_line); } if(p->stdout_name) { stdout_name = (*env)->NewStringUTF(env, p->stdout_name); } if(p->stdout_name) { stderr_name = (*env)->NewStringUTF(env, p->stderr_name); } jk_log(l, JK_LOG_DEBUG, "In init, calling Tomcat to intialize itself...\n"); rc = (*env)->CallIntMethod(env, p->jk_java_bridge_object, p->jk_startup_method, cmd_line, stdout_name, stderr_name); detach_from_jvm(p, l); if(rc) { p->was_initialized = JK_TRUE; jk_log(l, JK_LOG_DEBUG, "In init, Tomcat initialized OK, done\n"); return JK_TRUE; } else { jk_log(l, JK_LOG_EMERG, "Fail-> could not initialize Tomcat\n"); return JK_FALSE; } } else { jk_log(l, JK_LOG_ERROR, "In init, FIXME: init didn't gen env from validate!\n"); return JK_FALSE; } } static int JK_METHOD get_endpoint(jk_worker_t *pThis, jk_endpoint_t **pend, jk_logger_t *l) { /* [V] This slow, needs replacement */ jni_endpoint_t *p = (jni_endpoint_t *)malloc(sizeof(jni_endpoint_t)); jk_log(l, JK_LOG_DEBUG, "Into get_endpoint\n"); if(!pThis || ! pThis->worker_private || !pend) { jk_log(l, JK_LOG_EMERG, "In get_endpoint, assert failed - invalid parameters\n"); return JK_FALSE; } if(p) { p->attached = JK_FALSE; p->env = NULL; p->worker = pThis->worker_private; p->endpoint.endpoint_private = p; p->endpoint.service = service; p->endpoint.done = done; *pend = &p->endpoint; return JK_TRUE; } else { jk_log(l, JK_LOG_ERROR, "In get_endpoint, could not allocate endpoint\n"); return JK_FALSE; } } static int JK_METHOD destroy(jk_worker_t **pThis, jk_logger_t *l) { jni_worker_t *p; JNIEnv *env; jk_log(l, JK_LOG_DEBUG, "Into destroy\n"); if(!pThis || !*pThis || ! (*pThis)->worker_private) { jk_log(l, JK_LOG_EMERG, "In destroy, assert failed - invalid parameters\n"); return JK_FALSE; } p = (*pThis)->worker_private; if(!p->jvm) { jk_log(l, JK_LOG_DEBUG, "In destroy, JVM not intantiated\n"); return JK_FALSE; } if(!p->jk_java_bridge_object || ! p->jk_shutdown_method) { jk_log(l, JK_LOG_DEBUG, "In destroy, Tomcat not intantiated\n"); return JK_FALSE; } if((env = attach_to_jvm(p,l))) { jk_log(l, JK_LOG_DEBUG, "In destroy, shutting down Tomcat...\n"); (*env)->CallVoidMethod(env, p->jk_java_bridge_object, p->jk_shutdown_method); detach_from_jvm(p, l); } jk_close_pool(&p->p); free(p); jk_log(l, JK_LOG_DEBUG, "Done destroy\n"); return JK_TRUE; } int JK_METHOD jni_worker_factory(jk_worker_t **w, const char *name, jk_logger_t *l) { jni_worker_t *private_data; jk_log(l, JK_LOG_DEBUG, "Into jni_worker_factory\n"); if(!name || !w) { jk_log(l, JK_LOG_EMERG, "In jni_worker_factory, assert failed - invalid parameters\n"); return JK_FALSE; } if(the_singleton_jni_worker) { jk_log(l, JK_LOG_DEBUG, "In jni_worker_factory, instance already created\n"); *w = the_singleton_jni_worker; return JK_TRUE; } private_data = (jni_worker_t *)malloc(sizeof(jni_worker_t )); if(!private_data) { jk_log(l, JK_LOG_ERROR, "In jni_worker_factory, memory allocation error\n"); return JK_FALSE; } jk_open_pool(&private_data->p, private_data->buf, sizeof(jk_pool_atom_t) * TINY_POOL_SIZE); private_data->name = jk_pool_strdup(&private_data->p, name); if(!private_data->name) { jk_log(l, JK_LOG_ERROR, "In jni_worker_factory, memory allocation error\n"); jk_close_pool(&private_data->p); free(private_data); return JK_FALSE; } private_data->was_verified = JK_FALSE; private_data->was_initialized = JK_FALSE; private_data->jvm = NULL; private_data->tmp_env = NULL; private_data->jk_java_bridge_object = NULL; private_data->jk_java_bridge_class = NULL; private_data->jk_startup_method = NULL; private_data->jk_service_method = NULL; private_data->jk_shutdown_method = NULL; private_data->tomcat_cmd_line = NULL; private_data->tomcat_classpath = NULL; private_data->jvm_dll_path = NULL; private_data->tomcat_ms = 0; private_data->tomcat_mx = 0; private_data->sysprops = NULL; #ifdef JNI_VERSION_1_2 private_data->java2opts = NULL; private_data->java2lax = JK_TRUE; #endif private_data->stdout_name = NULL; private_data->stderr_name = NULL; private_data->worker.worker_private = private_data; private_data->worker.validate = validate; private_data->worker.init = init; private_data->worker.get_endpoint = get_endpoint; private_data->worker.destroy = destroy; *w = &private_data->worker; the_singleton_jni_worker = &private_data->worker; jk_log(l, JK_LOG_DEBUG, "Done jni_worker_factory\n"); return JK_TRUE; } static int load_jvm_dll(jni_worker_t *p, jk_logger_t *l) { #ifdef WIN32 HINSTANCE hInst = LoadLibrary(p->jvm_dll_path); if(hInst) { (FARPROC)jni_create_java_vm = GetProcAddress(hInst, "JNI_CreateJavaVM"); (FARPROC)jni_get_default_java_vm_init_args = GetProcAddress(hInst, "JNI_GetDefaultJavaVMInitArgs"); if(jni_create_java_vm && jni_get_default_java_vm_init_args) { return JK_TRUE; } FreeLibrary(hInst); } #elif defined(NETWARE) int javaNlmHandle = FindNLMHandle("JVM"); if (0 == javaNlmHandle) { /* if we didn't get a handle, try to load java and retry getting the */ /* handle */ spawnlp(P_NOWAIT, "JVM.NLM", NULL); ThreadSwitchWithDelay(); javaNlmHandle = FindNLMHandle("JVM"); if (0 == javaNlmHandle) printf("Error loading Java."); } if (0 != javaNlmHandle) { jni_create_java_vm = ImportSymbol(GetNLMHandle(), "JNI_CreateJavaVM"); jni_get_default_java_vm_init_args = ImportSymbol(GetNLMHandle(), "JNI_GetDefaultJavaVMInitArgs"); } if(jni_create_java_vm && jni_get_default_java_vm_init_args) { return JK_TRUE; } #else void *handle; jk_log(l, JK_LOG_DEBUG, "Into load_jvm_dll, load %s\n", p->jvm_dll_path); handle = dlopen(p->jvm_dll_path, RTLD_NOW | RTLD_GLOBAL); if(!handle) { jk_log(l, JK_LOG_EMERG, "Can't log native library %s : %s\n", p->jvm_dll_path, dlerror()); } else { jni_create_java_vm = dlsym(handle, "JNI_CreateJavaVM"); jni_get_default_java_vm_init_args = dlsym(handle, "JNI_GetDefaultJavaVMInitArgs"); if(jni_create_java_vm && jni_get_default_java_vm_init_args) { jk_log(l, JK_LOG_DEBUG, "In load_jvm_dll, symbols resolved, done\n"); return JK_TRUE; } jk_log(l, JK_LOG_EMERG, "Can't resolve JNI_CreateJavaVM or JNI_GetDefaultJavaVMInitArgs\n"); dlclose(handle); } #endif return JK_FALSE; } static int open_jvm(jni_worker_t *p, JNIEnv **env, jk_logger_t *l) { #ifdef JNI_VERSION_1_2 int jvm_version = detect_jvm_version(l); switch(jvm_version) { case JNI_VERSION_1_1: return open_jvm1(p, env, l); case JNI_VERSION_1_2: return open_jvm2(p, env, l); default: return JK_FALSE; } #else /* [V] Make sure this is _really_ visible */ #warning ------------------------------------------------------- #warning NO JAVA 2 HEADERS! SUPPORT FOR JAVA 2 FEATURES DISABLED #warning ------------------------------------------------------- return open_jvm1(p, env, l); #endif } static int open_jvm1(jni_worker_t *p, JNIEnv **env, jk_logger_t *l) { JDK1_1InitArgs vm_args; JNIEnv *penv; int err; *env = NULL; jk_log(l, JK_LOG_DEBUG, "Into open_jvm1\n"); vm_args.version = JNI_VERSION_1_1; if(0 != jni_get_default_java_vm_init_args(&vm_args)) { jk_log(l, JK_LOG_EMERG, "Fail-> can't get default vm init args\n"); return JK_FALSE; } jk_log(l, JK_LOG_DEBUG, "In open_jvm_dll, got default jvm args\n"); if(vm_args.classpath) { unsigned len = strlen(vm_args.classpath) + strlen(p->tomcat_classpath) + 3; char *tmp = jk_pool_alloc(&p->p, len); if(tmp) { sprintf(tmp, "%s%c%s", p->tomcat_classpath, PATH_SEPERATOR, vm_args.classpath); p->tomcat_classpath = tmp; } else { jk_log(l, JK_LOG_EMERG, "Fail-> allocation error for classpath\n"); return JK_FALSE; } } vm_args.classpath = p->tomcat_classpath; if(p->tomcat_mx) { vm_args.maxHeapSize = p->tomcat_mx; } if(p->tomcat_ms) { vm_args.minHeapSize = p->tomcat_ms; } if(p->sysprops) { vm_args.properties = p->sysprops; } jk_log(l, JK_LOG_DEBUG, "In open_jvm1, about to create JVM...\n"); if((err=jni_create_java_vm(&(p->jvm), &penv, &vm_args)) != 0) { jk_log(l, JK_LOG_EMERG, "Fail-> could not create JVM, code: %d \n", err); return JK_FALSE; } jk_log(l, JK_LOG_DEBUG, "In open_jvm1, JVM created, done\n"); *env = penv; return JK_TRUE; } #ifdef JNI_VERSION_1_2 static int detect_jvm_version(jk_logger_t *l) { JNIEnv *env = NULL; JDK1_1InitArgs vm_args; jk_log(l, JK_LOG_DEBUG, "Into detect_jvm_version\n"); /* [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_args.version = JNI_VERSION_1_2; if(0 != jni_get_default_java_vm_init_args(&vm_args)) { jk_log(l, JK_LOG_EMERG, "Fail-> can't get default vm init args\n"); return JK_FALSE; } jk_log(l, JK_LOG_DEBUG, "In detect_jvm_version, found: %X, done\n", vm_args.version); return vm_args.version; } static char* build_opt_str(jk_pool_t *p, char* opt_name, char* opt_value, jk_logger_t *l) { unsigned len = strlen(opt_name) + strlen(opt_value) + 2; /* [V] IMHO, these should not be deallocated as long as the JVM runs */ char *tmp = jk_pool_alloc(p, len); if(tmp) { sprintf(tmp, "%s%s", opt_name, opt_value); return tmp; } else { jk_log(l, JK_LOG_EMERG, "Fail-> build_opt_str allocation error for %s\n", opt_name); return NULL; } } static char* build_opt_int(jk_pool_t *p, char* opt_name, int opt_value, jk_logger_t *l) { /* [V] this should suffice even for 64-bit int */ unsigned len = strlen(opt_name) + 20 + 2; /* [V] IMHO, these should not be deallocated as long as the JVM runs */ char *tmp = jk_pool_alloc(p, len); if(tmp) { sprintf(tmp, "%s%d", opt_name, opt_value); return tmp; } else { jk_log(l, JK_LOG_EMERG, "Fail-> build_opt_int allocation error for %s\n", opt_name); return NULL; } } static int open_jvm2(jni_worker_t *p, JNIEnv **env, jk_logger_t *l) { JavaVMInitArgs vm_args; JNIEnv *penv; JavaVMOption options[100]; int optn = 0, err; char* tmp; *env = NULL; jk_log(l, JK_LOG_DEBUG, "Into open_jvm2\n"); vm_args.version = JNI_VERSION_1_2; vm_args.options = options; if(p->tomcat_classpath) { jk_log(l, JK_LOG_DEBUG, "In open_jvm2, setting classpath to %s\n", p->tomcat_classpath); tmp = build_opt_str(&p->p, "-Djava.class.path=", p->tomcat_classpath, l); null_check(tmp); options[optn++].optionString = tmp; } if(p->tomcat_mx) { jk_log(l, JK_LOG_DEBUG, "In open_jvm2, setting max heap to %d\n", p->tomcat_mx); tmp = build_opt_int(&p->p, "-Xmx", p->tomcat_mx, l); null_check(tmp); options[optn++].optionString = tmp; } if(p->tomcat_ms) { jk_log(l, JK_LOG_DEBUG, "In open_jvm2, setting start heap to %d\n", p->tomcat_ms); tmp = build_opt_int(&p->p, "-Xms", p->tomcat_ms, l); null_check(tmp); options[optn++].optionString = tmp; } if(p->sysprops) { int i = 0; while(p->sysprops[i]) { jk_log(l, JK_LOG_DEBUG, "In open_jvm2, setting %s\n", p->sysprops[i]); tmp = build_opt_str(&p->p, "-D", p->sysprops[i], l); null_check(tmp); options[optn++].optionString = tmp; i++; } } if(p->java2opts) { int i=0; while(p->java2opts[i]) { jk_log(l, JK_LOG_DEBUG, "In open_jvm2, using option: %s\n", p->java2opts[i]); /* Pass it "as is" */ options[optn++].optionString = p->java2opts[i++]; } } vm_args.nOptions = optn; if(p->java2lax) { jk_log(l, JK_LOG_DEBUG, "In open_jvm2, the JVM will ignore unknown options\n"); vm_args.ignoreUnrecognized = JNI_TRUE; } else { jk_log(l, JK_LOG_DEBUG, "In open_jvm2, the JVM will FAIL if it finds unknown options\n"); vm_args.ignoreUnrecognized = JNI_FALSE; } jk_log(l, JK_LOG_DEBUG, "In open_jvm2, about to create JVM...\n"); if((err=jni_create_java_vm(&(p->jvm), &penv, &vm_args)) != 0) { jk_log(l, JK_LOG_EMERG, "Fail-> could not create JVM, code: %d \n", err); return JK_FALSE; } jk_log(l, JK_LOG_DEBUG, "In open_jvm2, JVM created, done\n"); *env = penv; return JK_TRUE; } #endif static int get_bridge_object(jni_worker_t *p, JNIEnv *env, jk_logger_t *l) { jmethodID constructor_method_id; jk_log(l, JK_LOG_DEBUG, "Into get_bridge_object\n"); p->jk_java_bridge_class = (*env)->FindClass(env, JAVA_BRIDGE_CLASS_NAME); if(!p->jk_java_bridge_class) { jk_log(l, JK_LOG_EMERG, "Can't find class %s\n", JAVA_BRIDGE_CLASS_NAME); return JK_FALSE; } jk_log(l, JK_LOG_DEBUG, "In get_bridge_object, loaded %s bridge class\n", JAVA_BRIDGE_CLASS_NAME); constructor_method_id = (*env)->GetMethodID(env, p->jk_java_bridge_class, "<init>", /* method name */ "()V"); /* method sign */ if(!constructor_method_id) { p->jk_java_bridge_class = NULL; jk_log(l, JK_LOG_EMERG, "Can't find constructor\n"); return JK_FALSE; } p->jk_java_bridge_object = (*env)->NewObject(env, p->jk_java_bridge_class, constructor_method_id); if(! p->jk_java_bridge_object) { p->jk_java_bridge_class = NULL; jk_log(l, JK_LOG_EMERG, "Can't create new bridge object\n"); return JK_FALSE; } p->jk_java_bridge_object = (jobject)(*env)->NewGlobalRef(env, p->jk_java_bridge_object); if(! p->jk_java_bridge_object) { jk_log(l, JK_LOG_EMERG, "Can't create global ref to bridge object\n"); p->jk_java_bridge_class = NULL; p->jk_java_bridge_object = NULL; return JK_FALSE; } jk_log(l, JK_LOG_DEBUG, "In get_bridge_object, bridge built, done\n"); return JK_TRUE; } static int get_method_ids(jni_worker_t *p, JNIEnv *env, jk_logger_t *l) { p->jk_startup_method = (*env)->GetMethodID(env, p->jk_java_bridge_class, "startup", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I"); if(!p->jk_startup_method) { jk_log(l, JK_LOG_EMERG, "Can't find startup()\n"); return JK_FALSE; } p->jk_service_method = (*env)->GetMethodID(env, p->jk_java_bridge_class, "service", "(JJ)I"); if(!p->jk_service_method) { jk_log(l, JK_LOG_EMERG, "Can't find service()\n"); return JK_FALSE; } p->jk_shutdown_method = (*env)->GetMethodID(env, p->jk_java_bridge_class, "shutdown", "()V"); if(!p->jk_shutdown_method) { jk_log(l, JK_LOG_EMERG, "Can't find shutdown()\n"); return JK_FALSE; } return JK_TRUE; } static JNIEnv *attach_to_jvm(jni_worker_t *p, jk_logger_t *l) { JNIEnv *rc = NULL; /* [V] This message is important. If there are signal mask issues, * * the JVM usually hangs when a new thread tries to attach to it */ jk_log(l, JK_LOG_DEBUG, "Into attach_to_jvm\n"); #if defined LINUX && defined APACHE2_SIGHACK linux_signal_hack(); #endif if(0 == (*(p->jvm))->AttachCurrentThread(p->jvm, #ifdef JNI_VERSION_1_2 (void **) #endif &rc, NULL)) { jk_log(l, JK_LOG_DEBUG, "In attach_to_jvm, attached ok\n"); return rc; } jk_log(l, JK_LOG_ERROR, "In attach_to_jvm, cannot attach thread to JVM.\n"); return NULL; } /* static JNIEnv *attach_to_jvm(jni_worker_t *p) { JNIEnv *rc = NULL; #ifdef LINUX linux_signal_hack(); #endif if(0 == (*(p->jvm))->AttachCurrentThread(p->jvm, #ifdef JNI_VERSION_1_2 (void **) #endif &rc, NULL)) { return rc; } return NULL; } */ static void detach_from_jvm(jni_worker_t *p, jk_logger_t *l) { if(!p->jvm || !(*(p->jvm))) { jk_log(l, JK_LOG_ERROR, "In detach_from_jvm, cannot detach from NULL JVM.\n"); } if(0 == (*(p->jvm))->DetachCurrentThread(p->jvm)) { jk_log(l, JK_LOG_DEBUG, "In detach_from_jvm, detached ok\n"); } else { jk_log(l, JK_LOG_ERROR, "In detach_from_jvm, cannot detach from JVM.\n"); } } 1.1 jakarta-tomcat-connectors/jk/src/native/common/jk_jni_worker.h Index: jk_jni_worker.h =================================================================== /* * Copyright (c) 1997-1999 The Java Apache Project. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * 3. All advertising materials mentioning features or use of this * software must display the following acknowledgment: * "This product includes software developed by the Java Apache * Project for use in the Apache JServ servlet engine project * <http://java.apache.org/>." * * 4. The names "Apache JServ", "Apache JServ Servlet Engine" and * "Java Apache Project" must not be used to endorse or promote products * derived from this software without prior written permission. * * 5. Products derived from this software may not be called "Apache JServ" * nor may "Apache" nor "Apache JServ" appear in their names without * prior written permission of the Java Apache Project. * * 6. Redistributions of any form whatsoever must retain the following * acknowledgment: * "This product includes software developed by the Java Apache * Project for use in the Apache JServ servlet engine project * <http://java.apache.org/>." * * THIS SOFTWARE IS PROVIDED BY THE JAVA APACHE PROJECT "AS IS" AND ANY * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE JAVA APACHE PROJECT OR * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. * * This software consists of voluntary contributions made by many * individuals on behalf of the Java Apache Group. For more information * on the Java Apache Project and the Apache JServ Servlet Engine project, * please see <http://java.apache.org/>. * */ /*************************************************************************** * Description: jni worker header file * * Author: Gal Shachor <[EMAIL PROTECTED]> * * Version: $Revision: 1.1 $ * ***************************************************************************/ #ifndef JK_JNI_WORKER_H #define JK_JNI_WORKER_H #include "jk_logger.h" #include "jk_service.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ #define JK_JNI_WORKER_NAME ("jni") int JK_METHOD jni_worker_factory(jk_worker_t **w, const char *name, jk_logger_t *l); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* JK_JNI_WORKER_H */
