jk_urimap.c

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

    int i;

    for (i = 0; i < uriMap->maps->size(env, uriMap->maps); i++) {
        jk_uriEnv_t *uriEnv = uriMap->maps->valueAt(env, uriMap->maps, i);
        if (uriEnv == NULL) 
            continue;
        if (uriEnv->virtual != NULL && strlen(uriEnv->virtual)) {
            if (uriEnv->match_type == MATCH_TYPE_HOST) {
                jk2_map_default_create(env, &uriEnv->webapps, uriMap->pool);
                uriMap->vhosts->put(env, uriMap->vhosts,
                                    uriEnv->virtual, uriEnv, NULL);
            } 
            else { /* Create the missing vhosts */
                if (!uriMap->vhosts->get(env, uriMap->vhosts,
                                         uriEnv->virtual)) {
                    jk2_map_default_create(env, &uriEnv->webapps, uriMap->pool);
                    uriMap->vhosts->put(env, uriMap->vhosts,
                                        uriEnv->virtual, uriEnv, NULL);

                    env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                                  "uriMap.init() Fixing Host %s\n", 
                                  uriEnv->virtual);
                }
            }
        }
    }

    /** Make sure each vhost has a default context
     */
    for(i = 0; i < uriMap->vhosts->size(env, uriMap->vhosts); i++) {
        jk_uriEnv_t *hostEnv = uriMap->vhosts->valueAt(env, uriMap->vhosts, i);
        jk_uriEnv_t *rootCtx;
        char *uriPath;
        
        if (hostEnv->virtual != NULL) {
            uriPath=env->tmpPool->calloc(env, env->tmpPool,
                                         strlen(hostEnv->virtual) + 3);
            strcpy(uriPath, hostEnv->virtual);
            strcat(uriPath, "/");
        } else {
            uriPath = "/";
        }
        
        rootCtx = env->getByName2(env, "uri", uriPath);
        if (rootCtx == NULL) {
            env->createBean2(env, uriMap->mbean->pool, "uri", uriPath);
            rootCtx = env->getByName2(env, "uri", uriPath);
            if (uriMap->mbean->debug > 0) 
                env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                              "uriMap.init() Create default context %s\n", uriPath);
            rootCtx->mbean->setAttribute(env, rootCtx->mbean, "context", "/");
        }
    }
}

