jk_msg_ajp.c

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

                                   const int len)
{
    if (! len) {
        return JK_OK;
    }

    if (msg->len + len > msg->maxlen) {
        return JK_ERR;
    }

    /* We checked for space !!  */
    memcpy((char *)msg->buf + msg->len, param, len); 
    msg->len += len;

    return JK_OK;
}

static unsigned long jk2_msg_ajp_getLong(jk_env_t *env, jk_msg_t *msg)
{
    unsigned long i;
    
    if(msg->pos + 3 > msg->len) {
        env->l->jkLog( env, env->l, JK_LOG_ERROR,
                       "msg_ajp.getLong(): BufferOverflowException %d %d\n",
                       msg->pos, msg->len);
        msg->dump(env, msg, "BUFFER OVERFLOW");
        return -1;
    }
    i  = ((msg->buf[(msg->pos++)] & 0xFF)<<24);
    i |= ((msg->buf[(msg->pos++)] & 0xFF)<<16);
    i |= ((msg->buf[(msg->pos++)] & 0xFF)<<8);
    i |= ((msg->buf[(msg->pos++)] & 0xFF));
    return i;
}

static unsigned short jk2_msg_ajp_getInt(jk_env_t *env, jk_msg_t *msg) 
{
    int i;
    if(msg->pos + 1 > msg->len) {
        env->l->jkLog( env, env->l, JK_LOG_ERROR,
                       "msg_ajp.geInt(): BufferOverflowException %d %d\n",
                       msg->pos, msg->len);
        msg->dump(env, msg, "BUFFER OVERFLOW");
        return -1;
    }
    i  = ((msg->buf[(msg->pos++)] & 0xFF)<<8);
    i += ((msg->buf[(msg->pos++)] & 0xFF));
    return i;
}

static unsigned short jk2_msg_ajp_peekInt(jk_env_t *env, jk_msg_t *msg) 
{
    int i;
    if(msg->pos + 1 > msg->len) {
        env->l->jkLog( env, env->l, JK_LOG_ERROR,
                       "msg_ajp.peekInt(): BufferOverflowException %d %d\n",
                       msg->pos, msg->len);
        msg->dump(env, msg, "BUFFER OVERFLOW");
        return -1;
    }
    i  = ((msg->buf[(msg->pos)] & 0xFF)<<8);
    i += ((msg->buf[(msg->pos+1)] & 0xFF));
    return i;
}

static unsigned char jk2_msg_ajp_getByte(jk_env_t *env, jk_msg_t *msg) 
{
    unsigned char rc;
    if(msg->pos > msg->len) {
        env->l->jkLog( env, env->l, JK_LOG_ERROR,
                       "msg_ajp.getByte(): BufferOverflowException %d %d\n",
                       msg->pos, msg->len);
        msg->dump(env, msg, "BUFFER OVERFLOW");        
        return -1;
    }
    rc = msg->buf[msg->pos++];
    
    return rc;
}

static char *jk2_msg_ajp_getString(jk_env_t *env, jk_msg_t *msg) 
{
    int size = jk2_msg_ajp_getInt(env, msg);
    int start = msg->pos;

    if((size < 0 ) || (size + start > msg->maxlen)) { 
        env->l->jkLog( env, env->l, JK_LOG_ERROR,
                       "msg_ajp.getString(): BufferOverflowException %d %d\n",
                       msg->pos, msg->len);
        msg->dump(env, msg, "BUFFER OVERFLOW");
        return (unsigned char *)"ERROR"; /* XXX */
    }

    msg->pos += size;
    msg->pos++;  /* terminating NULL */
    
    return (unsigned char *)(msg->buf + start); 
}

static unsigned char *jk2_msg_ajp_getBytes(jk_env_t *env, jk_msg_t *msg, int *lenP) 
{
    int size = jk2_msg_ajp_getInt(env, msg);
    int start = msg->pos;

    *lenP=size;
    
    if((size < 0 ) || (size + start > msg->maxlen)) { 
        env->l->jkLog( env, env->l, JK_LOG_ERROR,
                       "msg_ajp.getBytes(): BufferOverflowException %d %d\n",
                       msg->pos, msg->len);
        msg->dump(env, msg, "BUFFER OVERFLOW");
        return (unsigned char *)"ERROR"; /* XXX */
    }

    msg->pos += size;
    msg->pos++;  /* terminating NULL */
    
    return (unsigned char *)(msg->buf + start); 
}


/** Shame-less copy from somewhere.
    assert (src != dst)
 */
static void jk2_swap_16(unsigned char *src, unsigned char *dst) 
{
    *dst++ = *(src + 1 );
    *dst= *src;
}

