jk_requtil.c

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

        if('=' == id_start[strlen(name)]) {
            /*
             * Session path-cookie was found, get it's value
             */
            id_start += (1 + strlen(name));
            if(strlen(id_start)) {
                char *id_end;
                id_start = s->pool->pstrdup(env, s->pool, id_start);
                /* 
                 * The query string is not part of req_uri, however
                 * to be on the safe side lets remove the trailing query 
                 * string if appended...
                 */
                if(id_end = strchr(id_start, '?')) { 
                    *id_end = '\0';
                }
                return id_start;
            }
        }
    }
  
    return NULL;
}

/** Retrieve session id from the cookie or the parameter                      
 * (parameter first)
 */
char *jk2_requtil_getSessionId(jk_env_t *env, jk_ws_service_t *s)
{
    char *val;
    val = jk2_requtil_getPathParam(env, s, JK_PATH_SESSION_IDENTIFIER);
    if(!val) {
        val = jk2_requtil_getCookieByName(env, s, JK_SESSION_IDENTIFIER);
    }
    return val;
}

/** Extract the 'route' from the session id. The route is
 *  the id of the worker that generated the session and where all
 *  further requests in that session will be sent.
*/
char *jk2_requtil_getSessionRoute(jk_env_t *env, jk_ws_service_t *s)
{
    char *sessionid = jk2_requtil_getSessionId(env, s);
    char *ch;

    if(!sessionid) {
        return NULL;
    }

    /*
     * Balance parameter is appended to the end
     */  
    ch = strrchr(sessionid, '.');
    if(!ch) {
        return 0;
    }
    ch++;
    if(*ch == '\0') {
        return NULL;
    }
    return ch;
}

/*
 * Read data from the web server.
 *
 * Socket API didn't garanty all the data will be kept in a single 
 * read, so we must loop up to all awaited data are received 
 */
int jk2_requtil_readFully(jk_env_t *env, jk_ws_service_t *s,
                         unsigned char *buf,
                         unsigned  len)
{
    unsigned rdlen = 0;
    unsigned padded_len = len;

    if (s->is_chunked && s->no_more_chunks) {
	return 0;
    }
    if (s->is_chunked) {
        /* Corner case: buf must be large enough to hold next
         * chunk size (if we're on or near a chunk border).
         * Pad the length to a reasonable value, otherwise the
         * read fails and the remaining chunks are tossed.
         */
        padded_len = (len < CHUNK_BUFFER_PAD) ?
            len : len - CHUNK_BUFFER_PAD;
    }

    while(rdlen < padded_len) {
        unsigned this_time = 0;
        if(s->read(env, s, buf + rdlen, len - rdlen, &this_time)) {
            return -1;
        }

        if(0 == this_time) {
	    if (s->is_chunked) {
		s->no_more_chunks = 1; /* read no more */
	    }
            break;
        }
        rdlen += this_time;
    }

    return (int)rdlen;
}


/* -------------------- Printf writing -------------------- */

#define JK_BUF_SIZE 4096

static int jk2_requtil_createBuffer(jk_env_t *env, 
                             jk_ws_service_t *s)
{
    int bsize=JK_BUF_SIZE;
    
    s->outSize=bsize;
    s->outBuf=(char *)s->pool->alloc( env, s->pool, bsize );

    return JK_OK;
}

static void jk2_requtil_printf(jk_env_t *env, jk_ws_service_t *s, char *fmt, ...)
{
    va_list vargs;
    int ret=0;

    if( s->outBuf==NULL ) {
        jk2_requtil_createBuffer( env, s );
    }
    
    va_start(vargs,fmt);
    s->outPos=0; /* Temp - we don't buffer */
    ret=vsnprintf(s->outBuf + s->outPos, s->outSize - s->outPos, fmt, vargs);
    va_end(vargs);

    s->write( env, s, s->outBuf, strlen(s->outBuf) );
}

/* -------------------- Request serialization -------------------- */
/* XXX optimization - this can be overriden by server to avoid
   multiple copies
*/
/**
  Message structure
 
 
AJPV13_REQUEST/AJPV14_REQUEST=
    request_prefix (1) (byte)
    method         (byte)
    protocol       (string)
    req_uri        (string)
    remote_addr    (string)
    remote_host    (string)
    server_name    (string)
    server_port    (short)
    is_ssl         (boolean)
    num_headers    (short)
    num_headers*(req_header_name header_value)

    ?context       (byte)(string)
    ?servlet_path  (byte)(string)
    ?remote_user   (byte)(string)
    ?auth_type     (byte)(string)
    ?query_string  (byte)(string)
    ?jvm_route     (byte)(string)
    ?ssl_cert      (byte)(string)
    ?ssl_cipher    (byte)(string)
    ?ssl_session   (byte)(string)
    ?ssl_key_size  (byte)(int)		via JkOptions +ForwardKeySize
    request_terminator (byte)
    ?body          content_length*(var binary)

    Was: ajp_marshal_into_msgb
 */
