jk_isapi_plugin.c

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

            /*
             * Just in case somebody set these headers in the request!
             */
            SetHeader(pfc, URI_HEADER_NAME, NULL);
            SetHeader(pfc, QUERY_HEADER_NAME, NULL);
            SetHeader(pfc, WORKER_HEADER_NAME, NULL);
            SetHeader(pfc, TOMCAT_TRANSLATE_HEADER_NAME, NULL);
        
            if (!GetHeader(pfc, "url", (LPVOID)uri, (LPDWORD)&sz)) {
                env->l->jkLog(env, env->l,  JK_LOG_ERROR, 
                       "HttpFilterProc error while getting the url\n");
                workerEnv->globalEnv->releaseEnv( workerEnv->globalEnv, env );
                return SF_STATUS_REQ_ERROR;
            }

            if (strlen(uri)) {
                int rc;
                char *worker=0;
                query = strchr(uri, '?');
                if (query) {
                    *query++ = '\0';
                }

                rc = jk_requtil_unescapeUrl(uri);
                if (rc == BAD_REQUEST) {
                    env->l->jkLog(env, env->l,  JK_LOG_ERROR, 
                           "HttpFilterProc [%s] contains one or more invalid escape sequences.\n", 
                           uri);
                    write_error_response(pfc,"400 Bad Request", HTML_ERROR_400);
                    workerEnv->globalEnv->releaseEnv( workerEnv->globalEnv, env );
                    return SF_STATUS_REQ_FINISHED;
                }
                else if(rc == BAD_PATH) {
                    env->l->jkLog(env, env->l,  JK_LOG_EMERG, 
                           "HttpFilterProc [%s] contains forbidden escape sequences.\n", 
                           uri);
                    write_error_response(pfc,"403 Forbidden", HTML_ERROR_403);
                    workerEnv->globalEnv->releaseEnv( workerEnv->globalEnv, env );
                    return SF_STATUS_REQ_FINISHED;
                }
                jk_requtil_getParents(uri);

                if (pfc->GetServerVariable(pfc, SERVER_NAME, (LPVOID)Host, (LPDWORD)&szHost)){
                    if (szHost > 0) {
                        Host[szHost-1] = '\0';
                    }
                }
                Port[0] = '\0';
                if (pfc->GetServerVariable(pfc, "SERVER_PORT", (LPVOID)Port, (LPDWORD)&szPort)){
                    if (szPort > 0) {
                        Port[szPort-1] = '\0';
                    }
                }
                nPort = atoi(Port);
                env->l->jkLog(env, env->l,  JK_LOG_DEBUG, 
                            "In HttpFilterProc Virtual Host redirection of %s : %s\n", 
                            Host, Port);
                uriEnv = workerEnv->uriMap->mapUri(env, workerEnv->uriMap,Host, nPort, uri );

                if( uriEnv!=NULL ) {
                    char *forwardURI;

                    /* This is a servlet, should redirect ... */
                    env->l->jkLog(env, env->l,  JK_LOG_DEBUG, 
                           "HttpFilterProc [%s] is a servlet url - should redirect to %s\n", 
                           uri, uriEnv->workerName);
                
                    /* get URI we should forward */
                
                    if( workerEnv->options == JK_OPT_FWDURICOMPATUNPARSED ){
                        /* get original unparsed URI */
                        GetHeader(pfc, "url", (LPVOID)uri, (LPDWORD)&sz);
                        /* restore terminator for uri portion */
                        if (query)
                            *(query - 1) = '\0';
                        env->l->jkLog(env, env->l,  JK_LOG_DEBUG, 
                               "HttpFilterProc fowarding original URI [%s]\n",uri);
                        forwardURI = uri;
                    } else if( workerEnv->options == JK_OPT_FWDURIESCAPED ){
                        if (!jk_requtil_escapeUrl(uri,snuri,INTERNET_MAX_URL_LENGTH)) {
                            env->l->jkLog(env, env->l,  JK_LOG_ERROR, 
                                   "HttpFilterProc [%s] re-encoding request exceeds maximum buffer size.\n", 
                                   uri);
                            write_error_response(pfc,"400 Bad Request", HTML_ERROR_400);
                            workerEnv->globalEnv->releaseEnv( workerEnv->globalEnv, env );
                            return SF_STATUS_REQ_FINISHED;
                        }
                        env->l->jkLog(env, env->l,  JK_LOG_DEBUG, 
                               "HttpFilterProc fowarding escaped URI [%s]\n",snuri);
                        forwardURI = snuri;
                    } else {
                        forwardURI = uri;
                    }

                    if(!AddHeader(pfc, URI_HEADER_NAME, forwardURI) || 
                       ( (query != NULL && strlen(query) > 0)
                               ? !AddHeader(pfc, QUERY_HEADER_NAME, query) : FALSE ) || 
                       !AddHeader(pfc, WORKER_HEADER_NAME, uriEnv->workerName) ||
                       !SetHeader(pfc, "url", extension_uri)) {
                        env->l->jkLog(env, env->l,  JK_LOG_ERROR, 
                               "HttpFilterProc error while adding request headers\n");
                        workerEnv->globalEnv->releaseEnv( workerEnv->globalEnv, env );
                        return SF_STATUS_REQ_ERROR;
                    }
                    
                    /* Move Translate: header to a temporary header so
                     * that the extension proc will be called.
                     * This allows the servlet to handle 'Translate: f'.
                     */
                    if(GetHeader(pfc, "Translate:", (LPVOID)Translate, (LPDWORD)&szTranslate) &&
                        Translate != NULL && szTranslate > 0) {
                        if (!AddHeader(pfc, TOMCAT_TRANSLATE_HEADER_NAME, Translate)) {
                            env->l->jkLog(env, env->l,  JK_LOG_ERROR, 
                              "HttpFilterProc error while adding Tomcat-Translate headers\n");
                            workerEnv->globalEnv->releaseEnv( workerEnv->globalEnv, env );
                            return SF_STATUS_REQ_ERROR;
                        }
                    SetHeader(pfc, "Translate:", NULL);
                    }
                } else {
                    env->l->jkLog(env, env->l,  JK_LOG_DEBUG, 
                           "HttpFilterProc [%s] is not a servlet url\n", 
                           uri);
                }

                /*
                 * Check if somebody is feeding us with his own TOMCAT data headers.
                 * We reject such postings !
                 */
                env->l->jkLog(env, env->l,  JK_LOG_DEBUG, 
                       "HttpFilterProc check if [%s] is pointing to the web-inf directory\n", 
                       uri);

                if(jk_requtil_uriIsWebInf(uri)) {
                    env->l->jkLog(env, env->l,  JK_LOG_EMERG, 
                           "HttpFilterProc [%s] points to the web-inf or meta-inf directory.\nSomebody try to hack into the site!!!\n", 
                           uri);

                    write_error_response(pfc,"403 Forbidden", HTML_ERROR_403);
                    workerEnv->globalEnv->releaseEnv( workerEnv->globalEnv, env );
                    return SF_STATUS_REQ_FINISHED;
                }
            }
        }
        workerEnv->globalEnv->releaseEnv( workerEnv->globalEnv, env );
    }
    return SF_STATUS_REQ_NEXT_NOTIFICATION;
}


