/*
 *  Copyright 1999-2004 The Apache Software Foundation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

/**
 * Utils for processing various request components
 *
 * Author:      Gal Shachor <shachor@il.ibm.com>                           
 * Author:      Henri Gomez <hgomez@apache.org>                               
 * Author:      Costin Manolache
 */

/* XXX make them virtual methods, allow servers to override
 */

#include "jk_global.h"
#include "jk_channel.h"
#include "jk_env.h"
#include "jk_requtil.h"

#ifdef AS400
#include "util_ebcdic.h"
#endif

#define CHUNK_BUFFER_PAD          (12)

static const char *response_trans_headers[] = {
    "Content-Type",
    "Content-Language",
    "Content-Length",
    "Date",
    "Last-Modified",
    "Location",
    "Set-Cookie",
    "Set-Cookie2",
    "Servlet-Engine",
    "Status",
    "WWW-Authenticate"
};

/*
 * Conditional request attributes
 * 
 */
#define SC_A_CONTEXT            (unsigned char)1
#define SC_A_SERVLET_PATH       (unsigned char)2
#define SC_A_REMOTE_USER        (unsigned char)3
#define SC_A_AUTH_TYPE          (unsigned char)4
#define SC_A_QUERY_STRING       (unsigned char)5
#define SC_A_JVM_ROUTE          (unsigned char)6
#define SC_A_SSL_CERT           (unsigned char)7
#define SC_A_SSL_CIPHER         (unsigned char)8
#define SC_A_SSL_SESSION        (unsigned char)9
#define SC_A_REQ_ATTRIBUTE      (unsigned char)10
/* only in if JkOptions +ForwardKeySize */
#define SC_A_SSL_KEY_SIZE       (unsigned char)11
#define SC_A_SECRET             (unsigned char)12
#define SC_A_STORED_METHOD      (unsigned char)13
#define SC_A_ARE_DONE           (unsigned char)0xFF

/*
 * Forward a request from the web server to the servlet container.
 */
#define JK_AJP13_FORWARD_REQUEST    (unsigned char)2

/* Important: ajp13 protocol has the strange habit of sending
   a second ( untyped ) message imediately following the request,
   with a first chunk of POST body. This is nice for small post
   requests, since it avoids a roundtrip, but it's horrible
   because it brakes the model. So we'll have to remember this
   as an exception to the rule as long as ajp13 is alive
*/


/** Get header value using a lookup table. 
 *
 *
 * long_res_header_for_sc
 */
const char *jk2_requtil_getHeaderById(jk_env_t *env, int sc)
{
    const char *rc = NULL;
    if (sc <= SC_RES_HEADERS_NUM && sc > 0) {
        rc = response_trans_headers[sc - 1];
    }

    return rc;
}

/**
 * Get method id. 
 *
 * sc_for_req_method
 */
