jk_isapi_plugin.c

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

                _splitpath( file_name, drive, dir, fname, NULL );
                _makepath( ini_file_name, drive, dir, fname, ".properties" );
                
            } else {
                fReturn = JK_FALSE;
            }
        break;
        default:
        break;
    } 
    return fReturn;
}

static int init_jk(char *serverName)
{
    int rc = JK_TRUE;  
    /* XXX this need review, works well because the initializations are done at the first request 
       but in case inits should be splited another time using directly globalEnv here could lead 
       to subtle problems.. 
    */   
    jk_env_t *env = workerEnv->globalEnv;
    workerEnv->initData->add( env, workerEnv->initData, "serverRoot",
                              workerEnv->pool->pstrdup( env, workerEnv->pool, server_root));
    /* Logging the initialization type: registry or properties file in virtual dir
    */
    if(strlen(worker_file)){
        rc=(JK_OK == workerEnv->config->setPropertyString( env, workerEnv->config, "config.file", worker_file ));
    }
    workerEnv->init(env,workerEnv);
    env->l->jkLog(env, env->l, JK_LOG_INFO, "Set serverRoot %s\n", server_root);
    if (using_ini_file) {
        env->l->jkLog(env, env->l,  JK_LOG_DEBUG, "Using ini file %s.\n", ini_file_name);
    } else {
        env->l->jkLog(env, env->l,  JK_LOG_DEBUG, "Using registry.\n");
    }
    env->l->jkLog(env, env->l,  JK_LOG_DEBUG, "Using extension uri %s.\n", extension_uri);
    env->l->jkLog(env, env->l,  JK_LOG_DEBUG, "Using server root %s.\n", server_root);
    env->l->jkLog(env, env->l,  JK_LOG_DEBUG, "Using worker file %s.\n", worker_file);
    return rc;
}

static int initialize_extension()
{
    jk_env_t *env=jk2_create_config();   
    if (read_registry_init_data(env)) {
        jk2_iis_init_pool(env);
        is_inited = JK_TRUE;
    }
    return is_inited;
}

static int read_registry_init_data(jk_env_t *env)
{
    char tmpbuf[INTERNET_MAX_URL_LENGTH];
    HKEY hkey;
    long rc;
    int  ok = JK_TRUE; 
    char *tmp;
    jk_map_t *map;
   
    if (JK_OK==jk2_map_default_create(env, &map, workerEnv->pool )) {
        if (JK_OK==jk2_config_file_read(env,map, ini_file_name)) {
            tmp = map->get(env,map,EXTENSION_URI_TAG);
            if (tmp) {
                strcpy(extension_uri, tmp);
            } else {
                ok = JK_FALSE;
            }
            tmp = map->get(env,map,SERVER_ROOT_TAG);
            if (tmp) {
                strcpy(server_root, tmp);
            } else {
                ok = JK_FALSE;
            }
            tmp = map->get(env,map,WORKERS_FILE_TAG);
            if (tmp) {
                strcpy(worker_file, tmp);
            }
            tmp = map->get(env,map,THREAD_POOL_TAG);
            if (tmp) {
                use_thread_pool = atoi(tmp);
                if (use_thread_pool < 10)
                    use_thread_pool = 0;
            }
            tmp = map->get(env,map,USE_AUTH_COMP_TAG);
            if (tmp) {
                use_auth_notification_flags = atoi(tmp);
            }
            using_ini_file=JK_TRUE;            
            return ok;
        }     
    } else {
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
               "read_registry_init_data, Failed to create map \n");
    }
    rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                      REGISTRY_LOCATION,
                      (DWORD)0,
                      KEY_READ,
                      &hkey);
    if(ERROR_SUCCESS != rc) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
               "read_registry_init_data, Failed Registry OpenKey %s\n",REGISTRY_LOCATION);
        return JK_FALSE;
    } 

    if(get_registry_config_parameter(hkey,
                                     EXTENSION_URI_TAG,
                                     tmpbuf,
                                     sizeof(extension_uri))) {
        strcpy(extension_uri, tmpbuf);
    } else {
        ok = JK_FALSE;
    }

    if(get_registry_config_parameter(hkey,
                                     SERVER_ROOT_TAG,
                                     tmpbuf,
                                     sizeof(server_root))) {
        strcpy(server_root, tmpbuf);
    } else {
        ok = JK_FALSE;
    }
    if(get_registry_config_parameter(hkey,
                                     WORKERS_FILE_TAG,
                                     tmpbuf,
                                     sizeof(server_root))) {
        strcpy(worker_file, tmpbuf);
    } else {
        ok = JK_FALSE;
    }
    if(get_registry_config_parameter(hkey,
                                     THREAD_POOL_TAG,
                                     tmpbuf,
                                     8)) {
        use_thread_pool = atoi(tmpbuf);
        if (use_thread_pool < 10) {
            use_thread_pool = 0;
            env->l->jkLog(env, env->l, JK_LOG_INFO, 
                          "read_registry_init_data, ThreadPool must be set to the value 10 or higher\n");
        }
    }
    if(get_registry_config_parameter(hkey,
                                     USE_AUTH_COMP_TAG,
                                     tmpbuf,
                                     8)) {
        use_auth_notification_flags = atoi(tmpbuf);
    }

    RegCloseKey(hkey);
    return ok;
} 

static int get_registry_config_parameter(HKEY hkey,
                                         const char *tag, 
                                         char *b,
                                         DWORD sz)
{   
    DWORD type = 0;
    LONG  lrc;

    lrc = RegQueryValueEx(hkey,     
                          tag,      
                          (LPDWORD)0,
                          &type,    
                          (LPBYTE)b,
                          &sz); 
    if ((ERROR_SUCCESS != lrc) || (type != REG_SZ)) {
        return JK_FALSE;        
    }
    
    b[sz] = '\0';

    return JK_TRUE;     
}


/** Basic initialization for jk2.
 */
static  jk_env_t*  jk2_create_workerEnv (void) {

    jk_logger_t *l;
    jk_pool_t *globalPool;
    jk_bean_t *jkb;
    jk_env_t *env;

    jk2_pool_apr_create( NULL, &globalPool, NULL, jk_globalPool );

    /** Create the global environment. This will register the default
        factories
    */
    env=jk2_env_getEnv( NULL, globalPool );

    /* Optional. Register more factories ( or replace existing ones ) */
    /* Init the environment. */
    
    /* Create the logger */
    jkb=env->createBean2( env, env->globalPool, "logger.win32", "");
    env->alias( env, "logger.win32:", "logger");
    l = jkb->object;
    
    env->l=l;
    env->soName=env->globalPool->pstrdup(env, env->globalPool, file_name );
    
    if( env->soName == NULL ){
        env->l->jkLog(env, env->l, JK_LOG_ERROR, "Error creating env->soName\n");
        return env;
    }
    env->l->init(env,env->l);

    /* We should make it relative to JK_HOME or absolute path.
       ap_server_root_relative(cmd->pool,opt); */
    
    /* Create the workerEnv */
    jkb=env->createBean2( env, env->globalPool,"workerEnv", "");
    workerEnv= jkb->object;
    env->alias( env, "workerEnv:" , "workerEnv");
    
    if( workerEnv==NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR, "Error creating workerEnv\n");
        return env;
    }

    workerEnv->childId = 0;
/* XXX 
    
    Detect install dir, be means of service configs, */

    
    return env;
}

static jk_env_t * jk2_create_config()
{
    jk_env_t *env;
    if(  workerEnv==NULL ) {
        env = jk2_create_workerEnv();
        env->l->jkLog(env, env->l, JK_LOG_INFO, "JK2 Config Created");
    } else {
        env = workerEnv->globalEnv->getEnv( workerEnv->globalEnv );
        env->l->jkLog(env, env->l, JK_LOG_INFO, "JK2 Config Reused");
    }

    
   
    return env;
}

#ifdef SF_NOTIFY_AUTH_COMPLETE
static int get_auth_flags()
{
    HKEY hkey;
    long rc;
    int maj, sz;
    int rv = SF_NOTIFY_PREPROC_HEADERS;
    int use_auth = JK_FALSE;
    /* Retreive the IIS version Major*/
    rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                      W3SVC_REGISTRY_KEY,
                      (DWORD)0,
                      KEY_READ,
                      &hkey);
    if(ERROR_SUCCESS != rc) {
        return rv;
    } 
    sz = sizeof(int);
    rc = RegQueryValueEx(hkey,     
                         "MajorVersion",      
                          NULL,
                          NULL,    
                          (LPBYTE)&maj,
                          &sz); 
    if (ERROR_SUCCESS != rc) {
        CloseHandle(hkey);
        return rv;        
    }
    CloseHandle(hkey);
    if (use_auth_notification_flags && maj > 4)
        rv = SF_NOTIFY_AUTH_COMPLETE;

    return rv;
}
#else
static int get_auth_flags()
{
    return SF_NOTIFY_PREPROC_HEADERS;
}
#endif