/*
 *  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.
 */

/***************************************************************************
 * Description: ISAPI plugin for Tomcat                                    *
 * Author:      Andy Armstrong <andy@tagish.com>                           *
 * Version:     $Revision$                                           *
 ***************************************************************************/

#include "poolbuf.h"

/* Macro to return the address of the first byte in a poolbuf__chunk on
 * the understanding that the buffer follows the structure in memory.
 */
#define poolbuf__buf(chnk) \
	((char *) ((poolbuf__chunk *) chnk + 1))

void poolbuf_init(poolbuf * pb, jk_pool_t *p)
{
    pb->p = p;
    pb->head = pb->current = NULL;
    pb->readPos = pb->writePos = 0;
    pb->avail = 0;
    pb->state = WRITE;
}

/* Write bytes to the buffer returning the number of bytes successfully
 * written. Can't be called again once poolbuf_read() has been called.
 */
size_t poolbuf_write(poolbuf * pb, const void *buf, size_t size)
{
    const char *cbuf = (const char *)buf;
    size_t left = size;

    if (READ == pb->state)
        return 0;

    /* first work out what we can write into the current buffer */
    if (pb->current != NULL && pb->writePos < pb->current->size) {
        char *chbuf = poolbuf__buf(pb->current) + pb->writePos;
        size_t sz = pb->current->size - pb->writePos;
        if (sz > left)
            sz = left;
        memcpy(chbuf, cbuf, sz);
        pb->writePos += sz;
        pb->avail += sz;
        cbuf += sz;
        left -= sz;
    }

    /* something left that we couldn't fit in the last chunk */
    if (left > 0) {
        poolbuf__chunk *chnk;
        size_t sz = size;

        if (sz < poolbuf__MINCHUNK)
            sz = poolbuf__MINCHUNK;
        if (NULL == pb->p
            || NULL == (chnk =
                        jk_pool_alloc(pb->p, sz + sizeof(poolbuf__chunk))))
            return size - left;

        chnk->next = NULL;
        chnk->size = sz;
        if (NULL == pb->head)
            pb->head = chnk;
        if (NULL != pb->current)
            pb->current->next = chnk;
        pb->current = chnk;
        memcpy(poolbuf__buf(chnk), cbuf, left);
        pb->avail += left;
        pb->writePos = left;
    }

    return size;
}

/* Read bytes from the buffer returning the number of bytes read (which
 * will be less than desired when the end of the buffer is reached). Once
 * poolbuf_read() has been called poolbuf_write() may not be called again.
 */
size_t poolbuf_read(poolbuf * pb, void *buf, size_t size)
{
    char *cbuf = (char *)buf;
    size_t nread = 0;

    if (WRITE == pb->state) {
        /* Move to read mode. Once we've done this subsequent
         * writes are not allowed.
         */
        pb->current = pb->head;
        pb->readPos = 0;
        pb->state = READ;
    }

    while (size > 0 && pb->avail > 0) {
        size_t sz = pb->current->size - pb->readPos;
        if (sz > pb->avail)
            sz = pb->avail;
        if (sz > size)
            sz = size;
        memcpy(cbuf, poolbuf__buf(pb->current) + pb->readPos, sz);
        pb->readPos += sz;
        if (pb->readPos == pb->current->size) {
            pb->current = pb->current->next;
            pb->readPos = 0;
        }
        pb->avail -= sz;
        nread += sz;
    }

    return nread;
}

/* Find out how many bytes are available for reading.
 */
size_t poolbuf_available(poolbuf * pb)
{
    return pb->avail;
}

/* Destroy the buffer. This doesn't actually free any memory
 * because the jk_pool functions don't support freeing individual
 * chunks, but it does recycle the buffer for subsequent use.
 */
void poolbuf_destroy(poolbuf * pb)
{
    pb->p = NULL;
    pb->head = pb->current = NULL;
    pb->readPos = pb->writePos = 0;
    pb->avail = 0;
    pb->state = WRITE;
}