int jk2_serialize_request13(jk_env_t *env, jk_msg_t *msg,
                            jk_ws_service_t *s,
                            jk_endpoint_t *ae)
{
    unsigned char method;
    int i;
    int headerCount;
    int rc;
    int debug=0;

    if( s->uriEnv != NULL ) {
        debug=s->uriEnv->mbean->debug;
    }
    
    rc=jk2_requtil_getMethodId(env, s->method, &method);
    if (rc!=JK_OK) { 
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "Error ajp_marshal_into_msgb - No such method %s\n",
                      s->method);
        return JK_ERR;
    }

    headerCount=s->headers_in->size(env, s->headers_in);
    
    if (msg->appendByte(env, msg, JK_AJP13_FORWARD_REQUEST)  ||
        msg->appendByte(env, msg, method)               ||
        msg->appendString(env, msg, s->protocol)        ||
        msg->appendString(env, msg, s->req_uri)         ||
        msg->appendString(env, msg, s->remote_addr)     ||
        msg->appendString(env, msg, s->remote_host)     ||
        msg->appendString(env, msg, s->server_name)     ||
        msg->appendInt(env, msg, (unsigned short)s->server_port) ||
        msg->appendByte(env, msg, (unsigned char)(s->is_ssl)) ||
        msg->appendInt(env, msg, (unsigned short)(headerCount))) {

        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "handle.request()  Error serializing the message head\n");
        return JK_ERR;
    }

    for (i = 0 ; i < headerCount ; i++) {
        unsigned short sc;

        char *name=s->headers_in->nameAt(env, s->headers_in, i);

        if (jk2_requtil_getHeaderId(env, name, &sc) == JK_OK) {
            /*  env->l->jkLog(env, env->l, JK_LOG_INFO, */
            /*                "serialize.request() Add headerId %s %d\n", name, sc); */
            if (msg->appendInt(env, msg, sc)) {
                env->l->jkLog(env, env->l, JK_LOG_ERROR,
                              "serialize.request() Error serializing header id\n");
                return JK_ERR;
            }
        } else {
            if( debug > 0 )
                env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                              "serialize.request() Add headerName %s\n", name);
            if (msg->appendString(env, msg, name)) {
                env->l->jkLog(env, env->l, JK_LOG_ERROR,
                              "serialize.request() Error serializing header name\n");
                return JK_ERR;
            }
        }
        
        if (msg->appendString(env, msg,
                               s->headers_in->valueAt( env, s->headers_in, i))) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "serialize.request() Error serializing header value\n");
            return JK_ERR;
        }
    }

    if (s->remote_user) {
        if (msg->appendByte(env, msg, SC_A_REMOTE_USER) ||
            msg->appendString(env, msg, s->remote_user)) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "serialize.request() Error serializing user name\n");
            return JK_ERR;
        }
    }
    if (s->auth_type) {
        if (msg->appendByte(env, msg, SC_A_AUTH_TYPE) ||
            msg->appendString(env, msg, s->auth_type)) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "handle.request() Error serializing auth type\n");
            return JK_ERR;
        }
    }
    if (s->query_string) {
        if (msg->appendByte(env, msg, SC_A_QUERY_STRING) ||
#ifdef AS400
            msg->appendAsciiString(env, msg, s->query_string)) {
#else
            msg->appendString(env, msg, s->query_string)) {
#endif
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "handle.request() Error serializing query string\n");
            return JK_ERR;
        }
    }
    /* XXX This can be sent only on startup ( ajp14 ) */
     
    if (s->jvm_route) {
        if ( msg->appendByte(env, msg, SC_A_JVM_ROUTE) ||
             msg->appendString(env, msg, s->jvm_route)) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "handle.request() Error serializing worker id\n");
            return JK_ERR;
        }
    }
    
    if (s->ssl_cert_len) {
        if ( msg->appendByte(env, msg, SC_A_SSL_CERT) ||
             msg->appendString(env, msg, s->ssl_cert)) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "handle.request() Error serializing SSL cert\n");
            return JK_ERR;
        }
    }

    if (s->ssl_cipher) {
        if ( msg->appendByte(env, msg, SC_A_SSL_CIPHER) ||
             msg->appendString(env, msg, s->ssl_cipher)) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "handle.request() Error serializing SSL cipher\n");
            return JK_ERR;
        }
    }
    if (s->ssl_session) {
        if ( msg->appendByte(env, msg, SC_A_SSL_SESSION) ||
             msg->appendString(env, msg, s->ssl_session)) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "handle.request() Error serializing SSL session\n");
            return JK_ERR;
        }
    }

    /*
     * ssl_key_size is required by Servlet 2.3 API
     * added support only in ajp14 mode
     * JFC removed: ae->proto == AJP14_PROTO
     */
    if (s->ssl_key_size != -1) {
        if ( msg->appendByte(env, msg, SC_A_SSL_KEY_SIZE) ||
             msg->appendInt(env, msg, (unsigned short) s->ssl_key_size)) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "handle.request() Error serializing SSL key size\n");
            return JK_ERR;
        }
    }

    if (ae->worker->secret ) {
        if ( msg->appendByte(env, msg, SC_A_SECRET) ||
             msg->appendString(env, msg, ae->worker->secret )) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "handle.request() Error serializing secret\n");
            return JK_ERR;
        }
    }


    if (s->attributes->size( env,  s->attributes) > 0) {
        for (i = 0 ; i < s->attributes->size( env,  s->attributes) ; i++) {
            char *name=s->attributes->nameAt( env,  s->attributes, i);
            char *val=s->attributes->valueAt( env, s->attributes, i);
            if ( msg->appendByte(env, msg, SC_A_REQ_ATTRIBUTE) ||
                 msg->appendString(env, msg, name ) ||
                 msg->appendString(env, msg, val)) {
                env->l->jkLog(env, env->l, JK_LOG_ERROR,
                         "handle.request() Error serializing attribute %s=%s\n",
                         name, val);
                return JK_ERR;
            }
        }
    }

    if ( msg->appendByte(env, msg, SC_A_ARE_DONE)) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                 "handle.request() Error serializing end marker\n");
        return JK_ERR;
    }

    
    if( debug > 0  )