src/http/writer/write.c

Go to the documentation of this file.

#include <unistd.h>
#include <sys/stat.h>

#include "class.h"
#include "http/message.h"
#include "http/writer.h"
#include "cbuf.h"
#include "stream.h"

#include "commons.h"


ssize_t
httpWriterWrite(void * _this, Stream st)
{
        HttpWriter       this    = _this;
        HttpMessageQueue respq   = this->queue;
        int              cont    = 1;

        if (cbufIsLocked(this->buffer)) {
                if (FALSE == this->ourLock)
                        return 0;
        }
        else {
                cbufLock(this->buffer);
                this->ourLock = TRUE;
        }

        while (cont) {
                switch (this->state) {
                        case HTTP_WRITER_GET:
                                if (NULL == this->current && 0 < respq->nmsgs) {
                                        this->current = respq->msgs[0];

                                        this->written = 0;
                                        this->nbody   = 0;
                                        this->nheader = httpMessageHeaderSizeGet(this->current);

                                        httpMessageHeaderToString(
                                                        this->current,
                                                        cbufGetWrite(this->buffer));
                                        cbufIncWrite(this->buffer, this->nheader);

                                        this->state = HTTP_WRITER_WRITE;
                                }
                                else {
                                        cbufRelease(this->buffer);
                                        this->ourLock = FALSE;
                                        cont          = 0;
                                }
                                break;

                        case HTTP_WRITER_WRITE:
                                if (this->nbody < this->current->nbody) {
                                        size_t size = MIN(
                                                        this->current->nbody - this->nbody,
                                                        cbufGetFree(this->buffer));

                                        switch (this->current->type) {
                                                case HTTP_MESSAGE_BUFFERED:
                                                        cbufSetData(this->buffer,
                                                                        this->current->body + this->nbody,
                                                                        size);
                                                        break;

                                                case HTTP_MESSAGE_PIPED:
                                                        size = cbufRead(this->buffer, this->current->handle);
                                                        break;

                                                default:
                                                        return -1;
                                        }

                                        this->nbody += size;
                                }

                                {
                                        ssize_t written = cbufWrite(this->buffer, st);

                                        if (0 <= written) {
                                                this->written += written;
                                        }
                                        else {
                                                return -1;
                                        }
                                }

                                if (this->written == this->current->nbody + this->nheader) {
                                        this->state = HTTP_WRITER_DONE;
                                }
                                else {
                                        cont = 0;
                                }
                                break;

                        case HTTP_WRITER_DONE:
                                this->state   = HTTP_WRITER_GET;

                                memmove(respq->msgs,
                                                &(respq->msgs[1]),
                                                sizeof(void*) * (--respq->nmsgs + 1));

                                cbufRelease(this->buffer);
                                this->ourLock = FALSE;

                                if (! httpMessageHasKeepAlive(this->current)) {
                                        delete(this->current);
                                        return -1;
                                }

                                delete(this->current);
                                break;
                }
        }

        return respq->nmsgs;
}

// vim: set ts=4 sw=4: