connect.cpp File Reference

#include "lwsapi_app.hpp"
#include "http_states.h"
#include "dbg.h"
#include <cstring>
#include <cstdarg>
#include "../Marlin/src/module/temperature.h"
#include "res/cc/index_html.c"
#include "res/cc/index_css.c"
#include "res/cc/index_js.c"
#include "res/cc/favicon_ico.c"
#include "res/cc/connect_black_svg.c"
#include "res/cc/status_filament_svg.c"
#include "res/cc/status_heatbed_svg.c"
#include "res/cc/status_nozzle_svg.c"
#include "res/cc/status_prnflow_svg.c"
#include "res/cc/status_prnspeed_svg.c"
#include "res/cc/status_z_axis_svg.c"
#include "res/cc/under_construction_gif.c"

Classes
struct	header_factory_t
struct	FileHandler_t
	File handler structure. More...
class	FileResponse
	Class to response any static files defined in files array. More...
class	BufferResponse
	Universal response class with internal buffer size by BUFFER_RESPONSE_SIZE. More...
class	WaitResponse

Macros
#define	LAST_MODIFY   __TIMESTAMP__
#define	BUFFER_RESPONSE_SIZE   256

Enumerations
enum	State_t { FIRST, NEXT, DONE }
	Response state enumeration. More...

Functions
IResponse::unique_ptr_t	api_job (Environment &env)
	return coroutine_fn for /api/job request More...
IResponse::unique_ptr_t	api_printer (Environment &env)
	return coroutine_fn for /api/printer request More...
IResponse::unique_ptr_t	api_post (Environment &env)
	return 200 OK when file is post right More...
IResponse::unique_ptr_t	not_found (Environment &env)
	return coroutine_fn for Not Found response More...
IHeader *	request_header (const char *key, size_t key_length, const char *value, size_t value_length)
	request_header_fn callbacke, which is call from LwIP WSAPI http server More...
IResponse::unique_ptr_t	application (Environment &env)
	application_fn callback, which is called from LwIP WSAPI http server More...

Variables
const header_factory_t	req_headers []
static const FileHandler_t	files []
	Array of files which could be responed by http. More...

Macro Definition Documentation

LAST_MODIFY

#define LAST_MODIFY   __TIMESTAMP__

BUFFER_RESPONSE_SIZE

#define BUFFER_RESPONSE_SIZE   256

Enumeration Type Documentation

State_t

enum State_t

Response state enumeration.

Enumerator
FIRST	First coroutine_fn call after creation
NEXT	Any other coroutine_fn call while all data is not sent
DONE	Last coroutine_fn call, coroutine_fn must delete response object

             {
    FIRST, /**< First coroutine_fn call after creation */
    NEXT, /**< Any other coroutine_fn call while all data is not sent */
    DONE /**< Last coroutine_fn call, coroutine_fn must delete response
                     object */
};

Function Documentation

api_job()

IResponse::unique_ptr_t api_job

(

Environment &

env

)

return coroutine_fn for /api/job request

Function create BufferResponse object, set its pointer to arg and return buffer_coroutine.

                                                {
    std::unique_ptr<BufferResponse> res(new BufferResponse());
    if (res.get() != nullptr) {
        res->response = HTTP_200;
        res->ct_header.value = "application/json";
        res->printf("{}");
    }
    return std::move(res);
}

Here is the caller graph for this function:

api_printer()

IResponse::unique_ptr_t api_printer

(

Environment &

env

)

return coroutine_fn for /api/printer request

Function create BufferResponse object, set its pointer to arg and return buffer_coroutine.

                                                    {
    std::unique_ptr<BufferResponse> res(new BufferResponse());
    if (res.get() != nullptr) {
        res->response = HTTP_200;
        res->ct_header.value = "application/json";
 
#ifndef TEST_INTEGRITY
        float actual_nozzle = thermalManager.degHotend(0);
        float target_nozzle = thermalManager.degTargetHotend(0);
        float actual_heatbed = thermalManager.degBed();
        float target_heatbed = thermalManager.degTargetBed();
#else
        float actual_nozzle = 26;
        float target_nozzle = 32;
        float actual_heatbed = 55;
        float target_heatbed = 16;
#endif
 
        res->printf(
            "{\"temperature\":{"
            "\"tool0\":{\"actual\":%f, \"target\":%f},"
            "\"bed\":{\"actual\":%f, \"target\":%f}}}",
            static_cast<double>(actual_nozzle), static_cast<double>(target_nozzle),
            static_cast<double>(actual_heatbed), static_cast<double>(target_heatbed));
    }
    return std::move(res);
}

