tomcat-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hgo...@apache.org
Subject cvs commit: jakarta-tomcat/proposals/web-connector/native/common jk_jni_worker.c jk_jni_worker.h
Date Thu, 03 May 2001 14:27:03 GMT
hgomez      01/05/03 07:27:03

  Added:       proposals/web-connector/native/common jk_jni_worker.c
                        jk_jni_worker.h
  Log:
  JNI connectivity
  
  Revision  Changes    Path
  1.1                  jakarta-tomcat/proposals/web-connector/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 <shachor@il.ibm.com>                           *
   * 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/proposals/web-connector/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 <shachor@il.ibm.com>                           *
   * 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 */
  
  
  

Mime
View raw message