jk_service_apache2.c

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

        /*     "service.write()  %ld (%ld) out of %ld \n",toSend, r, ll ); */
        ll-=CHUNK_SIZE;
        bb+=CHUNK_SIZE;
        
        if(toSend != r) { 
            return JK_ERR; 
        } 
        
    }
    
    /*
     * To allow server push. After writing full buffers
     */
    if(ap_rflush(rr) != APR_SUCCESS) {
        ap_log_error(APLOG_MARK, APLOG_STARTUP | APLOG_NOERRNO, 0, 
                     NULL, "mod_jk: Error flushing \n"  );
        return JK_ERR;
    }
    
    return JK_OK;
}

/* ========================================================================= */
/* Utility functions                                                         */
/* ========================================================================= */

static long jk2_get_content_length(jk_env_t *env, request_rec *r)
{
    if(r->clength > 0) {
        return (long)(r->clength);
    } else {
        char *lenp = (char *)apr_table_get(r->headers_in, "Content-Length");

        if(lenp) {
            long rc = atol(lenp);
            if(rc > 0) {
                return rc;
            }
        }
    }

    return 0;
}

static int JK_METHOD jk2_init_ws_service(jk_env_t *env, jk_ws_service_t *s,
                                         jk_worker_t *worker, void *serverObj)
{
    apr_port_t port;
    char *ssl_temp      = NULL;
    jk_workerEnv_t *workerEnv;
    request_rec *r=serverObj;
    int need_content_length_header=JK_FALSE;

    workerEnv = worker->workerEnv;
    /* Common initialization */
    /* XXX Probably not needed, we're duplicating */
    jk2_requtil_initRequest(env, s);


    s->ws_private = r;
    s->response_started = JK_FALSE;
    s->read_body_started = JK_FALSE;
    s->workerEnv=workerEnv;

    s->jvm_route        = NULL;    /* Used for sticky session routing */

    s->auth_type    = NULL_FOR_EMPTY(r->ap_auth_type);
    s->remote_user  = NULL_FOR_EMPTY(r->user);

    s->protocol     = r->protocol;
    s->remote_host  = (char *)ap_get_remote_host(r->connection, 
                                                 r->per_dir_config, 
                                                 REMOTE_HOST, NULL);
    s->remote_host  = NULL_FOR_EMPTY(s->remote_host);
    s->remote_addr  = NULL_FOR_EMPTY(r->connection->remote_ip);

    /* get server name */
    s->server_name= (char *)(r->hostname ? r->hostname :
                             r->server->server_hostname);

    /* get the real port (otherwise redirect failed) */
    apr_sockaddr_port_get(&port,r->connection->local_addr);
    s->server_port = port;

    s->server_software = (char *)ap_get_server_version();

    s->method         = (char *)r->method;
    s->content_length = jk2_get_content_length(env, r);
    s->is_chunked     = r->read_chunked;
    s->no_more_chunks = 0;
    s->query_string   = r->args;

    s->startTime = r->request_time;
    /*
     * The 2.2 servlet spec errata says the uri from
     * HttpServletRequest.getRequestURI() should remain encoded.
     * [http://java.sun.com/products/servlet/errata_042700.html]
     *
     * We use JkOptions to determine which method to be used
     *
     * ap_escape_uri is the latest recommanded but require
     *               some java decoding (in TC 3.3 rc2)
     *
     * unparsed_uri is used for strict compliance with spec and
     *              old Tomcat (3.2.3 for example)
     *
     * uri is use for compatibilty with mod_rewrite with old Tomcats
     */

    switch (workerEnv->options & JK_OPT_FWDURIMASK) {

        case JK_OPT_FWDURICOMPATUNPARSED :
            s->req_uri      = r->unparsed_uri;
            if (s->req_uri != NULL) {
                char *query_str = strchr(s->req_uri, '?');
                if (query_str != NULL) {
                    *query_str = 0;
                }
            }

        break;

        case JK_OPT_FWDURICOMPAT :
            s->req_uri = r->uri;
        break;

        case JK_OPT_FWDURIESCAPED :
            s->req_uri      = ap_escape_uri(r->pool, r->uri);
        break;

        default :
            return JK_ERR;
    }

    s->is_ssl       = JK_FALSE;
    s->ssl_cert     = NULL;
    s->ssl_cert_len = 0;
    s->ssl_cipher   = NULL;        /* required by Servlet 2.3 Api, 
                                   allready in original ajp13 */
    s->ssl_session  = NULL;
    s->ssl_key_size = -1;        /* required by Servlet 2.3 Api, added in jtc */

    if(workerEnv->ssl_enable || workerEnv->envvars_in_use) {
        ap_add_common_vars(r);

        if(workerEnv->ssl_enable) {
            ssl_temp = 
                (char *)apr_table_get(r->subprocess_env, 
                                      workerEnv->https_indicator);
            if(ssl_temp && !strcasecmp(ssl_temp, "on")) {
                s->is_ssl       = JK_TRUE;
                s->ssl_cert     = 
                    (char *)apr_table_get(r->subprocess_env, 
                                          workerEnv->certs_indicator);
                if(s->ssl_cert) {
                    s->ssl_cert_len = strlen(s->ssl_cert);
                }
                /* Servlet 2.3 API */
                s->ssl_cipher   = 
                    (char *)apr_table_get(r->subprocess_env, 
                                          workerEnv->cipher_indicator);
                 s->ssl_session  = 
                    (char *)apr_table_get(r->subprocess_env, 
                                          workerEnv->session_indicator);

                if (workerEnv->options & JK_OPT_FWDKEYSIZE) {
                    /* Servlet 2.3 API */
                    ssl_temp = (char *)apr_table_get(r->subprocess_env, 
                                                 workerEnv->key_size_indicator);
                    if (ssl_temp)
                        s->ssl_key_size = atoi(ssl_temp);
                }
            }
        }

#ifdef USE_APRTABLES
        /* We can't do that - the filtering should happen in
           common to enable that.
           
          jk2_map_aprtable_factory( workerEnv->env, s->pool,
          &s->attributes,
          "map", "aprtable" );
          s->attributes->init( NULL, s->attributes, 0, XXX);
        */
        jk2_map_default_create(env, &s->attributes, s->pool );
#else
        jk2_map_default_create(env, &s->attributes, s->pool );
#endif
        
        if(workerEnv->envvars_in_use) {
            int envCnt=workerEnv->envvars->size( env, workerEnv->envvars );
            int i;

            for( i=0; i< envCnt ; i++ ) {
                char *name= workerEnv->envvars->nameAt( env, workerEnv->envvars, i );
                char *val= (char *)apr_table_get(r->subprocess_env, name);
                if(val==NULL) {
                    val=workerEnv->envvars->valueAt( env, workerEnv->envvars, i );
                }
                s->attributes->put( env, s->attributes, name, val, NULL );
            }
        }
    }

#ifdef USE_APRTABLES
    jk2_map_aprtable_factory( env, s->pool,
                             (void *)&s->headers_in,
                             "map", "aprtable" );
    s->headers_in->init( env, s->headers_in, 0, r->headers_in);
#else
    jk2_map_default_create(env, &s->headers_in, s->pool );

    if(r->headers_in && apr_table_elts(r->headers_in)) {
        const apr_array_header_t *t = apr_table_elts(r->headers_in);
        if(t && t->nelts) {
            int i;

            apr_table_entry_t *elts = (apr_table_entry_t *)t->elts;

            for(i = 0 ; i < t->nelts ; i++) {
                s->headers_in->add( env, s->headers_in,
                                    elts[i].key, elts[i].val);
            }
        }
    }
#endif

    if(!s->is_chunked && s->content_length == 0) {
        /* XXX if r->contentLength == 0 I assume there's no header
           or a header with '0'. In the second case, put will override it 
         */
        s->headers_in->put( env, s->headers_in, "content-length", "0", NULL );
    }

#ifdef USE_APRTABLES
    jk2_map_aprtable_factory( env, s->pool, (void *)&s->headers_out,
                             "map", "aprtable" );
    s->headers_in->init( env, s->headers_out, 0, r->headers_out);
#else
    jk2_map_default_create(env, &s->headers_out, s->pool );
#endif

    return JK_OK;
}

/*
 * If the servlet engine didn't consume all of the
 * request data, consume and discard all further
 * characters left to read from client
 *
 *  XXX Is it the right thing to do ????? Why spend the
 *  bandwith, the servlet decided not to read the POST then
 *  jk shouldn't do it instead, and the user should get the
 *  error message !
 */
static void JK_METHOD jk2_service_apache2_afterRequest(jk_env_t *env, jk_ws_service_t *s )
{
    
    if (s->content_read < s->content_length ||
        (s->is_chunked && ! s->no_more_chunks)) {
        
        request_rec *r=s->ws_private;

        char *buff = apr_palloc(r->pool, 2048);
        if (buff != NULL) {
            int rd;
            while ((rd = ap_get_client_block(r, buff, 2048)) > 0) {
                s->content_read += rd;
            }
        }
    }
    if (s->realWorker) {
        struct jk_worker *w = s->realWorker;
        if (w != NULL && w->channel != NULL 
            && w->channel->afterRequest != NULL) {
            w->channel->afterRequest( env, w->channel, w, NULL, s );
        }
    }
}

int JK_METHOD jk2_service_apache2_init(jk_env_t *env, jk_ws_service_t *s)
{
    if(s==NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
                      "service.init() NullPointerException\n");
        return JK_ERR;
    }

    s->head   = jk2_service_apache2_head;
    s->read   = jk2_service_apache2_read;
    s->write  = jk2_service_apache2_write;
    s->init   = jk2_init_ws_service;
    s->afterRequest     = jk2_service_apache2_afterRequest;

    return JK_OK;
}