http/writer/write.c File Reference

#include <unistd.h>
#include <sys/stat.h>
#include "class.h"
#include "http/message.h"
#include "queue.h"
#include "http/writer.h"
#include "stream.h"
#include "commons.h"
#include "utils/memory.h"

Include dependency graph for http/writer/write.c:

Go to the source code of this file.

Functions
ssize_t	httpWriterWrite (void *_this, Stream st)

Detailed Description

Author

Georg Hopp

Copyright

Copyright © 2012 Georg Hopp

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file http/writer/write.c.

Function Documentation

ssize_t httpWriterWrite	(	void *	_this,
		Stream	st
	)

if the message did not have the keep-alive feature we don't care about further pipelined messages and return to the caller with a -2 indicating that the underlying connection should be closed at their side. Then we close to connection.

Definition at line 37 of file http/writer/write.c.

References HTTP_WRITER_DONE, HTTP_WRITER_GET, HTTP_WRITER_WRITE, httpMessageHasKeepAlive(), httpMessageHeaderSizeGet(), httpMessageHeaderToString(), MEM_FREE, memGetSize(), memMalloc(), MIN, queueEmpty, queueGet(), size, streamWrite(), and WRITER_BUF_CHUNK.

Referenced by httpWorkerWrite().

{
    HttpWriter this = _this;

    switch (this->state) {
        char    * start;
        ssize_t   to_write;
        ssize_t   written;

        case HTTP_WRITER_GET:

        if (! queueEmpty(this->queue)) {
            this->current = queueGet(this->queue);

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

            if (this->nheader > memGetSize(this->buffer)) {
                ssize_t size = this->nheader;

                size = (0 != size%WRITER_BUF_CHUNK)?
                    (size/WRITER_BUF_CHUNK)+1 :
                    size/WRITER_BUF_CHUNK;
                size *= WRITER_BUF_CHUNK;

                if (NULL != this->buffer) {
                    MEM_FREE(this->buffer);
                }

                this->buffer  = memMalloc(size);
                this->nbuffer = size;
            }

            httpMessageHeaderToString(this->current, this->buffer);

            this->nbody = MIN(
                    this->current->nbody,
                    this->nbuffer - this->nheader);

            memcpy(
                    this->buffer + this->nheader,
                    this->current->body,
                    this->nbody);

            this->state = HTTP_WRITER_WRITE;
        }
        else {
            break;
        }

        case HTTP_WRITER_WRITE:

        if (this->written >= this->nbuffer) {
            size_t body_done = this->written - this->nheader;

            start    = this->current->body + body_done;
            to_write = this->current->nbody - body_done;
        } else {
            start    = this->buffer   + this->written;
            to_write = (this->nheader + this->nbody) - this->written;
        }

        written = streamWrite(st, start, to_write);

        if (written < 0) {
            return written;
        }

        this->written += written;

        if (written != to_write) {
            /*
             * for some reason not all data could be
             * written...most likely its a slow connection
             * so, not to slow down the server we stop
             * writing to this one now and come back to
             * it in the next run....maybe it would be
             * feasable to also implement some kind of
             * timeout mechanism for writes...
             * By the way, the same is true for reading,
             * so to say, the parser.
             */
            break;
        }

        if (this->written >= this->nheader + this->current->nbody) {
            // we are done with this message.
            this->state = HTTP_WRITER_DONE;
        } else {
            break;
        }

        case HTTP_WRITER_DONE:

        this->state = HTTP_WRITER_GET;

        if (! httpMessageHasKeepAlive(this->current)) {
            /**
             * if the message did not have the keep-alive feature
             * we don't care about further pipelined messages and
             * return to the caller with a -2 indicating that the
             * underlying connection should be closed at their side.
             * Then we close to connection.
             */
            delete(this->current);
            return -2;
        }
        delete(this->current);

        break;
    }

    return NULL == this->current ?
        this->queue->nmsg :
        this->queue->nmsg + 1;
}

Here is the call graph for this function:

Here is the caller graph for this function: