bool BaseHTTPProtocol::HandleFixedLengthContent(IOBuffer &buffer) {
//1. Compute the chunk size that we areg going to read
//which is how many bytes we have available, but no more than _contentLength
uint32_t chunkSize = GETAVAILABLEBYTESCOUNT(buffer);
o_assert(_sessionDecodedBytesCount <= _contentLength);
uint32_t remaining = _contentLength - _sessionDecodedBytesCount;
chunkSize = chunkSize > remaining ? remaining : chunkSize;
//2. Update the session decoded bytes count and decoded bytes count
_sessionDecodedBytesCount += chunkSize;
_decodedBytesCount += chunkSize;
//3. Make the copy and ignore the chunk size
_inputBuffer.ReadFromBuffer(GETIBPOINTER(buffer), chunkSize);
buffer.Ignore(chunkSize);
//3. Call the near protocol
if (!_pNearProtocol->SignalInputData(_inputBuffer)) {
FATAL("Unable to call the next protocol in stack");
return false;
}
//4. reset the state if necessary
if (TransferCompleted()) {
_headers.Reset();
_contentLength = 0;
_chunkedContent = false;
_lastChunk = false;
_state = HTTP_STATE_HEADERS;
_sessionDecodedBytesCount = 0;
}
//5. we are done
return true;
}
void AsyncUsbReceiver::TransferComplete(struct libusb_transfer *transfer) {
if (transfer != m_transfer) {
OLA_WARN << "Mismatched libusb transfer: " << transfer << " != "
<< m_transfer;
return;
}
if (transfer->status != LIBUSB_TRANSFER_COMPLETED &&
transfer->status != LIBUSB_TRANSFER_TIMED_OUT ) {
OLA_WARN << "Transfer returned " << transfer->status;
}
ola::thread::MutexLocker locker(&m_mutex);
m_transfer_state = (transfer->status == LIBUSB_TRANSFER_NO_DEVICE ?
DISCONNECTED : IDLE);
if (m_suppress_continuation) {
return;
}
if (transfer->status != LIBUSB_TRANSFER_TIMED_OUT) {
if (TransferCompleted(&m_rx_buffer, transfer->actual_length)) {
// Input changed
if (m_receive_callback.get()) {
m_plugin_adaptor->Execute(m_receive_callback.get());
}
}
}
// Start next request
PerformTransfer();
}
string BaseHTTPProtocol::DumpState() {
string result = "";
result += _state == HTTP_STATE_HEADERS ? "HTTP_STATE_HEADERS\n" : "HTTP_STATE_PAYLOAD\n";
result += format("_chunkedContent: %hhu\n", _chunkedContent);
result += format("_lastChunk: %hhu\n", _lastChunk);
result += format("_contentLength: %u\n", _contentLength);
result += format("_sessionDecodedBytesCount: %u\n", _sessionDecodedBytesCount);
result += format("_decodedBytesCount: %u\n", _decodedBytesCount);
result += format("_disconnectAfterTransfer: %hhu\n", _disconnectAfterTransfer);
result += format("TransferCompleted(): %hhu\n", TransferCompleted());
result += format("_headers:\n%s\n", STR(_headers.ToString()));
result += format("_outputBuffer:\n%s\n", STR(_outputBuffer));
result += format("_inputBuffer:\n%s", STR(_inputBuffer));
return result;
}
bool BaseHTTPProtocol::HandleChunkedContent(IOBuffer &buffer) {
//2. We cycle until we don't have any complete chunks anymore
//or we hit the 0 bytes chunks (end of chunked content)
uint8_t *pBuffer = NULL;
uint32_t chunkSize = 0;
uint32_t chunkSizeSize = 0;
while (GETAVAILABLEBYTESCOUNT(buffer) >= 3) {
//1. Get the raw pointer. We need it almost everywhere
pBuffer = GETIBPOINTER(buffer);
//FINEST("%s", STR(buffer));
chunkSizeSize = 0;
//3. Read the string which represents the number of bytes in the chunk
for (uint32_t i = 0; i < GETAVAILABLEBYTESCOUNT(buffer) - 1; i++) {
//5. Are we at the end of chunk size string?
if ((pBuffer[i] == 0x0d) && (pBuffer[i + 1] == 0x0a)) {
chunkSizeSize = i + 2;
break;
}
//4. If the chunk size string has more than 10 bytes, we drop it like
//is hot! Also test each char to be a hex number.
//This is a bogus request/response
if (i >= 10 || (!(((pBuffer[i] >= '0') && (pBuffer[i] <= '9'))
|| ((pBuffer[i] >= 'a') && (pBuffer[i] <= 'f'))
|| ((pBuffer[i] >= 'A') && (pBuffer[i] <= 'F'))))) {
FATAL("Unable to read chunk size length:\n%s", STR(buffer));
return false;
}
}
//7. Test the newly extracted chunk size
if (chunkSizeSize == 0) {
return true;
}
//8. Get its actual value and test it as well
chunkSize = strtol((char *) pBuffer, NULL, 16);
if (chunkSize > HTTP_MAX_CHUNK_SIZE) {
FATAL("Chunk size too large. Maximum allowed is %" PRIu32 " and we got %" PRIu32,
(uint32_t) HTTP_MAX_CHUNK_SIZE, chunkSize);
return false;
}
//9. Now, we know the chunk size... do we have enough data?
if (GETAVAILABLEBYTESCOUNT(buffer) <
chunkSizeSize //length of the chunk size string
- 2 //substract the 0x particle
+ 2 //the \r\n that follows the chunk size string
+ chunkSize //chunk size itself
+ 2 //the \r\n that follows the data chunk
) {
return true;
}
//10. Update the session decoded bytes count and decoded bytes count
_sessionDecodedBytesCount += chunkSize;
_decodedBytesCount += chunkSize;
if (chunkSize != 0) {
//11. Make the copy
_contentLength += chunkSize;
_inputBuffer.ReadFromBuffer(GETIBPOINTER(buffer) + chunkSizeSize - 2 + 2, chunkSize);
} else {
//12. This was the last chunk (0 bytes size)
_lastChunk = true;
}
//12. Call the near protocol
if (!_pNearProtocol->SignalInputData(_inputBuffer)) {
FATAL("Unable to call the next protocol in stack");
return false;
}
//13. Ignore the bytes from the input buffer
DEBUG_HTTP("available bytes before ignore: %" PRIu32, GETAVAILABLEBYTESCOUNT(buffer));
// if (GETAVAILABLEBYTESCOUNT(buffer) == ((uint32_t) chunkSizeSize - 2 + 2 + chunkSize + 2)) {
// DEBUG_HTTP("%s", STR(buffer));
// }
buffer.Ignore((uint32_t) chunkSizeSize - 2 + 2 + chunkSize + 2);
DEBUG_HTTP("available bytes after ignore: %" PRIu32, GETAVAILABLEBYTESCOUNT(buffer));
//14. reset the state if necessary
if (TransferCompleted()) {
_headers.Reset();
_chunkedContent = false;
_lastChunk = false;
_contentLength = 0;
_state = HTTP_STATE_HEADERS;
_sessionDecodedBytesCount = 0;
return true;
}
}
return true;
}