/** Process the request header. At least the header must be
    available - the channel may get more data it it can, to
    avoid multiple system calls.
*/
static int jk2_msg_ajp_checkHeader(jk_env_t *env, jk_msg_t *msg,
                                   jk_endpoint_t *ae )
{
    char *head=msg->buf;
    int msglen;

    if( ! (
           ( head[0] == 0x41 && head[1] == 0x42 ) ||
           ( head[0] == 0x12 && head[1] == 0x34 ))) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "msgAjp.receive(): Bad signature %x%x\n",
                      head[0], head[1]);
        msg->dump( env, msg, "BAD MESSAGE: " );
        return -1;
    }

    msglen  = ((head[2]&0xff)<<8);
    msglen += (head[3] & 0xFF);

    if(msglen > msg->maxlen ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "msgAjp.receive(): Incoming message is too big %d\n",
                      msglen);
        return -2;
    }

    msg->len=msglen+AJP_HEADER_LEN;
    msg->pos=AJP_HEADER_LEN;

    return msglen;
}



/** 
 * Special method. Will read data from the server and add them as
 * bytes. It is equivalent with jk2_requtil_readFully() in a buffer
 * and then jk_msg_appendBytes(), except that we use directly the
 * internal buffer.
 *
 * Returns -1 on error, else number of bytes read
 */
static int jk2_msg_ajp_appendFromServer(jk_env_t *env, jk_msg_t    *msg,
                                       jk_ws_service_t *r,
                                       jk_endpoint_t  *ae,
                                       int            len )
{
    unsigned char *read_buf = msg->buf;

    jk2_msg_ajp_reset(env, msg);

    read_buf += AJP_HEADER_LEN;    /* leave some space for the buffer headers */
    read_buf += AJP_HEADER_SZ_LEN; /* leave some space for the read length */

    /* Pick the max size since we don't know the content_length */
    if (r->is_chunked && len == 0) {
	len = AJP13_MAX_SEND_BODY_SZ;
    }

    if ((len = jk2_requtil_readFully(env, r, read_buf, len)) < 0) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "msgAjp.appendFromServer() error reading from server\n");
        return -1;
    }

    if (!r->is_chunked) {
	r->left_bytes_to_send -= len;
    }

    if (len > 0) {
	/* Recipient recognizes empty packet as end of stream, not
	   an empty body packet */
        if(0 != jk2_msg_ajp_appendInt(env, msg, (unsigned short)len)) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR, 
                          "msg.appendFromServer(): appendInt failed\n");
            return -1;
	}
    }

    msg->len= msg->len + len;

    return len;
}

static void jk2_msg_ajp_init(jk_env_t *env, jk_msg_t *msg, int buffSize) 
{
    msg->maxlen=buffSize;
    msg->len=0;

    msg->headerLength=AJP_HEADER_LEN;

    msg->reset=jk2_msg_ajp_reset;
    msg->end=jk2_msg_ajp_end;
    msg->dump=jk2_msg_ajp_dump;

    msg->appendByte=jk2_msg_ajp_appendByte;
    msg->appendBytes=jk2_msg_ajp_appendBytes;
    msg->appendInt=jk2_msg_ajp_appendInt;
    msg->appendLong=jk2_msg_ajp_appendLong;
    msg->appendString=jk2_msg_ajp_appendString;
    msg->appendAsciiString=jk2_msg_ajp_appendAsciiString;
    msg->appendMap=jk2_msg_ajp_appendMap;

    msg->appendFromServer=jk2_msg_ajp_appendFromServer;

    msg->getByte=jk2_msg_ajp_getByte;
    msg->getInt=jk2_msg_ajp_getInt;
    msg->peekInt=jk2_msg_ajp_peekInt;
    msg->getLong=jk2_msg_ajp_getLong;
    msg->getString=jk2_msg_ajp_getString;
    msg->getMap=jk2_msg_ajp_getMap;
    msg->getBytes=jk2_msg_ajp_getBytes;

    msg->checkHeader=jk2_msg_ajp_checkHeader;
}


jk_msg_t *jk2_msg_ajp_create2(jk_env_t *env, jk_pool_t *pool, char *buf, int buffSize)
{
    jk_msg_t *msg = 
        (jk_msg_t *)pool->calloc(env, pool, sizeof(jk_msg_t));

    if( buffSize==0 )
        buffSize=DEF_BUFFER_SZ;
    if(!msg) {
        return NULL;
    }
    msg->pool = pool;

    msg->buf= buf;

    if(msg->buf==NULL) {
        return NULL;
    }

    jk2_msg_ajp_init( env, msg, buffSize );

    msg->len=buffSize;

    return msg;
}


jk_msg_t *jk2_msg_ajp_create(jk_env_t *env, jk_pool_t *pool, int buffSize) 
{
    jk_msg_t *msg = 
        (jk_msg_t *)pool->calloc(env, pool, sizeof(jk_msg_t));

    if( buffSize==0 )
        buffSize=DEF_BUFFER_SZ;
    if(!msg) {
        return NULL;
    }
    msg->pool = pool;
    msg->serverSide=JK_FALSE;

    msg->buf= (unsigned char *)msg->pool->alloc(env, msg->pool, buffSize);
    
    if(msg->buf==NULL) {
        return NULL;
    }

    jk2_msg_ajp_init( env, msg, buffSize );

    return msg;
}