Here is the call graph for this function:

Here is the caller graph for this function:

api_post()

IResponse::unique_ptr_t api_post

(

Environment &

env

)

return 200 OK when file is post right

                                                 {
    printf("Request headers:\n");
    size_t content_length = 0;
    for (auto it = env.get_headers(); it != nullptr; it = it->next) {
        char buff[80];
        it->snprintf(buff); // TODO: volitelna velikost bufferu :D
        printf(buff);
        if (!strcmp(it->key, "Content-Length")) {
            content_length = dynamic_cast<const NumberHeader *>(it)->value;
        }
    }
 
    std::unique_ptr<WaitResponse> res(new WaitResponse(content_length));
    return res;
}

Here is the caller graph for this function:

not_found()

IResponse::unique_ptr_t not_found

(

Environment &

env

)

return coroutine_fn for Not Found response

Function create BufferResponse object, set its pointer to arg and return buffer_coroutine.

                                                  {
    std::unique_ptr<BufferResponse> res(new BufferResponse());
    if (res.get() != nullptr) {
        res->response = HTTP_404;
        res->ct_header.value = "text/plain";
 
        res->printf("Not Found");
    }
    return res;
}

Here is the caller graph for this function:

request_header()

IHeader* request_header	(	const char *	key,
		size_t	key_length,
		const char *	value,
		size_t	value_length
	)

request_header_fn callbacke, which is call from LwIP WSAPI http server

                                            {
    for (size_t i = 0; i < sizeof(req_headers) / sizeof(header_factory_t); i++) {
        if (!std::strncmp(req_headers[i].key, key, key_length)) {
            return req_headers[i].factory(req_headers[i].key, value, value_length);
        }
    }
    return nullptr;
}

application()

IResponse::unique_ptr_t application

(

Environment &

env

)

application_fn callback, which is called from LwIP WSAPI http server

Define of application functions.

Parameters

env	request environment defined in lwsapi.h
arg	pointer to pointer to internal application reqeust object. This pointer is argument of coroutine_fn funtcions.

Returns

coroutine_fn for response

                                                    {
 
    _dbg("HTTP Request: %s %s", env.method, env.request_uri);
 
    if (!strcmp(env.method, "GET") || !strcmp(env.method, "HEAD")) {
        // Static files
        for (size_t i = 0; i < (sizeof(files) / sizeof(FileHandler_t)); i++) {
            if (!strcmp(env.request_uri, files[i].file_name)) {
                return std::unique_ptr<FileResponse>(new FileResponse(&files[i]));
            }
        }
 
        if (!strcmp(env.request_uri, "/api/job")) {
            return api_job(env);
        } else if (!strcmp(env.request_uri, "/api/printer")) {
            return api_printer(env);
        }
    } else if (!strcmp(env.method, "POST")) {
        if (!strcmp(env.request_uri, "/post")) {
            return api_post(env);
        }
    }
    return not_found(env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

req_headers

const header_factory_t req_headers[]

Initial value:

= {
    { "Host", &dynamics_header_factory },
    { "Content-Type", &dynamics_header_factory },
    { "Content-Length", &number_header_factory },
}

files

const FileHandler_t files[]

static

Initial value:

= {
    { "/", "text/html", sizeof(index_html), index_html },
    { "/index.css", "text/css", sizeof(index_css), index_css },
    { "/index.js", "application/javasript", sizeof(index_js), index_js },
    { "/favicon.ico", "image/x-icon", sizeof(favicon_ico), favicon_ico },
    { "/connect_black.svg", "image/svg+xml", sizeof(connect_black_svg),
        connect_black_svg },
    { "/status_filament.svg", "image/svg+xml", sizeof(status_filament_svg),
        status_filament_svg },
    { "/status_heatbed.svg", "image/svg+xml", sizeof(status_heatbed_svg),
        status_heatbed_svg },
    { "/status_nozzle.svg", "image/svg+xml", sizeof(status_nozzle_svg),
        status_nozzle_svg },
    { "/status_prnflow.svg", "image/svg+xml", sizeof(status_prnflow_svg),
        status_prnflow_svg },
    { "/status_prnspeed.svg", "image/svg+xml", sizeof(status_prnspeed_svg),
        status_prnspeed_svg },
    { "/status_z_axis.svg", "image/svg+xml", sizeof(status_z_axis_svg),
        status_z_axis_svg },
    { "/under_construction.gif", "image/gif", sizeof(under_construction_gif),
        under_construction_gif },
}

Array of files which could be responed by http.