ConnectionContext * con,

HTTPHeaders * headers,

HTTPNode * resolvedNode,

std::string method,

ResourceParameters * params,

std::string requestString):

_con(con),

_headers(headers),

_resolvedNode(resolvedNode),

_method(method),

_params(params),

_requestString(requestString) {

HTTPHeader * contentLength = headers->get("Content-Length");

if (contentLength == NULL) {

_remainingContent = 0;

_contentLengthSet = false;

} else {

_remainingContent = parseInt(contentLength->_value);

_contentLengthSet = true;

}

HTTPHeader * h = _headers->get(name);

if (h != NULL) {

return h->_value;

} else {

return std::string();

}

// Limit reading to content length

if (_contentLengthSet && length > _remainingContent) {

length = _remainingContent;

}

size_t bytesRead = 0;

if (length > 0) {

bytesRead = _con->readBuffer(buffer, length);

}

if (_contentLengthSet) {

_remainingContent -= bytesRead;

}

return bytesRead;

if (_contentLengthSet) {

// If we have a content size, rely on it.

return (_remainingContent == 0);

} else {

// If there is no more input...

return (_con->pendingBufferSize() == 0);

}

byte buf[16];

while(!requestComplete()) {

readBytes(buf, 16);

}

std::string token = decodeBasicAuthToken();

size_t splitpoint = token.find(":");

if (splitpoint != std::string::npos && splitpoint > 0) {

return token.substr(0, splitpoint);

} else {

return std::string();

}

std::string token = decodeBasicAuthToken();

size_t splitpoint = token.find(":");

if (splitpoint != std::string::npos && splitpoint > 0) {

return token.substr(splitpoint+1);

} else {

return std::string();

}

std::string basicAuthString = getHeader("Authorization");

// Get the length of the token

size_t sourceLength = basicAuthString.length();

// Only handle basic auth tokens

if (basicAuthString.substr(0, 6) != "Basic ") {

return std::string();

}

// If the token is too long, skip

if (sourceLength > 100) {

return std::string();

} else {

// Try to decode. As we are using mbedtls anyway, we can use that function

unsigned char * bufOut = new unsigned char[basicAuthString.length()];

size_t outputLength = 0;

int res = mbedtls_base64_decode(

bufOut,

sourceLength,

&outputLength,

((const unsigned char *)basicAuthString.substr(6).c_str()), // Strip "Basic "

sourceLength - 6 // Strip "Basic "

);

// Failure of decoding

if (res != 0) {

delete[] bufOut;

return std::string();

}

std::string tokenRes = std::string((char*)bufOut, outputLength);

delete[] bufOut;

return tokenRes;

}