#include "HTTPConnection.hpp"

#include "Websocket.hpp"

#include <hwcrypto/sha.h>

namespace httpsserver {

_isKeepAlive = false;

_lastTransmissionTS = millis();

_shutdownTS = 0;

_websocket = nullptr;

}

HTTPConnection::~HTTPConnection() {

}

if (_httpHeaders != NULL) {

HTTPS_DLOG("[ ] Free headers");

delete _httpHeaders;

_httpHeaders = NULL;

}

return (_isKeepAlive ? HTTPS_KEEPALIVE_CACHESIZE : 0);

}

void HTTPConnection::setWebsocketHandler(WebsocketHandler *wsHandler) {

_wsHandler = wsHandler;

}

void HTTPConnection::loop() {

// First, update the buffer

// newByteCount will contain the number of new bytes that have to be processed

_parserLine.text.substr(0, idxColon),

_parserLine.text.substr(idxColon+2)

));

HTTPS_DLOG(("[ ] Header: " + _parserLine.text.substr(0, idxColon) + ":" + _parserLine.text.substr(idxColon+2)).c_str());

} else {

HTTPS_DLOG("Malformed header line detected. Client error.");

HTTPS_DLOG(_parserLine.text.c_str());

_isKeepAlive = false;

}

// do we have a websocket connection?

if(checkWebsocket()) {

// Create response

HTTPResponse res = HTTPResponse(this);

// Add default headers to the response

auto allDefaultHeaders = _defaultHeaders->getAll();

for(std::vector<HTTPHeader*>::iterator header = allDefaultHeaders->begin(); header != allDefaultHeaders->end(); ++header) {

res.setHeader((*header)->_name, (*header)->_value);

}

// Set the response status

res.setStatusCode(101);

res.setStatusText("Switching Protocols");

res.setHeader("Upgrade", "websocket");

res.setHeader("Connection", "Upgrade");

res.setHeader("Sec-WebSocket-Accept", websocketKeyResponseHash(_httpHeaders->getValue("Sec-WebSocket-Key")));

res.print("");

// Callback for the actual resource

HTTPSCallbackFunction * resourceCallback = resolvedResource.getMatchingNode()->_callback;

// persistent request for websocket. To be destroyed when connection closes.

HTTPRequest *req = new HTTPRequest(this, _httpHeaders, resolvedResource.getParams(), _httpResource, _httpMethod, "");

// bind function call to the actual resource

std::function<void()> next = std::function<void()>(std::bind(resourceCallback, req, nullptr));

_websocket = new Websocket(this); // make websocket with this connection

next(); // call callback

delete req;

_connectionState = STATE_WEBSOCKET;

break;

}

// Create request context

HTTPRequest req = HTTPRequest(this, _httpHeaders, resolvedResource.getParams(), _httpResource, _httpMethod, resolvedResource.getMatchingNode()->_tag);

HTTPResponse res = HTTPResponse(this);

closeConnection();

break;

case STATE_WEBSOCKET: // Do handling of the websocket

refreshTimeout(); // don't timeout websocket connection

if(pendingBufferSize() > 0) {

HTTPS_DLOG("[ ] websocket handler");

if(_websocket->read() < 0) {

_websocket->close();

delete _websocket;

_httpHeaders->clearAll();

_connectionState = STATE_CLOSING;

}

}

//readBuffer();

break;

default:;

}

}

}

bool HTTPConnection::checkWebsocket() {

// check criteria according to RFC6455

if(_httpMethod == "GET" &&

!_httpHeaders->getValue("Host").empty() &&

_httpHeaders->getValue("Upgrade") == "websocket" &&

_httpHeaders->getValue("Connection").find("Upgrade") != std::string::npos &&

!_httpHeaders->getValue("Sec-WebSocket-Key").empty() &&

_httpHeaders->getValue("Sec-WebSocket-Version") == "13") {

HTTPS_DLOG("[-->] Websocket detected");

return true;

} else

return false;

}

std::string HTTPConnection::websocketKeyResponseHash(std::string key) {

std::string newKey = key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";

uint8_t shaData[20];

esp_sha(SHA1, (uint8_t*)newKey.data(), newKey.length(), shaData);

//GeneralUtils::hexDump(shaData, 20);

std::string retStr;

base64Encode(std::string((char*)shaData, sizeof(shaData)), &retStr);

return retStr;

} // WebsocketKeyResponseHash

} /* namespace httpsserver */

#include "ResourceNode.hpp"

#include "HTTPRequest.hpp"

#include "HTTPResponse.hpp"

#include "ConnectionContext.hpp"

namespace httpsserver {

class Websocket;

class HTTPConnection : private ConnectionContext {

friend class Websocket;

HTTPConnection(ResourceResolver * resResolver);

virtual ~HTTPConnection();

void loop();

bool isClosed();

bool isError();

void setWebsocketHandler(WebsocketHandler *wsHandler);

friend class HTTPRequest;

friend class HTTPResponse;

friend class WebsocketInputStreambuf;

virtual size_t writeBuffer(byte* buffer, size_t length);

virtual size_t readBytesToBuffer(byte* buffer, size_t length);

void signalRequestError();

size_t readBuffer(byte* buffer, size_t length);

size_t getCacheSize();

bool checkWebsocket();

std::string websocketKeyResponseHash(std::string key);

// The receive buffer

char _receiveBuffer[HTTPS_CONNECTION_DATA_CHUNK_SIZE];

// Should we use keep alive

bool _isKeepAlive;

//Websocket connection

WebsocketHandler * _wsHandler;

Websocket * _websocket;

};

return NULL;

}

std::string HTTPHeaders::getValue(std::string name) {

for(std::vector<HTTPHeader*>::iterator header = _headers->begin(); header != _headers->end(); ++header) {

if ((*header)->_name.compare(name)==0) {

return ((*header)->_value);

}

}

return "";

}

void HTTPHeaders::set(HTTPHeader * header) {

for(int i = 0; i < _headers->size(); i++) {

if ((*_headers)[i]->_name.compare(header->_name)==0) {

virtual ~HTTPHeaders();

HTTPHeader * get(std::string name);

std::string getValue(std::string name);

void set(HTTPHeader * header);

std::vector<HTTPHeader *> * getAll();

#include "HTTPSCallbackFunction.hpp"

namespace httpsserver {

class HTTPRequest;

/**

}

HTTPRequest::~HTTPRequest() {

}

return _con->isSecure();

}

void HTTPRequest::setWebsocketHandler(WebsocketHandler *wsHandler) {

_con->setWebsocketHandler(wsHandler);

}

} /* namespace httpsserver */

std::string getBasicAuthUser();

std::string getBasicAuthPassword();

bool isSecure();

void setWebsocketHandler(WebsocketHandler *wsHandler);

std::string decodeBasicAuthToken();

if (_responseCache != NULL) {

delete[] _responseCache;

}

_headers.clearAll();

}

void HTTPResponse::setStatusCode(uint16_t statusCode) {

#include "Arduino.h"

#define HTTPS_DLOG(X) Serial.print(millis());Serial.print(" HTTPSServer->debug: ");Serial.println(X);

#define HTTPS_DLOGHEX(X,Y) Serial.print(millis());Serial.print(" HTTPSServer->debug: ");Serial.print(X);Serial.print(" 0x");Serial.println(Y, HEX);

#define HTTPS_DLOGINT(X,Y) Serial.print(millis());Serial.print(" HTTPSServer->debug: ");Serial.print(X);Serial.println(Y);