Context Class Reference

Internal connection structure which is used in LwIP tcp_ callbacks as arg. More...

#include <connection.hpp>

Inheritance diagram for Context:

Collaboration diagram for Context:

Public Types
enum	State { FIRST, WAIT_FOR_EOH, PAYLOAD }

Public Member Functions
	Context (struct tcp_pcb *pcb)
	~Context ()
err_t	fill_request_buffer (const struct pbuf *p)
	Append pbuf to request_buffer. More...
size_t	find_eoh (const void *data=nullptr, size_t length=0)
	Try to find End Of Header (\r \r ) in buffer. More...
err_t	parse_request (const void *data=nullptr, size_t length=0)
	parste the request header (request line + request headers) More...
err_t	prepare_response ()
	Process message.response to internal buffer. More...
err_t	prepare_header ()
	Process message.headers to internal buffer. More...
void	free_buffer ()
Public Member Functions inherited from LwIPClass
virtual	~LwIPClass ()

Static Public Member Functions
static void *	operator new (size_t size) noexcept
static void	operator delete (void *ptr)
Static Public Member Functions inherited from LwIPClass
static void *	operator new (size_t size)
static void	operator delete (void *ptr)

Public Attributes
struct tcp_pcb *	pcb
uint8_t	retries
State	state
Environment	env
Message_t	message
char *	buffer
size_t	m_position
size_t	end_of_header
IResponse::unique_ptr_t	response

Detailed Description

Internal connection structure which is used in LwIP tcp_ callbacks as arg.

Member Enumeration Documentation

State

enum Context::State

Enumerator
FIRST
WAIT_FOR_EOH
PAYLOAD

               {
        FIRST, // firt call of recv callback after constructor
        WAIT_FOR_EOH, // wait for end of header \r\n\r\n
        PAYLOAD // pbuf containt payload
    };

Constructor & Destructor Documentation

Context()

Context::Context

(

struct tcp_pcb *

pcb

)

        : pcb(pcb)
        , retries(0)
        , state(FIRST)
        , message({ nullptr, nullptr, nullptr, 0 })
        , buffer(nullptr)
        , m_position(0)
        , end_of_header(0)
        , response(nullptr)
        , request_buffer(nullptr)
        , request_buffer_size(0) {
        tcp_arg(pcb, this);
    }

~Context()

Context::~Context

(

)

               {
        lwsapi_free(buffer); // when buffer is not deleted
        lwsapi_free(request_buffer); // when request_buffer is not deleted
        tcp_arg(this->pcb, nullptr);
    }

Member Function Documentation

operator new()

static void* Context::operator new ( size_t  size )

staticnoexcept

                                                    {
        if (Context::instances == Context::MAX) {
            lwsapi_error("Context::new Too many connections\n");
            return nullptr;
        }
        void *rv = mem_malloc(size);
        if (rv != nullptr) {
            Context::instances++;
        }
        return rv;
    }

Here is the call graph for this function:

operator delete()

static void Context::operator delete ( void *  ptr )

static

                                           {
        Context::instances--;
        mem_free(ptr);
    }

Here is the call graph for this function:

fill_request_buffer()

err_t Context::fill_request_buffer

(

const struct pbuf *

p

)