static void jk2_uriMap_createWebapps(jk_env_t *env, jk_uriMap_t *uriMap)
{
    int i;

    /* Init all contexts */
    /* For each context, init the local uri maps */
    for (i = 0; i < uriMap->maps->size(env, uriMap->maps); i++) {
        jk_uriEnv_t *uriEnv = uriMap->maps->valueAt(env, uriMap->maps, i);
        char *uri;
        char *context;
        if (uriEnv == NULL) {
            env->l->jkLog(env, env->l, JK_LOG_INFO,
                          "uriMap.init() NPE\n");
        }
        uri = uriEnv->uri;
        context = uriEnv->contextPath;

        if (uri != NULL && context != NULL && strcmp(uri, context) == 0) {
            char *vhost = uriEnv->virtual;
            int  port = uriEnv->port;
            jk_uriEnv_t *hostEnv = jk2_uriMap_hostMap(env, uriMap, vhost, port);
            if (!hostEnv)
                continue;
            if (  uriMap->mbean->debug > 5) 
                env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                              "uriMap.init() loaded context %s %s %#lx %#lx %#lx\n",
                              uriEnv->virtual, context, hostEnv, hostEnv->webapps,
                              uriMap->pool); 
            uriEnv->match_type = MATCH_TYPE_CONTEXT;

            uriEnv->prefix = context;
            uriEnv->prefix_len = strlen(context);
            hostEnv->webapps->put(env, hostEnv->webapps, context, uriEnv, NULL);
            jk2_map_default_create(env, &uriEnv->exactMatch, uriMap->pool);
            jk2_map_default_create(env, &uriEnv->prefixMatch, uriMap->pool);
            jk2_map_default_create(env, &uriEnv->suffixMatch, uriMap->pool);
            jk2_map_default_create(env, &uriEnv->regexpMatch, uriMap->pool);
        }
    }
    
    /* Now, fix the webapps finding context from each uri 
     * and create one if not found.
     */
    for (i = 0; i < uriMap->maps->size(env, uriMap->maps ); i++) {
        jk_uriEnv_t *uriEnv = uriMap->maps->valueAt(env, uriMap->maps, i);        
        char *vhost= uriEnv->virtual;
        int  port = uriEnv->port;
        char *context= uriEnv->contextPath;
        jk_uriEnv_t *hostEnv = jk2_uriMap_hostMap(env, uriMap, vhost, port);
        jk_uriEnv_t *ctxEnv;
       
        env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                      "uriMap: fix uri %s context %s host %s\n",
                       uriEnv->uri==NULL ? "null":uriEnv->uri,
                       uriEnv->contextPath==NULL ? "null":uriEnv->contextPath,
                       hostEnv->virtual);

        if (context == NULL) {
            if (  uriMap->mbean->debug > 5) 
                env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                              "uriMap: no context %s\n", uriEnv->uri );
            continue;
        }
        
        ctxEnv = jk2_uriMap_exactMap(env, uriMap, hostEnv->webapps, context,
                                      strlen(context));
        /* if not alredy created, create it */
        if (ctxEnv == NULL) {
            jk_bean_t *mbean;
            char *ctxname;

            ctxname = uriEnv->pool->calloc(env, uriEnv->pool, strlen(vhost) + 
                                           strlen(context) + 1 );

            strcpy(ctxname, vhost);
            strcat(ctxname, context);

            env->l->jkLog(env, env->l, JK_LOG_INFO,
                          "uriMap: creating context %s\n", ctxname);
            mbean = env->getBean2(env, "uri", ctxname);
            if (mbean == NULL)
                mbean = env->createBean2(env, uriMap->pool,"uri", ctxname);
            if (mbean == NULL || mbean->object == NULL) {
                env->l->jkLog(env, env->l, JK_LOG_ERROR,
                              "uriMap: can't create context object %s\n",ctxname);
                continue;
            }
            ctxEnv = mbean->object;
            ctxEnv->match_type = MATCH_TYPE_CONTEXT;
            ctxEnv->prefix = context;
            ctxEnv->prefix_len = strlen(context);
            ctxEnv->contextPath = context;
            ctxEnv->ctxt_len = strlen(context);
            hostEnv->webapps->put(env, hostEnv->webapps, context, ctxEnv, NULL);
            jk2_map_default_create(env, &ctxEnv->exactMatch, uriMap->pool);
            jk2_map_default_create(env, &ctxEnv->prefixMatch, uriMap->pool);
            jk2_map_default_create(env, &ctxEnv->suffixMatch, uriMap->pool);
            jk2_map_default_create(env, &ctxEnv->regexpMatch, uriMap->pool);
        }
    } 

}

static int jk2_uriMap_createMappings(jk_env_t *env, jk_uriMap_t *uriMap)
{
    int i;

    if (uriMap->mbean->debug > 5) 
        env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                      "uriMap.init() processing mappings\n");
    
    /* XXX We should also sort prefix mappings and maybe use binary search - but
       it won't have too bigger benefits, the number of mappings per ctx is typically 
       small
     */
    for (i = 0; i < uriMap->maps->size(env, uriMap->maps); i++) {
        jk_uriEnv_t *uriEnv = uriMap->maps->valueAt(env, uriMap->maps, i);

        char *vhost = uriEnv->virtual;
        int port = uriEnv->port;
        jk_uriEnv_t *hostEnv = jk2_uriMap_hostMap(env, uriMap, vhost, port);
        
        char *uri = uriEnv->uri;
        jk_uriEnv_t *ctxEnv = NULL;

        if (hostEnv == NULL)
            continue;
        if (uri == NULL )
            continue;
        uriEnv->uriMap = uriMap;
        uriEnv->init(env, uriEnv);

        if (uri == NULL)
            continue;
        
        /* If the context was specified try to find the exact one */
        if (uriEnv->contextPath != NULL)
            ctxEnv = jk2_uriMap_exactMap(env, uriMap, hostEnv->webapps,
                                         uriEnv->contextPath,
                                         uriEnv->ctxt_len);
        else if (uriEnv->match_type == MATCH_TYPE_REGEXP) {
            ctxEnv = hostEnv->webapps->get(env, hostEnv->webapps, "/");
        }
        /* Next find by uri prefix */
        if (ctxEnv == NULL)
            ctxEnv = jk2_uriMap_prefixMap(env, uriMap, hostEnv->webapps, uri,
                                          strlen(uri));

        if (ctxEnv == NULL) {
            env->l->jkLog(env, env->l, JK_LOG_INFO, 
                           "uriMap.init() no context for %s\n", uri); 
            return JK_ERR;
        }

        /* Correct the context path if needed */
        uriEnv->contextPath = ctxEnv->prefix;
        uriEnv->ctxt_len = ctxEnv->prefix_len;

        if (uriMap->mbean->debug > 5) 
            env->l->jkLog(env, env->l, JK_LOG_INFO, 
                          "uriMap.init() adding context %s for %s\n", ctxEnv->prefix, uri); 

        switch (uriEnv->match_type) {
            case MATCH_TYPE_EXACT:
                ctxEnv->exactMatch->add(env, ctxEnv->exactMatch, uri, uriEnv);
                break;
            case MATCH_TYPE_SUFFIX:
                ctxEnv->suffixMatch->add(env, ctxEnv->suffixMatch, uri, uriEnv);
                break;
            case MATCH_TYPE_PREFIX:
                ctxEnv->prefixMatch->add(env, ctxEnv->prefixMatch, uri, uriEnv);
                break;
            case MATCH_TYPE_REGEXP:
                if (uriEnv->regexp)
                    ctxEnv->regexpMatch->add(env, ctxEnv->regexpMatch, uri, uriEnv);
                break;
        }
    }
    return JK_OK;
}

static jk_uriEnv_t* jk2_uriMap_duplicateUri(jk_env_t *env, jk_uriMap_t *uriMap,
                                            jk_uriEnv_t *uriEnv, jk_uriEnv_t *mapEnv)
{
    char *uriname;
    jk_uriEnv_t *newEnv;
    jk_bean_t *mbean;

    uriname = uriEnv->pool->calloc(env, uriEnv->pool, strlen(uriEnv->name) + 
                                   strlen(mapEnv->uri) + 1 );

    strcpy(uriname, uriEnv->name);
    strcat(uriname, mapEnv->uri);

    env->l->jkLog(env, env->l, JK_LOG_INFO,
        "uriMap: creating duplicate of  uri %s\n", uriname);
    mbean = env->getBean2(env, "uri", uriname);
    if (mbean == NULL)
        mbean = env->createBean2(env, uriMap->pool,"uri", uriname);
    if (mbean == NULL || mbean->object == NULL) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
            "uriMap: can't create uri object %s\n", uriname);
        return NULL;
    }
    newEnv = mbean->object;
    newEnv->match_type = mapEnv->match_type;
    newEnv->prefix = mapEnv->prefix;
    newEnv->prefix_len = mapEnv->prefix_len;
    newEnv->contextPath = mapEnv->contextPath;
    newEnv->ctxt_len = mapEnv->ctxt_len;
    newEnv->worker = mapEnv->worker;
    newEnv->workerName = mapEnv->workerName;
    newEnv->workerEnv = mapEnv->workerEnv;
    newEnv->regexp = mapEnv->regexp;

    return newEnv;
}

static jk_uriEnv_t* jk2_uriMap_duplicateContext(jk_env_t *env, jk_uriMap_t *uriMap,
                                            jk_uriEnv_t *uriEnv, jk_uriEnv_t *mapEnv)
{
    char *uriname;
    jk_uriEnv_t *newEnv;
    jk_bean_t *mbean;

    uriname = uriEnv->pool->calloc(env, uriEnv->pool, strlen(uriEnv->name) + 
                                   strlen(mapEnv->contextPath) + 1 );

    strcpy(uriname, uriEnv->name);
    strcat(uriname, mapEnv->contextPath);

    env->l->jkLog(env, env->l, JK_LOG_INFO,
        "uriMap: creating duplicate of context %s\n", uriname);
    mbean = env->getBean2(env, "uri", uriname);
    if (mbean == NULL)
        mbean = env->createBean2(env, uriMap->pool,"uri", uriname);
    if (mbean == NULL || mbean->object == NULL) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
            "uriMap: can't create uri object %s\n", uriname);
        return NULL;
    }
    newEnv = mbean->object;
    newEnv->match_type = mapEnv->match_type;
    newEnv->prefix = mapEnv->prefix;
    newEnv->prefix_len = mapEnv->prefix_len;
    newEnv->contextPath = mapEnv->contextPath;
    newEnv->ctxt_len = mapEnv->ctxt_len;
    newEnv->worker = mapEnv->worker;
    newEnv->workerName = mapEnv->workerName;
    newEnv->workerEnv = mapEnv->workerEnv;

    jk2_map_default_create(env, &newEnv->exactMatch, uriMap->pool);
    jk2_map_default_create(env, &newEnv->prefixMatch, uriMap->pool);
    jk2_map_default_create(env, &newEnv->suffixMatch, uriMap->pool);
    jk2_map_default_create(env, &newEnv->regexpMatch, uriMap->pool);

    return newEnv;
}

static int jk2_uriMap_createGlobals(jk_env_t *env, jk_uriMap_t *uriMap)
{
    int i, n;
    jk_uriEnv_t *globalEnv;

    if (uriMap->mbean->debug > 5) 
        env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                      "uriMap.init() creating global mappings\n");
    globalEnv = uriMap->vhosts->get(env, uriMap->vhosts, "*");

    n = uriMap->vhosts->size(env, uriMap->vhosts);
    for (i = 0 ; i < n ; i++) {
        jk_uriEnv_t *uriEnv = uriMap->vhosts->valueAt(env, uriMap->vhosts, i);
        /* Duplicate globals for each vhost that has inheritGlobals set */
        if (uriEnv != globalEnv && uriEnv->inherit_globals) {
            int j, m;
            env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                         "uriMap.init() global for %s\n",
                          uriEnv->name);
            m = globalEnv->webapps->size(env, globalEnv->webapps);
            for (j = 0; j < m; j++) {
                jk_uriEnv_t *ctxEnv;
                jk_uriEnv_t *appEnv;
                int k, l;

                ctxEnv = globalEnv->webapps->valueAt(env, globalEnv->webapps, j);
                appEnv = uriEnv->webapps->get(env, uriEnv->webapps, ctxEnv->contextPath);

                /* Create the webapp if it doesn't exists on the selected vhost */
                if (!appEnv) {

                    appEnv = jk2_uriMap_duplicateContext(env, uriMap, uriEnv, ctxEnv);
                    uriEnv->webapps->put(env, uriEnv->webapps, appEnv->contextPath, appEnv, NULL);
                    env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                                  "uriMap.init() creating global webapp %s for %s\n",
                                  appEnv->contextPath, uriEnv->name);
                }
                /* Fix the exact matches */
                l = ctxEnv->exactMatch->size(env, ctxEnv->exactMatch);
                for (k = 0; k < l; k++) {
                    jk_uriEnv_t *mapEnv;
                    jk_uriEnv_t *newEnv;