/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

#include "fcgid_bucket.h"
#include "fcgid_protocol.h"
#include "fcgid_bridge.h"

#define FCGID_FEED_LEN 8192
static apr_status_t fcgid_feed_data(fcgid_bucket_ctx * ctx,
                                    apr_bucket_alloc_t * bucketalloc,
                                    char **buffer, apr_size_t * bufferlen)
{
    apr_status_t rv;

    if (!ctx->buffer) {
        *buffer = apr_bucket_alloc(FCGID_FEED_LEN, bucketalloc);

        *bufferlen = FCGID_FEED_LEN;
        if ((rv =
             proc_read_ipc(&ctx->ipc, *buffer,
                           bufferlen)) != APR_SUCCESS) {
            ctx->has_error = 1;
            apr_bucket_free(*buffer);
            return rv;
        }

        ctx->buffer =
            apr_bucket_heap_create(*buffer, FCGID_FEED_LEN,
                                   apr_bucket_free, bucketalloc);
        if (*bufferlen != FCGID_FEED_LEN) {
            apr_bucket *buckettmp;

            apr_bucket_split(ctx->buffer, *bufferlen);
            buckettmp = APR_BUCKET_NEXT(ctx->buffer);
            apr_bucket_delete(buckettmp);
        }
    } else {
        apr_bucket_read(ctx->buffer, (const char **) buffer, bufferlen,
                        APR_BLOCK_READ);
    }
    return APR_SUCCESS;
}

static void fcgid_ignore_bytes(fcgid_bucket_ctx * ctx,
                               apr_size_t ignorebyte)
{
    apr_bucket *buckettmp;

    if (ignorebyte == ctx->buffer->length) {
        apr_bucket_destroy(ctx->buffer);
        ctx->buffer = NULL;
    } else {
        apr_bucket_split(ctx->buffer, ignorebyte);
        buckettmp = ctx->buffer;
        ctx->buffer = APR_BUCKET_NEXT(ctx->buffer);
        apr_bucket_delete(buckettmp);
    }
}

static apr_status_t fcgid_header_bucket_read(apr_bucket * b,
                                             const char **str,
                                             apr_size_t * len,
                                             apr_read_type_e block)
{
    fcgid_bucket_ctx *ctx = (fcgid_bucket_ctx *) b->data;
    apr_status_t rv;
    apr_size_t hasread, bodysize;
    FCGI_Header header;
    apr_bucket *curbucket = b;

    /* Keep reading until I get a fastcgi header */
    hasread = 0;
    while (hasread < sizeof(header)) {
        char *buffer;
        apr_size_t bufferlen, putsize;

        /* Feed some data if necessary */
        if ((rv =
             fcgid_feed_data(ctx, b->list, &buffer,
                             &bufferlen)) != APR_SUCCESS)
            return rv;

        /* Initialize header */
        putsize = fcgid_min(bufferlen, sizeof(header) - hasread);
        memcpy((apr_byte_t *)&header + hasread, buffer, putsize);
        hasread += putsize;

        /* Ignore the bytes that have read */
        fcgid_ignore_bytes(ctx, putsize);
    }

    /* Get the body size */
    bodysize = header.contentLengthB1;
    bodysize <<= 8;
    bodysize += header.contentLengthB0;

    /* Handle FCGI_STDERR body, write the content to log file */
    if (header.type == FCGI_STDERR) {
        char *logbuf = apr_bucket_alloc(APR_BUCKET_BUFF_SIZE, b->list);
        char *line;
        apr_size_t hasput;

        memset(logbuf, 0, APR_BUCKET_BUFF_SIZE);

        hasread = 0;
        hasput = 0;
        while (hasread < bodysize) {
            char *buffer;
            apr_size_t bufferlen, canput, willput;

            /* Feed some data if necessary */
            if ((rv =
                 fcgid_feed_data(ctx, b->list, &buffer,
                                 &bufferlen)) != APR_SUCCESS) {
                apr_bucket_free(logbuf);
                return rv;
            }

            canput = fcgid_min(bufferlen, bodysize - hasread);
            willput =
                fcgid_min(canput, APR_BUCKET_BUFF_SIZE - hasput - 1);
            memcpy(logbuf + hasput, buffer, willput);
            hasread += canput;
            hasput += willput;

            /* Ignore the "canput" bytes */
            fcgid_ignore_bytes(ctx, canput);
        }

        /* Now I get the log data, write log and release the buffer */
        line = logbuf;
        while (*line) {
            char *end = strpbrk(line, "\r\n");

            if (end != NULL) {
                *end = '\0';
            }
            ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, ctx->ipc.request,
                          "mod_fcgid: stderr: %s", line);
            if (end == NULL) {
                break;
            }
            ++end;
            line = end + strspn(end, "\r\n");
        }

        apr_bucket_free(logbuf);
    }

    /* if( header.type==FCGI_STDERR ) */
    /* Now handle FCGI_STDOUT */
    else if (header.type == FCGI_STDOUT) {
        hasread = 0;
        while (hasread < bodysize) {
            char *buffer;
            apr_size_t bufferlen, canput;
            apr_bucket *buckettmp;

            /* Feed some data if necessary */
            if ((rv =
                 fcgid_feed_data(ctx, b->list, &buffer,
                                 &bufferlen)) != APR_SUCCESS)
                return rv;

            canput = fcgid_min(bufferlen, bodysize - hasread);

            /* Change the current bucket to refer to what we read */
            buckettmp = ctx->buffer;
            if (canput == (bodysize - hasread)) {
                apr_bucket_split(ctx->buffer, canput);
                ctx->buffer = APR_BUCKET_NEXT(ctx->buffer);
                APR_BUCKET_REMOVE(buckettmp);
            } else {
                /* canput==bufferlen */
                ctx->buffer = NULL;
            }

            APR_BUCKET_INSERT_AFTER(curbucket, buckettmp);
            curbucket = buckettmp;
            hasread += canput;
        }                       /* while( hasread<bodysize ) */
    }

    /* if( header.type==FCGI_STDOUT ) */
    /* Now FCGI_END_REQUEST */
    else if (header.type == FCGI_END_REQUEST) {
        /* Just ignore the body */
        hasread = 0;
        while (hasread < bodysize) {
            char *buffer;
            apr_size_t bufferlen, canignore;

            /* Feed some data if necessary */
            if ((rv =
                 fcgid_feed_data(ctx, b->list, &buffer,
                                 &bufferlen)) != APR_SUCCESS)
                return rv;

            canignore = fcgid_min(bufferlen, bodysize);
            hasread += canignore;

            /* Ignore the bytes */
            fcgid_ignore_bytes(ctx, canignore);
        }
    }

    /* Now ignore padding data */
    hasread = 0;
    while (hasread < header.paddingLength) {
        char *buffer;
        apr_size_t bufferlen, canignore;

        /* Feed some data if necessary */
        if ((rv =
             fcgid_feed_data(ctx, b->list, &buffer,
                             &bufferlen)) != APR_SUCCESS)
            return rv;

        canignore = fcgid_min(bufferlen, header.paddingLength - hasread);
        hasread += canignore;

        /* Ignore the bytes */
        fcgid_ignore_bytes(ctx, canignore);
    }

    /* Tail another fastcgi header bucket if it's not ending */
    if (header.type != FCGI_END_REQUEST) {
        apr_bucket *headerbucket =
            ap_bucket_fcgid_header_create(b->list, ctx);
        APR_BUCKET_INSERT_AFTER(curbucket, headerbucket);
    } else {
        /* Release the process ASAP */
        if ((rv = apr_pool_cleanup_run(ctx->ipc.request->pool,
                                       ctx,
                                       bucket_ctx_cleanup)) != APR_SUCCESS)
            return rv;
    }

    b = apr_bucket_immortal_make(b, "", 0);
    return apr_bucket_read(b, str, len, APR_BLOCK_READ);
}

apr_bucket *ap_bucket_fcgid_header_make(apr_bucket * b,
                                        fcgid_bucket_ctx * ctx)
{
    b->length = (apr_size_t) (-1);
    b->start = -1;
    b->data = ctx;
    b->type = &ap_bucket_type_fcgid_header;

    return b;
}

apr_bucket *ap_bucket_fcgid_header_create(apr_bucket_alloc_t * list,
                                          fcgid_bucket_ctx * ctx)
{
    apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);

    APR_BUCKET_INIT(b);
    b->free = apr_bucket_free;
    b->list = list;
    return ap_bucket_fcgid_header_make(b, ctx);
}

const apr_bucket_type_t ap_bucket_type_fcgid_header = {
    "FCGID_HEADER", 5, APR_BUCKET_DATA,
    apr_bucket_destroy_noop,
    fcgid_header_bucket_read,
    apr_bucket_setaside_notimpl,
    apr_bucket_split_notimpl,
    apr_bucket_copy_notimpl
};