Append pbuf to request_buffer.

                                                       {
    if (request_buffer == nullptr) {
        /* TODO: alloacate onle part for non parsed data
           for example, if 500 bytes are parsed, allocat only
           MAX_HTTP_REQUEST - 500*/
        request_buffer = reinterpret_cast<char *>(mem_malloc(MAX_HTTP_REQUEST));
        if (request_buffer == nullptr) {
            return ERR_MEM;
        }
    }
    for (auto it = p; it != nullptr; it = it->next) {
        uint16_t len = it->len;
        if (request_buffer_size + len > MAX_HTTP_REQUEST) {
            len = MAX_HTTP_REQUEST - request_buffer_size;
        }
        std::strncpy(request_buffer + request_buffer_size,
            reinterpret_cast<char *>(it->payload), len);
        request_buffer_size += len;
    }
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_eoh()

size_t Context::find_eoh	(	const void *	data = nullptr,
		size_t	length = 0
	)

Try to find End Of Header (\r
\r
) in buffer.

Returns

position in data of \r
\r
. Return value can't be less then MINIMAL_REQUEST_LENGTH. If EOH sequence is not found, zero is returned.

                                                        {
    if (data == nullptr) {
        data = request_buffer;
        length = request_buffer_size;
    }
 
    // skip minimal request length
    for (size_t i = MINIMAL_REQUEST_LENGTH; i < (length - 3); i++) {
        if (!std::memcmp(memshift(data, i), CRLF CRLF, 4)) {
            return i + 3;
        }
    }
    return 0;
}

Here is the caller graph for this function:

parse_request()

err_t Context::parse_request	(	const void *	data = nullptr,
		size_t	length = 0
	)

parste the request header (request line + request headers)

Parse and set request method and uri from input buffer.

                                                            {
    if (request_buffer != nullptr) {
        data = request_buffer;
        length = request_buffer_size;
    }
 
    const void *end = std::memchr(data, '\n', length);
    if (end == nullptr || chrshift(end, -1)[0] != '\r') { // end of line not found
        return ERR_VAL;
    }
 
    if (parse_request_line(data, memlen(data, end)) != ERR_OK) {
        return ERR_VAL;
    }
 
    length -= memlen(data, end);
    const void *start = memshift(end, 1);
    end = std::memchr(start, '\n', length);
 
    while (end != nullptr) {
        if (chrshift(end, -1)[0] != '\r') {
            return ERR_VAL;
        }
 
        // EOH detected
        if (memlen(start, end) == 2 && (!std::memcmp(start, CRLF, 2))) {
            return ERR_OK;
        }
 
        if (parse_header(start, memlen(start, end)) != ERR_OK) {
            return ERR_VAL;
        }
        length -= memlen(start, end);
        start = memshift(end, 1);
        end = std::memchr(start, '\n', length);
    }
 
    // EOH not found, that is error
    return ERR_VAL;
}

Here is the caller graph for this function:

prepare_response()

err_t Context::prepare_response

(

)

Process message.response to internal buffer.

                                {
    // HTTP/1.0\ 200 OK\r\n\0
    size_t size = strlen(HTTP_10) + strlen(message.response) + 4;
    // TODO: check size
    if (buffer != nullptr) {
        mem_free(buffer); // repet call of this method could be possible
    }
 
    buffer = reinterpret_cast<char *>(mem_calloc(size, sizeof(char)));
    if (buffer == nullptr) {
        // no nullptr to response means try to prepare response in next call
        return ERR_MEM;
    }
    snprintf(buffer, size, "%s %s\r\n", HTTP_10, message.response);
    message.response = nullptr;
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_header()

err_t Context::prepare_header

(

)

Process message.headers to internal buffer.

                              {
    const IHeader *header = message.headers;
    size_t size = header->length() + 2; // + \r\n when it is last header
    // TODO: check size
    if (buffer != nullptr) {
        mem_free(buffer); // repet call of this method could be possible
    }
 
    buffer = reinterpret_cast<char *>(mem_calloc(size, sizeof(char)));
    if (buffer == nullptr) {
        return ERR_MEM; // no memmory yet
    }
 
    header->snprintf(buffer);
    if (header->next == nullptr) {
        buffer[size - 3] = '\r';
        buffer[size - 2] = '\n';
        buffer[size - 1] = '\0';
    }
    message.headers = header->next;
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

free_buffer()

void Context::free_buffer

(

)

                              {
        lwsapi_free(buffer);
    }

Here is the caller graph for this function:

Member Data Documentation

pcb

struct tcp_pcb* Context::pcb

retries

uint8_t Context::retries

state

State Context::state

env

Environment Context::env

Request WSAPI environment

message

Message_t Context::message

Last message returned from application

buffer

char* Context::buffer

Buffer for internal output data

m_position

size_t Context::m_position

Position of data in last message which is write not yet.

end_of_header

size_t Context::end_of_header

response

IResponse::unique_ptr_t Context::response

Response object with generator function.