_con(con) {

// Default status code is 200 OK

_statusCode = 200;

_statusText = "OK";

_headerWritten = false;

_isError = false;

_responseCacheSize = con->getCacheSize();

_responseCachePointer = 0;

if (_responseCacheSize > 0) {

HTTPS_LOGD("Creating buffered response, size: %d", _responseCacheSize);

_responseCache = new byte[_responseCacheSize];

} else {

HTTPS_LOGD("Creating non-buffered response");

_responseCache = NULL;

}

HTTPHeader * h = _headers.get(name);

if (h != NULL) {

return h->_value;

} else {

return std::string();

}

if (isResponseBuffered()) {

drainBuffer();

}

if(!isResponseBuffered()) {

printHeader();

}

return writeBytesInternal(buffer, size);

if(!isResponseBuffered()) {

printHeader();

}

byte ba[] = {b};

return writeBytesInternal(ba, 1);

if (!_headerWritten) {

HTTPS_LOGD("Printing headers");

// Status line, like: "HTTP/1.1 200 OK\r\n"

std::string statusLine = "HTTP/1.1 " + intToString(_statusCode) + " " + _statusText + "\r\n";

printInternal(statusLine, true);

// Each header, like: "Host: myEsp32\r\n"

std::vector<HTTPHeader *> * headers = _headers.getAll();

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

printInternal((*header)->print()+"\r\n", true);

}

printInternal("\r\n", true);

_headerWritten=true;

}

if (!_isError) {

if (isResponseBuffered() && !skipBuffer) {

// We are buffering ...

if(length <= _responseCacheSize - _responseCachePointer) {

// ... and there is space left in the buffer -> Write to buffer

size_t end = _responseCachePointer + length;

size_t i = 0;

while(_responseCachePointer < end) {

_responseCache[_responseCachePointer++] = ((byte*)data)[i++];

}

// Returning skips the SSL_write below

return length;

} else {

// .., and the buffer is too small. This is the point where we switch from

// caching to streaming

if (!_headerWritten) {

setHeader("Connection", "close");

}

drainBuffer(true);

}

}

return _con->writeBuffer((byte*)data, length);

} else {

return 0;

}

if (!_headerWritten) {

if (_responseCache != NULL && !onOverflow) {

_headers.set(new HTTPHeader("Content-Length", intToString(_responseCachePointer)));

}

printHeader();

}

if (_responseCache != NULL) {

HTTPS_LOGD("Draining response buffer");

// Check for 0 as it may be an overflow reaction without any data that has been written earlier

if(_responseCachePointer > 0) {

// FIXME: Return value?

_con->writeBuffer((byte*)_responseCache, _responseCachePointer);

}

delete[] _responseCache;

_responseCache = NULL;

}