BOOL WINAPI GetExtensionVersion(HSE_VERSION_INFO  *pVer)
{
    pVer->dwExtensionVersion = MAKELONG( HSE_VERSION_MINOR,
                                         HSE_VERSION_MAJOR );

    strcpy(pVer->lpszExtensionDesc, VERSION_STRING);

    return TRUE;
}

DWORD WINAPI HttpExtensionProcWorker(LPEXTENSION_CONTROL_BLOCK  lpEcb, 
                                     jk_ws_service_t *service)
{   
    DWORD rc = HSE_STATUS_ERROR;
    jk_env_t *env;
    jk_ws_service_t sOnStack;
    jk_ws_service_t *s;
    char *worker_name;
    char huge_buf[16 * 1024]; /* should be enough for all */
    DWORD huge_buf_sz;        
    jk_worker_t *worker;
    jk_pool_t *rPool=NULL;
    int rc1;

    if (service)
        s = service;
    else
        s = &sOnStack;

    lpEcb->dwHttpStatusCode = HTTP_STATUS_SERVER_ERROR;
    env = workerEnv->globalEnv->getEnv( workerEnv->globalEnv );
    env->l->jkLog(env, env->l,  JK_LOG_DEBUG, 
                  "HttpExtensionProc started\n");

    huge_buf_sz = sizeof(huge_buf);
    get_server_value(lpEcb, HTTP_WORKER_HEADER_NAME, huge_buf, huge_buf_sz, "");
    worker_name = huge_buf;

    worker=env->getByName( env, worker_name);

    env->l->jkLog(env, env->l,  JK_LOG_DEBUG, 
        "HttpExtensionProc %s a worker for name %s\n", 
        worker ? "got" : "could not get",
        worker_name);

    if( worker==NULL ){
        env->l->jkLog(env, env->l,  JK_LOG_ERROR, 
            "HttpExtensionProc worker is NULL\n");
        return rc;            
    }
    /* Get a pool for the request XXX move it in workerEnv to
    be shared with other server adapters */
    rPool= worker->rPoolCache->get( env, worker->rPoolCache );
    if( rPool == NULL ) {
        rPool=worker->mbean->pool->create( env, worker->mbean->pool, HUGE_POOL_SIZE );
        env->l->jkLog(env, env->l, JK_LOG_DEBUG,
            "HttpExtensionProc: new rpool\n");
    }

    jk2_service_iis_init( env, s );
    s->pool = rPool;
    s->is_recoverable_error = JK_FALSE;
    s->response_started = JK_FALSE;
    s->content_read = 0;
    s->ws_private = lpEcb;
    s->workerEnv = workerEnv;

    /* Initialize the ws_service structure */
    s->init( env, s, worker, lpEcb );

    if (JK_OK == worker->service(env, worker, s)){
        rc=HSE_STATUS_SUCCESS;
        lpEcb->dwHttpStatusCode = HTTP_STATUS_OK;
        env->l->jkLog(env, env->l,  JK_LOG_DEBUG, 
            "HttpExtensionProc service() returned OK\n");
    } else {
        env->l->jkLog(env, env->l,  JK_LOG_DEBUG, 
            "HttpExtensionProc service() Failed\n");
    }

    s->afterRequest(env, s);

    if (service != NULL) {
        lpEcb->ServerSupportFunction(lpEcb->ConnID, 
                                     HSE_REQ_DONE_WITH_SESSION, 
                                     NULL, 
                                     NULL, 
                                     NULL);
    }
    rPool->reset(env, rPool);
    rc1=worker->rPoolCache->put( env, worker->rPoolCache, rPool );

    workerEnv->globalEnv->releaseEnv( workerEnv->globalEnv, env );

    return rc;
}

DWORD WINAPI HttpExtensionProc(LPEXTENSION_CONTROL_BLOCK  lpEcb)
{
    if (is_inited) {
        if (!use_thread_pool) {
            return HttpExtensionProcWorker(lpEcb, NULL);
        }
        else {
            /* Pass the request to the thread pool */
            jk2_iis_thread_pool(lpEcb);
            return HSE_STATUS_PENDING;
        }
    }
    return HSE_STATUS_ERROR;
}

BOOL WINAPI TerminateExtension(DWORD dwFlags) 
{
    return TerminateFilter(dwFlags);
}

BOOL WINAPI TerminateFilter(DWORD dwFlags) 
{
    /* detatch the starter thread */
    SetEvent(jk2_starter_event);
    WaitForSingleObject(jk2_starter_thread, 3000);
    CloseHandle(jk2_starter_thread);
    jk2_starter_thread = INVALID_HANDLE_VALUE;
    return TRUE;
}



BOOL WINAPI DllMain(HINSTANCE hInst,        // Instance Handle of the DLL
                    ULONG ulReason,         // Reason why NT called this DLL
                    LPVOID lpReserved)      // Reserved parameter for future use
{
    BOOL fReturn = TRUE; 
    char drive[_MAX_DRIVE];
    char dir[_MAX_DIR];
    char fname[_MAX_FNAME];

    switch (ulReason) {
        case DLL_PROCESS_ATTACH:
            if (GetModuleFileName( hInst, file_name, sizeof(file_name))) {