int jk2_requtil_getMethodId(jk_env_t *env, const char *method,
                            unsigned char *sc)
{
    int rc = JK_OK;
    if (0 == strcmp(method, "GET")) {
        *sc = SC_M_GET;
    }
    else if (0 == strcmp(method, "POST")) {
        *sc = SC_M_POST;
    }
    else if (0 == strcmp(method, "HEAD")) {
        *sc = SC_M_HEAD;
    }
    else if (0 == strcmp(method, "PUT")) {
        *sc = SC_M_PUT;
    }
    else if (0 == strcmp(method, "DELETE")) {
        *sc = SC_M_DELETE;
    }
    else if (0 == strcmp(method, "OPTIONS")) {
        *sc = SC_M_OPTIONS;
    }
    else if (0 == strcmp(method, "TRACE")) {
        *sc = SC_M_TRACE;
    }
    else if (0 == strcmp(method, "PROPFIND")) {
        *sc = SC_M_PROPFIND;
    }
    else if (0 == strcmp(method, "PROPPATCH")) {
        *sc = SC_M_PROPPATCH;
    }
    else if (0 == strcmp(method, "MKCOL")) {
        *sc = SC_M_MKCOL;
    }
    else if (0 == strcmp(method, "COPY")) {
        *sc = SC_M_COPY;
    }
    else if (0 == strcmp(method, "MOVE")) {
        *sc = SC_M_MOVE;
    }
    else if (0 == strcmp(method, "LOCK")) {
        *sc = SC_M_LOCK;
    }
    else if (0 == strcmp(method, "UNLOCK")) {
        *sc = SC_M_UNLOCK;
    }
    else if (0 == strcmp(method, "ACL")) {
        *sc = SC_M_ACL;
    }
    else if (0 == strcmp(method, "REPORT")) {
        *sc = SC_M_REPORT;
    }
    else if (0 == strcmp(method, "VERSION-CONTROL")) {
        *sc = SC_M_VERSION_CONTROL;
    }
    else if (0 == strcmp(method, "CHECKIN")) {
        *sc = SC_M_CHECKIN;
    }
    else if (0 == strcmp(method, "CHECKOUT")) {
        *sc = SC_M_CHECKOUT;
    }
    else if (0 == strcmp(method, "UNCHECKOUT")) {
        *sc = SC_M_UNCHECKOUT;
    }
    else if (0 == strcmp(method, "SEARCH")) {
        *sc = SC_M_SEARCH;
    }
    else if (0 == strcmp(method, "MKWORKSPACE")) {
        *sc = SC_M_MKWORKSPACE;
    }
    else if (0 == strcmp(method, "UPDATE")) {
        *sc = SC_M_UPDATE;
    }
    else if (0 == strcmp(method, "LABEL")) {
        *sc = SC_M_LABEL;
    }
    else if (0 == strcmp(method, "MERGE")) {
        *sc = SC_M_MERGE;
    }
    else if (0 == strcmp(method, "BASELINE-CONTROL")) {
        *sc = SC_M_BASELINE_CONTROL;
    }
    else if (0 == strcmp(method, "MKACTIVITY")) {
        *sc = SC_M_MKACTIVITY;
    }
    else {
		*sc = SC_M_JK_STORED;
    }

    return rc;
}

/**
 * Get header id.
 *
 * sc_for_req_header
 */
int jk2_requtil_getHeaderId(jk_env_t *env, const char *header_name,
                            unsigned short *sc)
{
/*     char lowerCased[30]; */

/*     if( strlen( header_name ) > 30 ) */
/*         return JK_FALSE; */
/*     strncpy( lowerCased, header_name,  30 ); */


    switch (header_name[0]) {
    case 'a':
    case 'A':
        if (strncasecmp(header_name, "accept", 6) == 0) {
            if ('-' == header_name[6]) {
                if (!strcasecmp(header_name + 7, "charset")) {
                    *sc = SC_ACCEPT_CHARSET;
                }
                else if (!strcasecmp(header_name + 7, "encoding")) {
                    *sc = SC_ACCEPT_ENCODING;
                }
                else if (!strcasecmp(header_name + 7, "language")) {
                    *sc = SC_ACCEPT_LANGUAGE;
                }
                else {
                    return JK_ERR;
                }
            }
            else if ('\0' == header_name[6]) {
                *sc = SC_ACCEPT;
            }
            else {
                return JK_ERR;
            }
        }
        else if (!strcasecmp(header_name, "authorization")) {
            *sc = SC_AUTHORIZATION;
        }
        else {
            return JK_ERR;
        }
        break;

    case 'c':
    case 'C':
        if (!strcasecmp(header_name, "cookie")) {
            *sc = SC_COOKIE;
        }
        else if (!strcasecmp(header_name, "connection")) {
            *sc = SC_CONNECTION;
        }
        else if (!strcasecmp(header_name, "content-type")) {
            *sc = SC_CONTENT_TYPE;
        }
        else if (!strcasecmp(header_name, "content-length")) {
            *sc = SC_CONTENT_LENGTH;
        }
        else if (!strcasecmp(header_name, "cookie2")) {
            *sc = SC_COOKIE2;
        }
        else {
            return JK_ERR;
        }
        break;

    case 'h':
    case 'H':
        if (!strcasecmp(header_name, "host")) {
            *sc = SC_HOST;
        }
        else {
            return JK_ERR;
        }
        break;

    case 'p':
    case 'P':
        if (!strcasecmp(header_name, "pragma")) {
            *sc = SC_PRAGMA;
        }
        else {
            return JK_ERR;
        }
        break;

    case 'r':
    case 'R':
        if (!strcasecmp(header_name, "referer")) {
            *sc = SC_REFERER;
        }
        else {
            return JK_ERR;
        }
        break;

    case 'u':
    case 'U':
        if (!strcasecmp(header_name, "user-agent")) {
            *sc = SC_USER_AGENT;
        }
        else {
            return JK_ERR;
        }
        break;

    default:
/*         env->l->jkLog(env, env->l, JK_LOG_INFO,  */
/*                       "requtil.getHeaderId() long header %s\n", header_name); */

        return JK_ERR;
    }
    return JK_OK;
}

/** Retrieve the cookie with the given name
 */
char *jk2_requtil_getCookieByName(jk_env_t *env, jk_ws_service_t *s,
                                  const char *name)
{
    int i;
    jk_map_t *headers = s->headers_in;

    /* XXX use 'get' - and make sure jk_map has support for
       case insensitive search */
    for (i = 0; i < headers->size(NULL, headers); i++) {
        if (0 == strcasecmp(headers->nameAt(NULL, headers, i), "cookie")) {

            char *id_start;
            for (id_start = strstr(headers->valueAt(NULL, headers, i), name);
                 id_start; id_start = strstr(id_start + 1, name)) {
                if ('=' == id_start[strlen(name)]) {
                    /*
                     * Session 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);
                        if (id_end = strchr(id_start, ';')) {
                            *id_end = '\0';
                        }
                        return id_start;
                    }
                }
            }
        }
    }

    return NULL;
}

/* Retrieve the parameter with the given name
 */
char *jk2_requtil_getPathParam(jk_env_t *env, jk_ws_service_t *s,
                               const char *name)
{
    char *id_start = NULL;
    for (id_start = strstr(s->req_uri, name);
         id_start; id_start = strstr(id_start + 1, name)) {
        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 =
        apr_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 - 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 the method was unrecognized, encode it as an attribute */
	if (method == SC_M_JK_STORED) {
		if (msg->appendByte(env, msg, SC_A_STORED_METHOD) ||
            msg->appendString(env, msg, s->method)) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                         "handle.request() Error encoding method %s\n",
                         s->method);
		}
	}

    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)
        env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                      "serialize.request() serialized %s\n", s->req_uri);

    /*  msg->dump( env, msg, "Dump: " ); */
    return JK_OK;
}


/** The inital BODY chunk 
 */
int jk2_serialize_postHead(jk_env_t *env, jk_msg_t *msg,
                           jk_ws_service_t *r, jk_endpoint_t *ae)
{
    int len = r->left_bytes_to_send;

    if (len > AJP13_MAX_SEND_BODY_SZ) {
        len = AJP13_MAX_SEND_BODY_SZ;
    }
    if (len <= 0) {
        len = 0;
        return JK_OK;
    }

    len = msg->appendFromServer(env, msg, r, ae, len);
    /* the right place to add file storage for upload */
    if (len >= 0) {
        r->content_read += len;
        return JK_OK;
    }

    env->l->jkLog(env, env->l, JK_LOG_ERROR,
                  "handler.marshalPostHead() - error len=%d\n", len);
    return JK_ERR;
}

/* -------------------- Query decoding -------------------- */

/** Read a query string into the map
 */
int jk2_requtil_queryRead(jk_env_t *env, jk_map_t *m, const char *query)
{
    char *sep;
    char *value;
    char *qry = m->pool->pstrdup(env, m->pool, query);

    while (qry != NULL) {
        sep = strchr(qry, '&');
        if (sep != NULL) {
            *sep = '\0';
            sep++;
        }

        value = strchr(qry, '=');
        if (value == NULL) {
            value = "";
        }
        else {
            *value = '\0';
            value++;
        }
        m->add(env, m, m->pool->pstrdup(env, m->pool, qry),
               m->pool->pstrdup(env, m->pool, value));
        qry = sep;
    }
    return JK_OK;
}


/* -------------------- Request encoding -------------------- */
/* Moved from IIS adapter */

#define T_OS_ESCAPE_PATH	(4)

static const unsigned char test_char_table[256] = {
    0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 14, 14, 14, 14, 14, 14, 14, 14,
        14,
    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 7, 6, 1, 6, 1, 1,
    9, 9, 1, 0, 8, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 15,
    15, 8, 15, 15, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 7, 0, 7, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 15, 7, 15, 1, 14, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6
};

#define TEST_CHAR(c, f)	(test_char_table[(unsigned)(c)] & (f))

static const char c2x_table[] = "0123456789abcdef";

static unsigned char *c2x(unsigned what, unsigned char *where)
{
    *where++ = '%';
    *where++ = c2x_table[what >> 4];
    *where++ = c2x_table[what & 0xf];
    return where;
}

int jk_requtil_escapeUrl(const char *path, char *dest, int destsize)
{
    const unsigned char *s = (const unsigned char *)path;
    unsigned char *d = (unsigned char *)dest;
    unsigned char *e = (unsigned char *)(dest + destsize - 1);
    unsigned char *ee = (unsigned char *)(dest + destsize - 3);
    unsigned c;

    while ((c = *s)) {
        if (TEST_CHAR(c, T_OS_ESCAPE_PATH)) {
            if (d >= ee)
                return JK_ERR;
            d = c2x(c, d);
        }
        else {
            if (d >= e)
                return JK_ERR;
            *d++ = c;
        }
        ++s;
    }
    *d = '\0';
    return JK_OK;
}

/* XXX Make it a default checking in uri worker map
 */
int jk_requtil_uriIsWebInf(char *uri)
{
    char *c = uri;
    while (*c) {
        *c = tolower(*c);
        c++;
    }
    if (strstr(uri, "web-inf")) {
        return JK_TRUE;
    }
    if (strstr(uri, "meta-inf")) {
        return JK_TRUE;
    }

    return JK_FALSE;
}

static char x2c(const char *what)
{
    register char digit;

    digit =
        ((what[0] >= 'A') ? ((what[0] & 0xdf) - 'A') + 10 : (what[0] - '0'));
    digit *= 16;
    digit +=
        (what[1] >= 'A' ? ((what[1] & 0xdf) - 'A') + 10 : (what[1] - '0'));
    return (digit);
}

int jk_requtil_unescapeUrl(char *url)
{
    register int x, y, badesc, badpath;

    badesc = 0;
    badpath = 0;
    for (x = 0, y = 0; url[y]; ++x, ++y) {
        if (url[y] != '%')
            url[x] = url[y];
        else {
            if (!isxdigit(url[y + 1]) || !isxdigit(url[y + 2])) {
                badesc = 1;
                url[x] = '%';
            }
            else {
                url[x] = x2c(&url[y + 1]);
                y += 2;
                if (url[x] == '/' || url[x] == '\0')
                    badpath = 1;
            }
        }
    }
    url[x] = '\0';
    if (badesc)
        return -1;
    else if (badpath)
        return -2;
    else
        return JK_OK;
}

void jk_requtil_getParents(char *name)
{
    int l, w;

    /* Four paseses, as per RFC 1808 */
    /* a) remove ./ path segments */

    for (l = 0, w = 0; name[l] != '\0';) {
        if (name[l] == '.' && name[l + 1] == '/'
            && (l == 0 || name[l - 1] == '/'))
            l += 2;
        else
            name[w++] = name[l++];
    }

    /* b) remove trailing . path, segment */
    if (w == 1 && name[0] == '.')
        w--;
    else if (w > 1 && name[w - 1] == '.' && name[w - 2] == '/')
        w--;
    name[w] = '\0';

    /* c) remove all xx/../ segments. (including leading ../ and /../) */
    l = 0;

    while (name[l] != '\0') {
        if (name[l] == '.' && name[l + 1] == '.' && name[l + 2] == '/' &&
            (l == 0 || name[l - 1] == '/')) {
            register int m = l + 3, n;

            l = l - 2;
            if (l >= 0) {
                while (l >= 0 && name[l] != '/')
                    l--;
                l++;
            }
            else
                l = 0;
            n = l;
            while ((name[n] = name[m]))
                (++n, ++m);
        }
        else
            ++l;
    }

    /* d) remove trailing xx/.. segment. */
    if (l == 2 && name[0] == '.' && name[1] == '.')
        name[0] = '\0';
    else if (l > 2 && name[l - 1] == '.' && name[l - 2] == '.'
             && name[l - 3] == '/') {
        l = l - 4;
        if (l >= 0) {
            while (l >= 0 && name[l] != '/')
                l--;
            l++;
        }
        else
            l = 0;
        name[l] = '\0';
    }
}


static const char begin_cert[] = "-----BEGIN CERTIFICATE-----\r\n";

static const char end_cert[] = "-----END CERTIFICATE-----\r\n";

static const char basis_64[] =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

int jk_requtil_base64CertLen(int len)
{
    int n = ((len + 2) / 3 * 4) + 1;    /* base64 encoded size */
    n += (n + 63 / 64) * 2;     /* add CRLF's */
    n += sizeof(begin_cert) + sizeof(end_cert) - 2;     /* add enclosing strings. */
    return n;
}

int jk_requtil_base64EncodeCert(char *encoded,
                                const unsigned char *string, int len)
{
    int i, c;
    char *p;
    const char *t;

    p = encoded;

    t = begin_cert;
    while (*t != '\0')
        *p++ = *t++;

    c = 0;
    for (i = 0; i < len - 2; i += 3) {
        *p++ = basis_64[(string[i] >> 2) & 0x3F];
        *p++ = basis_64[((string[i] & 0x3) << 4) |
                        ((int)(string[i + 1] & 0xF0) >> 4)];
        *p++ = basis_64[((string[i + 1] & 0xF) << 2) |
                        ((int)(string[i + 2] & 0xC0) >> 6)];
        *p++ = basis_64[string[i + 2] & 0x3F];
        c += 4;
        if (c >= 64) {
            *p++ = '\r';
            *p++ = '\n';
            c = 0;
        }
    }
    if (i < len) {
        *p++ = basis_64[(string[i] >> 2) & 0x3F];
        if (i == (len - 1)) {
            *p++ = basis_64[((string[i] & 0x3) << 4)];
            *p++ = '=';
        }
        else {
            *p++ = basis_64[((string[i] & 0x3) << 4) |
                            ((int)(string[i + 1] & 0xF0) >> 4)];
            *p++ = basis_64[((string[i + 1] & 0xF) << 2)];
        }
        *p++ = '=';
        c++;
    }
    if (c != 0) {
        *p++ = '\r';
        *p++ = '\n';
    }

    t = end_cert;
    while (*t != '\0')
        *p++ = *t++;

    *p++ = '\0';
    return p - encoded;
}


/** Initialize the request 
 * 
 * jk_init_ws_service
 */
void jk2_requtil_initRequest(jk_env_t *env, jk_ws_service_t *s)
{
    s->ws_private = NULL;
    s->method = NULL;
    s->protocol = NULL;
    s->req_uri = NULL;
    s->remote_addr = NULL;
    s->remote_host = NULL;
    s->remote_user = NULL;
    s->auth_type = NULL;
    s->query_string = NULL;
    s->server_name = NULL;
    s->server_port = 80;
    s->server_software = NULL;
    s->content_length = 0;
    s->is_chunked = 0;
    s->no_more_chunks = 0;
    s->content_read = 0;
    s->is_ssl = JK_FALSE;
    s->ssl_cert = NULL;
    s->ssl_cert_len = 0;
    s->ssl_cipher = NULL;
    s->ssl_session = NULL;
    s->jvm_route = NULL;
    s->uriEnv = NULL;
    s->outBuf = NULL;
    s->msg = NULL;

    s->jkprintf = jk2_requtil_printf;
}