| /* ------------------------------------------------------------------ |
| * Copyright (C) 1998-2009 PacketVideo |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either |
| * express or implied. |
| * See the License for the specific language governing permissions |
| * and limitations under the License. |
| * ------------------------------------------------------------------- |
| */ |
| #include "http_parser.h" |
| #include "http_parser_internal.h" |
| #include "oscl_string_utils.h" |
| #include "oscl_string_containers.h" |
| |
| // Use default DLL entry point for Symbian |
| #include "oscl_dll.h" |
| |
| OSCL_DLL_ENTRY_POINT_DEFAULT() |
| |
| |
| // three inline functions for multiple class implementation |
| inline bool isLetter(const char c) |
| { |
| return ((c >= 65 && c <= 90) || (c >= 97 && c <= 122) || (c == 45)); // A-Z, or a-z or - |
| } |
| |
| inline bool isDigit(const char c) |
| { |
| return (c >= 48 && c <= 57); |
| } |
| |
| inline bool isHexDigit(const char c) |
| { |
| return (isDigit(c) || (c >= 65 && c <= 70) || (c >= 97 && c <= 102)); // 0-9, A-F or a-f |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| ////// HTTPParser implementation /////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////////// |
| |
| OSCL_EXPORT_REF int32 HTTPParser::parse(const OsclRefCounterMemFrag &aInputDataStream, RefCountHTTPEntityUnit &aEntityUnit) |
| { |
| if (!iParserInput->push_back((OsclRefCounterMemFrag &)aInputDataStream)) // not a new data fragment |
| return PARSE_NEED_MORE_DATA; |
| |
| if (!aEntityUnit.empty()) aEntityUnit.clear(); |
| if (!iHeader->isParsed()) return iHeader->parse(*iParserInput, aEntityUnit); |
| |
| return parseEntityBody(aEntityUnit); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| OSCL_EXPORT_REF int32 HTTPParser::doSanityCheckForResponseHeader() |
| { |
| if (!iHeader->isParsed()) return PARSE_HEADER_NOT_PARSED_YET; |
| return iHeader->doSanityCheckForResponseHeader(); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| // assume aFieldKeyList has enough space to hold all parsed key list, if it is small, it will cause crash |
| // since we have no way to check the space |
| OSCL_EXPORT_REF uint32 HTTPParser::getFieldKeyListInHeader(StrPtrLen *&aFieldKeyList) |
| { |
| return iHeader->getKeyValuesStore()->getCurrentKeyList(aFieldKeyList); // iHeader should be created successfully in factory method |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| OSCL_EXPORT_REF bool HTTPParser::getField(const StrCSumPtrLen &aNewFieldName, StrPtrLen &aNewFieldValue, uint32 index) |
| { |
| return iHeader->getField(aNewFieldName, aNewFieldValue, index); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| OSCL_EXPORT_REF uint32 HTTPParser::getNumberOfFieldsByKey(const StrCSumPtrLen &aNewFieldName) |
| { |
| return iHeader->getNumberOfFieldsByKey(aNewFieldName); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| OSCL_EXPORT_REF uint32 HTTPParser::getTotalFieldsInHeader() |
| { |
| return iHeader->getNumFields(); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| OSCL_EXPORT_REF uint32 HTTPParser::getHTTPStatusCode() |
| { |
| return iHeader->getStatusCode(); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| OSCL_EXPORT_REF void HTTPParser::getContentInfo(HTTPContentInfo &aContentInfo) |
| { |
| aContentInfo.clear(); |
| if (iContentInfo) iContentInfo->get(aContentInfo); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| // reset the parser to parse a new HTTP response |
| OSCL_EXPORT_REF void HTTPParser::reset() |
| { |
| if (iParserInput) iParserInput->clear(); |
| if (iContentInfo) iContentInfo->clear(); |
| if (iHeader) iHeader->reset(); |
| |
| // delete iEntityBody |
| if (iEntityBody) OSCL_DELETE(iEntityBody); |
| iEntityBody = NULL; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| // factory method |
| OSCL_EXPORT_REF HTTPParser* HTTPParser::create() |
| { |
| HTTPParser *parser = OSCL_NEW(HTTPParser, ()); |
| if (!parser) return NULL; |
| if (!parser->construct()) |
| { |
| OSCL_DELETE(parser); |
| return NULL; |
| } |
| return parser; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| bool HTTPParser::construct() |
| { |
| reset(); |
| |
| // create the component objects |
| if ((iContentInfo = OSCL_NEW(HTTPContentInfoInternal, ())) == NULL) return false; |
| if ((iParserInput = HTTPParserInput::create()) == NULL) return false; |
| if ((iHeader = HTTPParserHeaderObject::create(iContentInfo)) == NULL) return false; |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| // destructor |
| OSCL_EXPORT_REF HTTPParser::~HTTPParser() |
| { |
| reset(); |
| |
| // delete iParserInput |
| if (iParserInput) OSCL_DELETE(iParserInput); |
| iParserInput = NULL; |
| |
| // delete iContentInfo |
| if (iContentInfo) OSCL_DELETE(iContentInfo); |
| iContentInfo = NULL; |
| |
| // delete iHeader |
| if (iHeader) OSCL_DELETE(iHeader); |
| iHeader = NULL; |
| |
| // delete iEntityBody |
| if (iEntityBody) OSCL_DELETE(iEntityBody); |
| iEntityBody = NULL; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| int32 HTTPParser::parseEntityBody(RefCountHTTPEntityUnit &aEntityUnit) |
| { |
| if (!iHeader || !iHeader->isParsed()) return PARSE_HEADER_NOT_PARSED_YET; |
| if (iHeader->isWholeResponseParsed()) return PARSE_SUCCESS_END_OF_MESSAGE; |
| |
| if (!iEntityBody) |
| { |
| // create iEntityBody |
| // After parsing the header, we should get right content type, iContentType |
| if (iContentInfo->getContentType() == HTTP_CONTENT_NORMAL) |
| iEntityBody = OSCL_NEW(HTTPParserNormalContentObject, (iHeader->getKeyValuesStore(), iHeader->getAllocator(), iContentInfo)); |
| else if (iContentInfo->getContentType() == HTTP_CONTENT_NULTIPART) |
| iEntityBody = OSCL_NEW(HTTPParserMultipartContentObject, (iHeader->getKeyValuesStore(), iHeader->getAllocator(), iContentInfo)); |
| else if (iContentInfo->getContentType() == HTTP_CONTENT_CHUNKED_TRANSFER_ENCODING) |
| iEntityBody = OSCL_NEW(HTTPParserCTEContentObject, (iHeader->getKeyValuesStore(), iHeader->getAllocator(), iContentInfo)); |
| |
| if (!iEntityBody) return PARSE_MEMORY_ALLOCATION_FAILURE; |
| } |
| |
| return iEntityBody->parse(*iParserInput, aEntityUnit); |
| } |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| ////////// HTTPContentInfoInternal Implementation /////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////////// |
| bool HTTPContentInfoInternal::parseContentInfo(StringKeyValueStore &aKeyValueStore) |
| { |
| // Content-Length |
| StrCSumPtrLen contenLengthKey("Content-Length"); |
| StrPtrLen contentLengthValue; |
| if (aKeyValueStore.getValueByKey(contenLengthKey, contentLengthValue)) |
| { |
| // has content length |
| PV_atoi(contentLengthValue.c_str(), 'd', iContentLength); |
| } |
| |
| // Content-Type |
| StrCSumPtrLen contentTypeKey("Content-Type"); |
| StrPtrLen contentTypeValue; |
| if (aKeyValueStore.getValueByKey(contentTypeKey, contentTypeValue)) |
| { |
| // has content type |
| if (!parseContentType(contentTypeValue)) return false; |
| } |
| |
| // Content-Range |
| StrCSumPtrLen contentRangeKey("Content-Range"); |
| StrPtrLen contentRangeValue; |
| if (aKeyValueStore.getValueByKey(contentRangeKey, contentRangeValue)) |
| { |
| // has content type |
| parseContentRange(contentRangeValue); |
| } |
| |
| // check Chunked Transfer-Encoding, "Transfer-Encoding : chunked" |
| StrCSumPtrLen transferEncodingKey("Transfer-Encoding"); |
| StrPtrLen transferEncodingValue; |
| if (aKeyValueStore.getValueByKey(transferEncodingKey, transferEncodingValue)) |
| { |
| // has content type |
| verifyTransferEncoding(transferEncodingValue); |
| } |
| return true; |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| void HTTPContentInfoInternal::parseContentRange(const StrPtrLen &aContentRange) |
| { |
| char *ptr = (char *)aContentRange.c_str(); |
| uint32 len = aContentRange.length(); |
| |
| while (!isLetter(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| OSCL_FastString bytesString(_STRLIT_CHAR("bytes")); |
| if (len <= oscl_strlen(bytesString.get_cstr())) return; |
| |
| if (((ptr[0] | OSCL_ASCII_CASE_MAGIC_BIT) == 'b') && |
| ((ptr[1] | OSCL_ASCII_CASE_MAGIC_BIT) == 'y') && |
| ((ptr[2] | OSCL_ASCII_CASE_MAGIC_BIT) == 't') && |
| ((ptr[3] | OSCL_ASCII_CASE_MAGIC_BIT) == 'e') && |
| ((ptr[4] | OSCL_ASCII_CASE_MAGIC_BIT) == 's')) |
| { |
| // find "bytes" |
| ptr += 5; |
| if ((len -= 5) <= 0) return; |
| |
| // get the left side of the range |
| while (!isDigit(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| char *start_ptr = ptr; |
| uint32 start_len = len; |
| while (isDigit(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| PV_atoi(start_ptr, 'd', start_len - len, iContentRangeLeft); |
| |
| // get the right side of the range |
| while (!isDigit(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| start_ptr = ptr; |
| start_len = len; |
| while (isDigit(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| PV_atoi(start_ptr, 'd', start_len - len, iContentRangeRight); |
| |
| // get the content length |
| while (!isDigit(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| start_ptr = ptr; |
| start_len = len; |
| while (isDigit(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| PV_atoi(start_ptr, 'd', start_len - len, iContentLength); |
| } |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| bool HTTPContentInfoInternal::parseContentType(const StrPtrLen &aContentType) |
| { |
| // identify multipart content type and chunked transfer-encoding |
| // Content-type: multipart/byteranges; boundary=THIS_STRING_SEPARATES |
| char *ptr = (char *)aContentType.c_str(); |
| uint32 len = aContentType.length(); |
| |
| // eat non-letter characters |
| while (!isLetter(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| OSCL_FastString typeString(_STRLIT_CHAR("multipart/byteranges")); |
| if (len <= oscl_strlen(typeString.get_cstr())) return true; |
| |
| if (((ptr[0] | OSCL_ASCII_CASE_MAGIC_BIT) == 'm') && |
| ((ptr[1] | OSCL_ASCII_CASE_MAGIC_BIT) == 'u') && |
| ((ptr[2] | OSCL_ASCII_CASE_MAGIC_BIT) == 'l') && |
| ((ptr[3] | OSCL_ASCII_CASE_MAGIC_BIT) == 't') && |
| ((ptr[4] | OSCL_ASCII_CASE_MAGIC_BIT) == 'i') && |
| ((ptr[5] | OSCL_ASCII_CASE_MAGIC_BIT) == 'p') && |
| ((ptr[6] | OSCL_ASCII_CASE_MAGIC_BIT) == 'a') && |
| ((ptr[7] | OSCL_ASCII_CASE_MAGIC_BIT) == 'r') && |
| ((ptr[8] | OSCL_ASCII_CASE_MAGIC_BIT) == 't') && |
| (ptr[9] == '/') && |
| ((ptr[10] | OSCL_ASCII_CASE_MAGIC_BIT) == 'b') && |
| ((ptr[11] | OSCL_ASCII_CASE_MAGIC_BIT) == 'y') && |
| ((ptr[12] | OSCL_ASCII_CASE_MAGIC_BIT) == 't') && |
| ((ptr[13] | OSCL_ASCII_CASE_MAGIC_BIT) == 'e') && |
| ((ptr[14] | OSCL_ASCII_CASE_MAGIC_BIT) == 'r') && |
| ((ptr[15] | OSCL_ASCII_CASE_MAGIC_BIT) == 'a') && |
| ((ptr[16] | OSCL_ASCII_CASE_MAGIC_BIT) == 'n') && |
| ((ptr[17] | OSCL_ASCII_CASE_MAGIC_BIT) == 'g') && |
| ((ptr[18] | OSCL_ASCII_CASE_MAGIC_BIT) == 'e') && |
| ((ptr[19] | OSCL_ASCII_CASE_MAGIC_BIT) == 's')) |
| { |
| // find "multipart/byteranges" |
| // constinue search "boundary" |
| ptr += 20; |
| if ((len -= 20) <= 8) return false; |
| |
| while (!isLetter(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| if (((ptr[0] | OSCL_ASCII_CASE_MAGIC_BIT) == 'b') && |
| ((ptr[1] | OSCL_ASCII_CASE_MAGIC_BIT) == 'o') && |
| ((ptr[2] | OSCL_ASCII_CASE_MAGIC_BIT) == 'u') && |
| ((ptr[3] | OSCL_ASCII_CASE_MAGIC_BIT) == 'n') && |
| ((ptr[4] | OSCL_ASCII_CASE_MAGIC_BIT) == 'd') && |
| ((ptr[5] | OSCL_ASCII_CASE_MAGIC_BIT) == 'a') && |
| ((ptr[6] | OSCL_ASCII_CASE_MAGIC_BIT) == 'r') && |
| ((ptr[7] | OSCL_ASCII_CASE_MAGIC_BIT) == 'y')) |
| { |
| // find "boundary" |
| ptr += 8; |
| if ((len -= 8) <= 0) return false; |
| |
| // find "=" |
| while (*ptr != HTTP_CHAR_EQUAL && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| if (len <= 0) return false; |
| ptr++; |
| |
| while ((*ptr == HTTP_CHAR_SPACE || *ptr == HTTP_CHAR_TAB) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| char *boundaryStartPtr = ptr; |
| uint32 start_len = (uint32)len; |
| while (!(*ptr == HTTP_CHAR_NULL || *ptr == HTTP_CHAR_SPACE || *ptr == HTTP_CHAR_TAB || |
| *ptr == HTTP_CHAR_CR || *ptr == HTTP_CHAR_LF) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| iContentType = HTTP_CONTENT_NULTIPART; |
| return copyBoundaryString(boundaryStartPtr, start_len - (uint32)len); |
| } |
| } |
| return true; |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| void HTTPContentInfoInternal::verifyTransferEncoding(const StrPtrLen &aTransferEncodingValue) |
| { |
| char *ptr = (char *)aTransferEncodingValue.c_str(); |
| uint32 len = aTransferEncodingValue.length(); |
| |
| // eat non-letter characters |
| while (!isLetter(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| OSCL_FastString chunkedString(_STRLIT_CHAR("chunked")); |
| if (len < oscl_strlen(chunkedString.get_cstr())) return; |
| |
| if (((ptr[0] | OSCL_ASCII_CASE_MAGIC_BIT) == 'c') && |
| ((ptr[1] | OSCL_ASCII_CASE_MAGIC_BIT) == 'h') && |
| ((ptr[2] | OSCL_ASCII_CASE_MAGIC_BIT) == 'u') && |
| ((ptr[3] | OSCL_ASCII_CASE_MAGIC_BIT) == 'n') && |
| ((ptr[4] | OSCL_ASCII_CASE_MAGIC_BIT) == 'k') && |
| ((ptr[5] | OSCL_ASCII_CASE_MAGIC_BIT) == 'e') && |
| ((ptr[6] | OSCL_ASCII_CASE_MAGIC_BIT) == 'd')) |
| { |
| // find "chunked" |
| iContentType = HTTP_CONTENT_CHUNKED_TRANSFER_ENCODING; |
| } |
| } |
| |
| bool HTTPContentInfoInternal::copyBoundaryString(const char* aBoundaryString, const uint32 aBoundaryStringLength) |
| { |
| // allocate memory for boundary string |
| if (!iBoundaryBuffer) iBoundaryBuffer = new char[aBoundaryStringLength+1]; |
| if (!iBoundaryBuffer) return false; |
| if (!aBoundaryString) return false; |
| |
| oscl_memcpy(iBoundaryBuffer, aBoundaryString, aBoundaryStringLength); |
| iBoundaryBuffer[aBoundaryStringLength] = HTTP_CHAR_NULL; |
| iBoundary.setPtrLen(iBoundaryBuffer, aBoundaryStringLength); |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////// |
| bool HTTPContentInfoInternal::parseBoudaryLine(HTTPMemoryFragment &aInputLineData, bool &isFinalBoundary) |
| { |
| isFinalBoundary = false; |
| |
| // check boundary line : --BOUNDARY STRING |
| char *ptr = (char *)aInputLineData.getPtr(); |
| int32 len = aInputLineData.getAvailableSpace(); |
| while (*ptr != HTTP_CHAR_MINUS && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| if (len <= 0) return false; // this line is not boundary line |
| if (*(++ptr) != HTTP_CHAR_MINUS) return false; // not "--" |
| ptr++; |
| len -= 2; |
| if (len < iBoundary.length()) return false; |
| char *boundaryString = (char *)iBoundary.c_str(); |
| int32 i = 0; |
| for (i = 0; i < iBoundary.length(); i++) |
| { |
| if (ptr[i] != boundaryString[i]) return false; |
| } |
| |
| // check the last "--" as the flag of final boundary string |
| ptr += iBoundary.length(); |
| len -= iBoundary.length(); |
| if (len >= 2) |
| { |
| if (*ptr == HTTP_CHAR_MINUS && *(ptr + 1) == HTTP_CHAR_MINUS) |
| { |
| isFinalBoundary = true; |
| } |
| } |
| return true; |
| } |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| ////////// HTTPParserInput Implementation /////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////////// |
| HTTPParserInput* HTTPParserInput::create() |
| { |
| HTTPParserInput *parserInput = OSCL_NEW(HTTPParserInput, ()); |
| if (!parserInput) return NULL; |
| if (!parserInput->construct()) |
| { |
| OSCL_DELETE(parserInput); |
| return NULL; |
| } |
| return parserInput; |
| } |
| |
| bool HTTPParserInput::construct() |
| { |
| // create iLineBuffer |
| OsclMemAllocator alloc; |
| iLineBuffer = (char *)alloc.allocate(iLineBufferSize); |
| if (!iLineBuffer) return false; |
| |
| int32 err = 0; |
| OSCL_TRY(err, |
| iDataInQueue.reserve(DATA_QUEUE_VECTOR_RESERVE_SIZE); |
| iDataOutQueue.reserve(DATA_QUEUE_VECTOR_RESERVE_SIZE); |
| ); |
| return (err == 0); |
| |
| } |
| |
| HTTPParserInput::~HTTPParserInput() |
| { |
| clear(); |
| iDataInQueue.clear(); |
| iDataOutQueue.clear(); |
| if (iLineBuffer) |
| { |
| OsclMemAllocator alloc; |
| alloc.deallocate(iLineBuffer); |
| iLineBuffer = NULL; |
| } |
| } |
| |
| bool HTTPParserInput::push_back(OsclRefCounterMemFrag &aFrag) |
| { |
| if (!aFrag.getMemFragPtr() || !aFrag.getRefCounter()) // empty fragment |
| { |
| return (!iDataInQueue.empty()); // true for iDataInQueue not being empty |
| } |
| |
| // check if this input is same to the previous one |
| if (!iDataInQueue.empty()) |
| { |
| if ((uint8*)aFrag.getMemFragPtr() == (uint8*)iDataInQueue[iDataInQueue.size()-1].getMemFragPtr()) |
| { |
| return true; // true for iDataInQueue not being empty |
| } |
| } |
| |
| // push into the data queue |
| int32 err = 0; |
| OSCL_TRY(err, iDataInQueue.push_back(aFrag);); |
| if (err) return false; |
| |
| return true; |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| bool HTTPParserInput::getNextCompleteLine(HTTPMemoryFragment &aHttpFrag, bool aHeaderParsed) |
| { |
| int32 offset = isNextLineAvailable(aHeaderParsed); |
| if (offset <= 0) return false; |
| aHttpFrag.bind(iHTTPMemFrag.getPtr(), offset); |
| return true; |
| } |
| |
| // aRequestDataSize==0 means no request size, the function needs to send out whatever amount of data it has, |
| // but with one input data fragment each time. |
| // return value: actual size, if aRequestDataSize > 0, actual size <= aRequestDataSize |
| // actual size = 0, => no data, -1 means error |
| int32 HTTPParserInput::getData(HTTPMemoryFragment &aHttpFrag, const uint32 aRequestDataSize) |
| { |
| if (iDataInQueue.empty()) return 0; |
| |
| uint32 requestSize = (aRequestDataSize > 0 ? aRequestDataSize : 0xffffffff); |
| uint32 availableFragSize = iDataInQueue[0].getMemFragSize() - iDataInQueueMemFragOffset; |
| uint32 actualSize = OSCL_MIN(requestSize, availableFragSize); |
| |
| if (actualSize > 0) |
| { |
| // create the output fragments |
| uint8* fragStartPtr = (uint8*)iDataInQueue[0].getMemFragPtr() + iDataInQueueMemFragOffset; |
| aHttpFrag.bind((void *)fragStartPtr, actualSize); |
| if (!constructOutputFragment(actualSize, (void *)fragStartPtr, (iDataInQueueMemFragOffset == 0))) return -1; |
| } |
| |
| // check if iDataInQueue[0] needs to be removed and update iDataInQueueMemFragOffset |
| if (availableFragSize <= requestSize) |
| { |
| iDataInQueue.erase(iDataInQueue.begin()); |
| iDataInQueueMemFragOffset = 0; |
| } |
| else |
| { |
| // updata iDataInQueueMemFragOffset |
| iDataInQueueMemFragOffset += actualSize; |
| } |
| |
| return (int32)actualSize; |
| } |
| |
| // This function is for parsing multipart content, specically for the final boundary string like --boundaryString--, which could |
| // has no "\r\n", so getNextCompleteLine may not work in this case |
| // In general, if iLineBuffer has data, then send out iLineBuffer, then check if input data queue has data, if it has, then send |
| // out the first buffer. Return false for no any data (both iLineBuffer and data queue are empty) |
| // Note that this function doesn't do "get" that means changing internal pointers, instead, only does "view" |
| bool HTTPParserInput::viewAvailableInputData(HTTPMemoryFragment &aHttpFrag) |
| { |
| if (iLineBufferOccupied == 0 && iDataInQueue.empty()) return false; |
| |
| if (iLineBufferOccupied) |
| { |
| aHttpFrag.bind(iLineBuffer, iLineBufferOccupied); |
| } |
| else // iDataInQueue is not empty |
| { |
| int32 availableFragSize = iDataInQueue[0].getMemFragSize() - iDataInQueueMemFragOffset; |
| if (availableFragSize == 0) return false; |
| uint8* fragStartPtr = (uint8*)iDataInQueue[0].getMemFragPtr() + iDataInQueueMemFragOffset; |
| aHttpFrag.bind(fragStartPtr, availableFragSize); |
| } |
| return true; |
| } |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| bool HTTPParserInput::getOutputMemFrag(OsclRefCounterMemFrag &aMemFrag) |
| { |
| if (iDataOutQueue.empty()) return false; |
| iDataOutQueue[0].getRefCountMemFrag(aMemFrag); |
| iDataOutQueue.erase(iDataOutQueue.begin()); |
| return true; |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| // pass ending CRLF |
| void HTTPParserInput::skipCRLF() |
| { |
| if (iDataInQueue.empty()) return; |
| uint8* fragStartPtr = (uint8*)iDataInQueue[0].getMemFragPtr() + iDataInQueueMemFragOffset; |
| int32 availableFragSize = iDataInQueue[0].getMemFragSize() - iDataInQueueMemFragOffset; |
| while ((*fragStartPtr == HTTP_CHAR_CR || *fragStartPtr == HTTP_CHAR_LF) && availableFragSize > 0) |
| { |
| *fragStartPtr++; |
| availableFragSize--; |
| iDataInQueueMemFragOffset++; |
| } |
| } |
| |
| // return value: 0 => not available ; >0 means the offset of the next complete line from the current point |
| // -1 error |
| int32 HTTPParserInput::isNextLineAvailable(bool aHeaderParsed) |
| { |
| if (iDataInQueue.empty()) return 0; |
| |
| while (iDataInQueue.size() > 0) |
| { |
| if (iDataInQueueMemFragOffset >= iDataInQueue[0].getMemFragSize()) |
| { |
| // remove iDataInQueue[0], since it is copied to iDataOutQueue |
| iDataInQueue.erase(iDataInQueue.begin()); |
| iDataInQueueMemFragOffset = 0; |
| iHTTPMemFrag.clear(); |
| return 0; |
| } |
| |
| bool bNewData = (iDataInQueueMemFragOffset == 0); |
| iHTTPMemFrag.bind((void *)((uint8*)iDataInQueue[0].getMemFragPtr() + iDataInQueueMemFragOffset), |
| iDataInQueue[0].getMemFragSize() - iDataInQueueMemFragOffset); |
| |
| int32 offset = checkNextLine(iHTTPMemFrag); |
| iDataInQueueMemFragOffset += offset; |
| if (offset > 0 && iLineBufferOccupied == 0) |
| { |
| // construct an output fragment |
| if (!constructOutputFragment(iDataInQueueMemFragOffset, NULL, bNewData)) return -1; |
| return offset; |
| } |
| |
| // copy to iLineBuffer to concatenate the line fragments |
| uint32 remaining_bytes = (offset > 0 ? offset : iHTTPMemFrag.getAvailableSpace()); |
| HTTPMemoryFragment aFrag(iHTTPMemFrag.getPtr(), remaining_bytes); |
| if (assemblyLineFragments(aFrag)) return -1; |
| |
| if (offset > 0) |
| { |
| iHTTPMemFrag.bind(iLineBuffer, iLineBufferOccupied); |
| if (!constructOutputFragment(iDataInQueueMemFragOffset, NULL, bNewData)) return -1; |
| iLineBufferOccupied = 0; |
| return iHTTPMemFrag.getCapacity(); |
| } |
| |
| if (!aHeaderParsed) |
| { |
| // save iDataInQueue[0] |
| if (!bNewData && !iDataOutQueue.empty()) iDataOutQueue.erase(&iDataOutQueue.back()); |
| int32 err = 0; |
| OSCL_TRY(err, iDataOutQueue.push_back(iDataInQueue[0]);); |
| if (err) return -1; |
| } |
| // remove iDataInQueue[0] |
| iDataInQueue.erase(iDataInQueue.begin()); |
| iDataInQueueMemFragOffset = 0; |
| iHTTPMemFrag.clear(); |
| } |
| |
| return 0; |
| } |
| |
| int32 HTTPParserInput::assemblyLineFragments(HTTPMemoryFragment &aFrag) |
| { |
| if (aFrag.getCapacity() <= iLineBufferSize - iLineBufferOccupied) |
| { |
| oscl_memcpy(iLineBuffer + iLineBufferOccupied, (char*)aFrag.getPtr(), aFrag.getCapacity()); |
| } |
| else |
| { |
| // realloc iLineBuffer |
| // aFrag.getCapacity()+iLineBufferOccupied>iLineBufferSize |
| iLineBufferSize = (aFrag.getCapacity() + iLineBufferOccupied) << 1; |
| |
| OsclMemAllocator alloc; |
| char *aNewLineBuffer = (char*)alloc.allocate(iLineBufferSize); |
| if (!aNewLineBuffer) return -1; |
| if (iLineBufferOccupied) oscl_memcpy(aNewLineBuffer, iLineBuffer, iLineBufferOccupied); |
| oscl_memcpy(aNewLineBuffer + iLineBufferOccupied, (char*)aFrag.getPtr(), aFrag.getCapacity()); |
| |
| // deallocate iLineBuffer |
| alloc.deallocate(iLineBuffer); |
| iLineBuffer = aNewLineBuffer; |
| } |
| iLineBufferOccupied += aFrag.getCapacity(); |
| return 0; |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| int32 HTTPParserInput::checkNextLine(HTTPMemoryFragment &aInputDataStream) |
| { |
| char *ptr = (char *)aInputDataStream.getPtr(), *start_ptr = ptr; |
| int32 streamLength = aInputDataStream.getAvailableSpace(); |
| while (streamLength > 1 && (*ptr != HTTP_CHAR_CR && *ptr != HTTP_CHAR_LF)) |
| { |
| ptr++; |
| streamLength--; |
| } |
| |
| if (*ptr == HTTP_CHAR_CR || *ptr == HTTP_CHAR_LF) |
| { |
| if (streamLength > 1 && |
| (ptr[1] == HTTP_CHAR_CR || ptr[1] == HTTP_CHAR_LF) && |
| ptr[1] != ptr[0]) ptr++; // avoid double CR or double LF, should treat it as different lines |
| // Note that double CR(CRLFCRLF) or double LF (CRLFCRLF, or LFLF) means end of HTTP header |
| return ptr - start_ptr + 1; |
| } |
| |
| return 0; // no complete key-value pair available |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| // if aNewMemFragPtr=NULL, no change to memory fragment pointer, existing fragment with larger length |
| bool HTTPParserInput::constructOutputFragment(const uint32 aNewMemFragLen, const void *aNewMemFragPtr, const bool isNewFrag) |
| { |
| if (isNewFrag || iDataOutQueue.empty()) |
| { |
| RefCounterMemoryFragment refCountMemfrag(iDataInQueue[0].getMemFrag(), iDataInQueue[0].getRefCounter()); |
| int32 err = 0; |
| OSCL_TRY(err, iDataOutQueue.push_back(refCountMemfrag);); |
| if (err) return false; |
| } |
| |
| // update ptr and len of the memory fragment |
| iDataOutQueue.back().update(aNewMemFragLen); |
| if (aNewMemFragPtr) iDataOutQueue.back().update((void*)aNewMemFragPtr); |
| return true; |
| } |
| |
| bool HTTPParserInput::empty() |
| { |
| if (iDataInQueue.empty()) return true; |
| if (iDataInQueue.size() > 1) return false; |
| |
| // iDataInQueue.size() = 1 |
| if (iDataInQueueMemFragOffset == iDataInQueue[0].getMemFragSize()) return true; |
| return false; |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| ////////// HTTPParserBaseObject Implementation //////////////////////*///////////// |
| ///////////////////////////////////////////////////////////////////////////////////// |
| int32 HTTPParserBaseObject::parseHeaderFields(HTTPMemoryFragment &aInputLineData, const bool aReplaceOldValue) |
| { |
| // parse header fields |
| char *fieldKey; |
| uint32 fieldKeyLength; |
| char *fieldValue; |
| uint32 fieldValueLength = 0; |
| int32 status = getNextFieldKeyValuePair(aInputLineData, fieldKey, fieldKeyLength, fieldValue, fieldValueLength); |
| if (status == 1) return HTTPParser::PARSE_HEADER_AVAILABLE; // end of header |
| if (status < 0) |
| { |
| LOGINFO((0, "HTTPParserBaseObject::parseHeaderFields() : Syntax Error founded!!")); |
| return HTTPParser::PARSE_SYNTAX_ERROR; // no divider characters found! |
| } |
| |
| // exception handling (no key or no value case) |
| if (fieldKeyLength == 0) return HTTPParser::PARSE_SUCCESS; // for no key, just ignore it |
| char spaceChar = HTTP_CHAR_SPACE; |
| if (fieldValueLength == 0) // for no value, just set '' |
| { |
| fieldValue = &spaceChar; |
| fieldValueLength = 1; |
| } |
| if (status != 0) return HTTPParser::PARSE_SUCCESS; // just ignore |
| |
| // add a key-value pair(fieldKey, fieldValue) to store |
| return addKeyValuePairToStore(fieldKey, fieldKeyLength, fieldValue, fieldValueLength, aReplaceOldValue); |
| } |
| |
| int32 HTTPParserBaseObject::addKeyValuePairToStore(const char *aFieldKey, const uint32 aFieldKeyLength, |
| const char *aFieldValue, const uint32 aFieldValueLength, |
| const bool aNeedReplaceOldValue) |
| { |
| if (aFieldKeyLength + aFieldValueLength < iKeyValueStore->getAvailableSize()) |
| { |
| if (iKeyValueStore->addKeyValuePair(aFieldKey, aFieldKeyLength, aFieldValue, aFieldValueLength, aNeedReplaceOldValue) != 0) |
| { |
| return HTTPParser::PARSE_GENERAL_ERROR; |
| } |
| } |
| else |
| { |
| // not enough memory |
| if (!reallocKeyValueStore(aFieldKeyLength + aFieldValueLength)) return HTTPParser::PARSE_MEMORY_ALLOCATION_FAILURE; |
| // re-add key-value pair to store |
| if (iKeyValueStore->addKeyValuePair(aFieldKey, aFieldKeyLength, aFieldValue, aFieldValueLength, aNeedReplaceOldValue) == |
| StringKeyValueStore::StringKeyValueStore_Failure) return HTTPParser::PARSE_GENERAL_ERROR; |
| } |
| return HTTPParser::PARSE_SUCCESS; |
| } |
| |
| int32 HTTPParserBaseObject::addKeyValuePairToStore(const StrCSumPtrLen &aNewKey, |
| const StrPtrLen &aNewValue, |
| const bool aNeedReplaceOldValue) |
| { |
| return addKeyValuePairToStore((char*)aNewKey.c_str(), aNewKey.length(), |
| (char*)aNewValue.c_str(), aNewValue.length(), |
| aNeedReplaceOldValue); |
| } |
| |
| |
| bool HTTPParserBaseObject::reallocKeyValueStore(const uint32 aCurrKeyValueSize) |
| { |
| // calculate the new KeyValueStore size |
| uint32 miniSize = iKeyValueStore->getCurrentMemoryUsage() + aCurrKeyValueSize; |
| uint32 aNewStoreSize = OSCL_MAX(miniSize, iKeyValueStore->getStoreSize()) << 1; |
| |
| // create a new store |
| StringKeyValueStore *aKeyValueStore = StringKeyValueStore::create(aNewStoreSize); |
| if (!aKeyValueStore) return false; |
| if (!aKeyValueStore->copy(*iKeyValueStore)) |
| { |
| OSCL_DELETE(aKeyValueStore); |
| return false; |
| } |
| OSCL_DELETE(iKeyValueStore); |
| iKeyValueStore = aKeyValueStore; |
| return true; |
| |
| } |
| |
| bool HTTPParserBaseObject::constructEntityUnit(HTTPParserInput &aParserInput, RefCountHTTPEntityUnit &aEntityUnit) |
| { |
| OsclRefCounterMemFrag entityUnit; |
| int32 err = 0; |
| OSCL_TRY(err, entityUnit = iEntityUnitAlloc->get();); |
| if (err) return false; |
| |
| // add memory fragments into the entity unit |
| HTTPEntityUnit* entityUnitFrag = OSCL_PLACEMENT_NEW(((uint8*) entityUnit.getMemFragPtr()), HTTPEntityUnit()); |
| OsclRefCounterMemFrag memfrag; |
| while (aParserInput.getOutputMemFrag(memfrag)) |
| { |
| if (!entityUnitFrag->addMemFrag(memfrag)) |
| { |
| entityUnitFrag->~HTTPEntityUnit(); |
| return false; |
| } |
| } |
| //if(entityUnitFrag->getNumFragments() == 0) { entityUnitFrag->~HTTPEntityUnit(); return false; } // no memory fragments |
| aEntityUnit = RefCountHTTPEntityUnit(*entityUnitFrag, entityUnit.getRefCounter()); // no memory fragments is possible |
| entityUnitFrag->~HTTPEntityUnit(); // destruct entityUnitFrag |
| return true; |
| } |
| |
| // return value: 0 normal, 1 end of header, 2 ignore, -1 error |
| int32 HTTPParserBaseObject::getNextFieldKeyValuePair(HTTPMemoryFragment &aInputDataStream, char *&aFieldKey, uint32 &aFieldKeyLength, |
| char *&aFieldValue, uint32 &aFieldValueLength) |
| { |
| // get key |
| int32 status = parseNextValueItem(aInputDataStream, aFieldKey, aFieldKeyLength, true); |
| if (status != 0) return status; // end of header or error |
| |
| // get value |
| return parseNextValueItem(aInputDataStream, aFieldValue, aFieldValueLength, false); |
| } |
| |
| // return value: 0 normal, |
| // 1 end of header, |
| // 2 ignore (for CRLF, to handle CRLF split into separate fragments) |
| // -1 error |
| int32 HTTPParserBaseObject::parseNextValueItem(HTTPMemoryFragment &aInputDataStream, char *&valueItemPtr, uint32 &valueItemLength, const bool isKeyItem) |
| { |
| char dividerChar0 = (isKeyItem ? HTTP_CHAR_COLON : HTTP_CHAR_CR); |
| char dividerChar1 = (isKeyItem ? HTTP_CHAR_COLON : HTTP_CHAR_LF); |
| |
| char *ptr = (char *)aInputDataStream.getPtr(); |
| int32 len = aInputDataStream.getAvailableSpace(); |
| |
| // eat all non-letter characters at the beginning |
| int32 status = getLineStartPoint(ptr, len, isKeyItem); |
| if (status == 2) return status; // ignore |
| if (status == 1) |
| { |
| aInputDataStream.update(ptr); // Final CRLF, end of HTTP header |
| return 1; |
| } |
| |
| // search divider characters to identify the value item |
| valueItemPtr = ptr; |
| while (*ptr != dividerChar0 && *ptr != dividerChar1 && len > 0) |
| { |
| ptr++; // assuming there is no case like "zzz key :" |
| len--; |
| } |
| if (len <= 0) return -1; // no divider chars |
| |
| char *end_ptr = ptr--; |
| while (*ptr == HTTP_CHAR_SPACE || *ptr == HTTP_CHAR_TAB) ptr--; // eat space or tab characater |
| valueItemLength = (ptr > valueItemPtr ? (ptr - valueItemPtr + 1) : 0); // ptr is the ending pointer for a value item |
| |
| ptr = end_ptr; |
| if (isKeyItem) ptr++; |
| else |
| { |
| saveEndingCRLF(ptr, len, iPrevCRLF); |
| if (len > 0 && (ptr[1] == HTTP_CHAR_CR || ptr[1] == HTTP_CHAR_LF)) ptr++; // pass CRLF at each line |
| } |
| |
| aInputDataStream.update(ptr); |
| return 0; |
| } |
| |
| // return value: 0 normal, 1 end of header, 2 ignore |
| int32 HTTPParserBaseObject::getLineStartPoint(char *&ptr, int32 &len, const bool isKeyItem) |
| { |
| if (isKeyItem) |
| { |
| while (!isLetter(*ptr) && (*ptr != HTTP_CHAR_CR && *ptr != HTTP_CHAR_LF) && len > 0) |
| { |
| iPrevCRLF = 0; |
| ptr++; |
| len--; // eat all non-letter characters except CRLF |
| } |
| if (*ptr == HTTP_CHAR_CR || *ptr == HTTP_CHAR_LF) // key guarantees to have very first LETTER character |
| { |
| if (iPrevCRLF == 0) |
| { |
| saveEndingCRLF(ptr, len, iPrevCRLF); |
| if (len > 0 && (ptr[1] == HTTP_CHAR_CR || ptr[1] == HTTP_CHAR_LF)) ptr++; |
| return 2; // save CRLF to iPrevCRLF, and ignore |
| } |
| else // iPrevCRLF has something |
| { |
| uint8 currCRLF = 0; |
| saveEndingCRLF(ptr, len, currCRLF); |
| if (len > 0 && (ptr[1] == HTTP_CHAR_CR || ptr[1] == HTTP_CHAR_LF)) ptr++; |
| if (iPrevCRLF & currCRLF) return 1; // double CR or LF, end of HTTP header |
| iPrevCRLF = currCRLF; |
| return 2; // ignore |
| } |
| } |
| } |
| else |
| { |
| while ((*ptr == HTTP_CHAR_SPACE || *ptr == HTTP_CHAR_TAB) && len > 0) |
| { |
| ptr++; |
| len--; |
| } // eat space or tab character |
| } |
| |
| return 0; |
| } |
| |
| // aNeedReset=1, set aCRLF; aNeedReset=0, update aCRLF |
| void HTTPParserBaseObject::saveEndingCRLF(char *ptr, uint32 len, uint8& aCRLF, bool aNeedReset) |
| { |
| char *tmpPtr = ptr; |
| int32 tmpLen = (int32)len; |
| if (aNeedReset) aCRLF = 0; |
| |
| // get to CRLF point |
| while ((*tmpPtr != HTTP_CHAR_CR && *tmpPtr != HTTP_CHAR_LF) && tmpLen > 0) |
| { |
| tmpPtr++; |
| tmpLen--; |
| } |
| |
| while ((*tmpPtr == HTTP_CHAR_CR || *tmpPtr == HTTP_CHAR_LF) && tmpLen > 0) |
| { |
| if (*tmpPtr == HTTP_CHAR_CR) aCRLF |= 0x2; // bit 1 = 1 |
| if (*tmpPtr == HTTP_CHAR_LF) aCRLF |= 0x1; // bit 0 = 1 |
| tmpPtr++; |
| tmpLen--; |
| } |
| } |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| ////////// HTTPParserHeaderObject Implementation //////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////////// |
| int32 HTTPParserHeaderObject::parse(HTTPParserInput &aParserInput, RefCountHTTPEntityUnit &aEntityUnit) |
| { |
| HTTPMemoryFragment aInputLineData; |
| |
| while (aParserInput.getNextCompleteLine(aInputLineData)) |
| { |
| if (!iHeaderFirstLineParsed) |
| { |
| // parse the first line : Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF |
| int32 status = parseFirstLine(aInputLineData); |
| if (status < 0) return status; // syntax error |
| iHeaderFirstLineParsed = true; |
| } |
| else |
| { |
| int32 status = parseHeaderFields(aInputLineData); |
| if (status == HTTPParser::PARSE_HEADER_AVAILABLE) |
| { |
| iHeaderParsed = true; |
| // check content info |
| if (!iContentInfo->parseContentInfo(*iKeyValueStore)) return HTTPParser::PARSE_MEMORY_ALLOCATION_FAILURE; |
| // construct output entity unit |
| if (!constructEntityUnit(aParserInput, aEntityUnit)) return HTTPParser::PARSE_MEMORY_ALLOCATION_FAILURE; |
| if (!isGoodStatusCode()) |
| { |
| LOGINFO((0, "HTTPParserHeaderObject::parse() : NOT GOOD STATUS CODE")); |
| return HTTPParser::PARSE_STATUS_LINE_SHOW_NOT_SUCCESSFUL; |
| } |
| if (checkResponseParsedComplete()) iResponseParsedComplete = true; |
| return HTTPParser::PARSE_HEADER_AVAILABLE; |
| } |
| if (status != HTTPParser::PARSE_SUCCESS) return status; |
| } |
| |
| } // end of: while(iParserInput->getNextCompleteLine(aInputLineData)) |
| |
| // check content info |
| return HTTPParser::PARSE_NEED_MORE_DATA; |
| } |
| |
| // return value: 0 => ok , or HTTPParser enum codes |
| int32 HTTPParserHeaderObject::parseFirstLine(HTTPMemoryFragment &aInputDataStream) |
| { |
| // Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF |
| char *ptr = (char *)aInputDataStream.getPtr(); |
| int32 len = (int32)aInputDataStream.getAvailableSpace(); |
| |
| while (!isLetter(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| if (len < 8) return HTTPParser::PARSE_SYNTAX_ERROR; |
| |
| // check HTTP/1.x |
| if (((ptr[0] | OSCL_ASCII_CASE_MAGIC_BIT) == 'h') && |
| ((ptr[1] | OSCL_ASCII_CASE_MAGIC_BIT) == 't') && |
| ((ptr[2] | OSCL_ASCII_CASE_MAGIC_BIT) == 't') && |
| ((ptr[3] | OSCL_ASCII_CASE_MAGIC_BIT) == 'p') && |
| (ptr[4] == '/')) |
| { |
| ptr += 5; // size of "http/" |
| if (!checkHTTPVersion(ptr)) |
| { |
| return HTTPParser::PARSE_HTTP_VERSION_NOT_SUPPORTED; |
| } |
| |
| // ptr should be updated in checkHTTPVersion() |
| while (!isDigit(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| if (len <= 0) return 0; // no digital status code |
| char *start_ptr = ptr; |
| uint32 start_len = len; |
| while (isDigit(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| //if(len <= 0) return 1; // no Reason-Phrase |
| |
| // get status code |
| PV_atoi(start_ptr, 'd', start_len - len, iStatusCode); |
| saveEndingCRLF(ptr, len, iPrevCRLF); |
| return 0; |
| } |
| |
| // add first-line into the key-value store |
| StrPtrLen firstLine = "Response-Line"; |
| addKeyValuePairToStore(firstLine.c_str(), firstLine.length(), |
| (char *)aInputDataStream.getPtr(), aInputDataStream.getAvailableSpace(), |
| true); |
| |
| return HTTPParser::PARSE_SYNTAX_ERROR; // looks like the status line has something we don't understand. |
| } |
| |
| bool HTTPParserHeaderObject::checkHTTPVersion(char* &aPtr) |
| { |
| if (aPtr[0] == '1' && aPtr[0] == HTTP_CHAR_SPACE) |
| { |
| // support HTTP/1 |
| aPtr += 2; |
| iHttpVersionNum = 0; |
| return true; |
| } |
| |
| if (aPtr[0] == '1' && |
| aPtr[1] == '.' && |
| (aPtr[2] == '0' || aPtr[2] == '1')) |
| { |
| iHttpVersionNum = (aPtr[2] == '0' ? 0 : 1); |
| aPtr += 3; |
| return true; |
| } |
| |
| return false; |
| } |
| |
| // This function gets complicated since a couple of new cases have been added |
| bool HTTPParserHeaderObject::isGoodStatusCode() |
| { |
| if (iStatusCode < GOOD_HTTP_STATUS_CODE_START_FROM100 || |
| iStatusCode > GOOD_HTTP_STATUS_CODE_END_AT299) return false; |
| |
| // check 1xx code, 1xx code is only allowed in Http/1.1 |
| bool goodStatusCode = checkGood1xxCode(); |
| if (!goodStatusCode) return false; |
| |
| // check 2xx code, if 204 (no content) or 2xx code with content-length=0, then we need to error out |
| goodStatusCode = checkGood2xxCode(); |
| return goodStatusCode; |
| } |
| |
| // check 1xx code, 1xx code is only allowed in Http/1.1 |
| bool HTTPParserHeaderObject::checkGood1xxCode() |
| { |
| if (iHttpVersionNum == 0 && |
| (GOOD_HTTP_STATUS_CODE_START_FROM100 <= iStatusCode && iStatusCode < GOOD_HTTP_STATUS_CODE_START_FROM200)) |
| { |
| return false; |
| } |
| return true; |
| } |
| |
| // check 2xx code, if 2xx code with content-length=0, then we need to error out |
| bool HTTPParserHeaderObject::checkGood2xxCode() |
| { |
| uint32 goodStatusCodeStart = GOOD_HTTP_STATUS_CODE_START_FROM200; |
| if (GOOD_HTTP_STATUS_CODE_START_FROM200 <= iStatusCode && iStatusCode <= GOOD_HTTP_STATUS_CODE_END_AT299) |
| { |
| // for Http status code 204 (no content), error our right away |
| if (iStatusCode == HTTP_STATUS_CODE_204_NO_CONTENT) |
| { |
| LOGINFO((0, "HTTPParserHeaderObject::checkGood2xxCode() : iStatusCode=HTTP_STATUS_CODE_204_NO_CONTENT")); |
| return false; |
| } |
| |
| // other 2xx code, check the zero or empty content-length |
| StrCSumPtrLen contenLengthKey("Content-Length"); |
| StrPtrLen contentLengthValue; |
| if (iKeyValueStore->getValueByKey(contenLengthKey, contentLengthValue)) |
| { |
| // has Content-Length field |
| uint32 aContentLength = 0; |
| PV_atoi(contentLengthValue.c_str(), 'd', aContentLength); |
| |
| // check the empty Content-Length case |
| char *ptr = (char *)contentLengthValue.c_str(); |
| if (aContentLength == 0 || ptr[0] == HTTP_CHAR_SPACE) |
| { |
| LOGINFO((0, "HTTPParserHeaderObject::checkGood2xxCode() : zero or empty content length for 2xx code")); |
| return false; |
| } |
| } |
| } |
| return (goodStatusCodeStart <= iStatusCode && iStatusCode <= GOOD_HTTP_STATUS_CODE_END_AT299); |
| } |
| |
| int32 HTTPParserHeaderObject::doSanityCheckForResponseHeader() |
| { |
| // check Chunked Transfer Encoding supported for Http/1.1 only |
| if (!checkChunkedTransferEncodingSupported()) return HTTPParser::PARSE_TRANSFER_ENCODING_NOT_SUPPORTED; |
| return HTTPParser::PARSE_SUCCESS; |
| } |
| |
| |
| // check Chunked Transfer Encoding supported by Http/1.1 only |
| bool HTTPParserHeaderObject::checkChunkedTransferEncodingSupported() |
| { |
| StrCSumPtrLen transferEncodingKey("Transfer-Encoding"); |
| StrPtrLen transferEncodingValue; |
| if (iKeyValueStore->getValueByKey(transferEncodingKey, transferEncodingValue)) |
| { |
| LOGINFO((0, "HTTPParserHeaderObject::checkChunkedTransferEncodingSupported() : has Transfer-encoding field, HttpVersionNum=%d", iHttpVersionNum)); |
| // has Transfer-encoding field |
| if (iHttpVersionNum == 0) return false; |
| } |
| return true; |
| } |
| |
| bool HTTPParserHeaderObject::checkResponseParsedComplete() |
| { |
| // check "Content-Length" |
| StrCSumPtrLen contentLengthKey = "Content-Length"; |
| StrPtrLen contentLengthValue; |
| |
| if (!getField(contentLengthKey, contentLengthValue)) return false; // no "Content-Length" |
| |
| // get "Content-Length" value |
| uint32 contentLength = 0; |
| PV_atoi(contentLengthValue.c_str(), 'd', contentLength); |
| return (contentLength == 0); |
| } |
| |
| HTTPParserHeaderObject *HTTPParserHeaderObject::create(HTTPContentInfoInternal *aContentInfo) |
| { |
| HTTPParserHeaderObject *header = OSCL_NEW(HTTPParserHeaderObject, ()); |
| if (!header) return NULL; |
| if (!header->construct(aContentInfo)) |
| { |
| OSCL_DELETE(header); |
| return NULL; |
| } |
| return header; |
| } |
| |
| bool HTTPParserHeaderObject::construct(HTTPContentInfoInternal *aContentInfo) |
| { |
| reset(); |
| iContentInfo = aContentInfo; |
| |
| if ((iKeyValueStore = StringKeyValueStore::create()) == NULL) return false; |
| |
| iEntityUnitAlloc = OSCL_NEW(PVMFBufferPoolAllocator, ()); |
| if (!iEntityUnitAlloc) return false; |
| |
| int32 err = 0; |
| OSCL_TRY(err, iEntityUnitAlloc->size(HTTP_ENTITY_UNIT_POOLNUM, sizeof(HTTPEntityUnit))); |
| if (err) return false; |
| |
| return true; |
| } |
| |
| HTTPParserHeaderObject::~HTTPParserHeaderObject() |
| { |
| reset(); |
| |
| // delete iKeyValueStore |
| if (iKeyValueStore) OSCL_DELETE(iKeyValueStore); |
| iKeyValueStore = NULL; |
| |
| // delete iEntityUnitAlloc |
| if (iEntityUnitAlloc) OSCL_DELETE(iEntityUnitAlloc); |
| iEntityUnitAlloc = NULL; |
| } |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| ////////// HTTPParserEntityBodyObject Implementation //////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////////// |
| int32 HTTPParserEntityBodyObject::parseEnityBodyChunkData(HTTPParserInput &aParserInput, RefCountHTTPEntityUnit &aEntityUnit) |
| { |
| int32 requestSize = iContentInfo->getContentRangeLength() - iCurrentChunkDataLength; |
| HTTPMemoryFragment aFrag; |
| int32 actualSize = 0; |
| while (requestSize > 0) |
| { |
| if ((actualSize = aParserInput.getData(aFrag, requestSize)) <= 0) break; |
| iCurrentChunkDataLength += actualSize; |
| iNumChunks++; |
| requestSize -= actualSize; |
| } |
| if (actualSize < 0) return HTTPParser::PARSE_MEMORY_ALLOCATION_FAILURE; |
| if (actualSize == 0 && requestSize > 0) return HTTPParser::PARSE_NEED_MORE_DATA; |
| |
| // get complete chunk, and then construct output entity unit |
| if (!constructEntityUnit(aParserInput, aEntityUnit)) return HTTPParser::PARSE_MEMORY_ALLOCATION_FAILURE; |
| |
| // pass ending CRLF for the chunk data for next chunk parsing |
| aParserInput.skipCRLF(); |
| return HTTPParser::PARSE_SUCCESS; |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| ////////// HTTPParserNormalContentObject Implementation ///////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////////// |
| int32 HTTPParserNormalContentObject::parse(HTTPParserInput &aParserInput, RefCountHTTPEntityUnit &aEntityUnit) |
| { |
| HTTPMemoryFragment aFrag; |
| int32 actualSize = 0; |
| if (iContentInfo->iContentLength == 0) iContentInfo->iContentLength = 0x7fffffff; // 0=>7fff ffff |
| if (iCurrTotalLengthObtained == 0 && iContentInfo->iContentRangeLeft > 0) iCurrTotalLengthObtained = iContentInfo->iContentRangeLeft; |
| int32 requestSize = (int32)iContentInfo->iContentLength - (int32)iCurrTotalLengthObtained; |
| if (requestSize <= 0) |
| { |
| if (requestSize == 0) return HTTPParser::PARSE_SUCCESS_END_OF_MESSAGE; |
| return HTTPParser::PARSE_SUCCESS_END_OF_MESSAGE_WITH_EXTRA_DATA; |
| } |
| while ((actualSize = aParserInput.getData(aFrag, requestSize)) > 0) |
| { |
| iCurrTotalLengthObtained += actualSize; |
| if (requestSize > 0) |
| { |
| if ((requestSize -= actualSize) <= 0) break; // we don't need to process aFrag |
| } |
| } |
| if (actualSize < 0) return HTTPParser::PARSE_MEMORY_ALLOCATION_FAILURE; |
| |
| // construct output entity unit |
| if (!constructEntityUnit(aParserInput, aEntityUnit)) return HTTPParser::PARSE_MEMORY_ALLOCATION_FAILURE; |
| if (iCurrTotalLengthObtained >= iContentInfo->iContentLength) |
| { |
| if (iCurrTotalLengthObtained > iContentInfo->iContentLength || |
| !aParserInput.empty()) return HTTPParser::PARSE_SUCCESS_END_OF_MESSAGE_WITH_EXTRA_DATA; |
| return HTTPParser::PARSE_SUCCESS_END_OF_MESSAGE; |
| } |
| if (actualSize == 0 && iContentInfo->iContentLength > iCurrTotalLengthObtained) return HTTPParser::PARSE_SUCCESS_END_OF_INPUT; |
| return HTTPParser::PARSE_SUCCESS; |
| } |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| ////////// HTTPParserCTEContentObject Implementation ///////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////////// |
| int32 HTTPParserCTEContentObject::parse(HTTPParserInput &aParserInput, RefCountHTTPEntityUnit &aEntityUnit) |
| { |
| // get CTE chunk length |
| if (iContentInfo->iContentRangeRight == 0) |
| { |
| HTTPMemoryFragment aInputLineData; |
| int32 chunkLength = -1; |
| while (aParserInput.getNextCompleteLine(aInputLineData, true)) // true means header is already parsed |
| { |
| if (getCTEChunkLength(aInputLineData, chunkLength)) break; |
| } |
| if (chunkLength == -1) return HTTPParser::PARSE_NEED_MORE_DATA; |
| if (chunkLength == 0) |
| { |
| if (!aParserInput.empty()) return HTTPParser::PARSE_SUCCESS_END_OF_MESSAGE_WITH_EXTRA_DATA; |
| return HTTPParser::PARSE_SUCCESS_END_OF_MESSAGE; |
| } |
| |
| iContentInfo->iContentRangeRight = chunkLength - 1; |
| iContentInfo->iContentLength += chunkLength; |
| aParserInput.clearOutputQueue(); |
| } |
| |
| // get CTE chunk data |
| aParserInput.skipCRLF(); |
| int32 status = parseEnityBodyChunkData(aParserInput, aEntityUnit); |
| if (status == HTTPParser::PARSE_SUCCESS) reset(); // for next chunk parsing |
| return status; |
| } |
| |
| bool HTTPParserCTEContentObject::getCTEChunkLength(HTTPMemoryFragment &aInputLineData, int32 &aChunkSize) |
| { |
| char *ptr = (char *)aInputLineData.getPtr(); |
| int32 len = (int32)aInputLineData.getAvailableSpace(); |
| while (!isHexDigit(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| if (len <= 0) return false; |
| char *start_ptr = ptr; |
| int32 start_len = len; |
| while (isHexDigit(*ptr) && len > 0) |
| { |
| ptr++; |
| len--; |
| } |
| if (len <= 0) return false; |
| uint32 chunkSize; |
| PV_atoi(start_ptr, 'x', start_len - len, chunkSize); |
| aChunkSize = (int32)chunkSize; |
| return true; |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////////// |
| ////////// HTTPParserMultipartContentObject Implementation ///////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////////// |
| int32 HTTPParserMultipartContentObject::parse(HTTPParserInput &aParserInput, RefCountHTTPEntityUnit &aEntityUnit) |
| { |
| // parse boundary string and chunk header |
| int32 status = parseChunkHeader(aParserInput); |
| if (status != HTTPParser::PARSE_SUCCESS) return status; |
| |
| // get chunk data |
| |
| status = parseEnityBodyChunkData(aParserInput, aEntityUnit); |
| if (status != HTTPParser::PARSE_SUCCESS) return status; |
| |
| reset(); // for next chunk parsing |
| if (aParserInput.empty()) return HTTPParser::PARSE_SUCCESS_END_OF_INPUT; |
| return HTTPParser::PARSE_SUCCESS; |
| } |
| |
| int32 HTTPParserMultipartContentObject::parseChunkHeader(HTTPParserInput &aParserInput) |
| { |
| if (iHeaderInEntityBodyParsed) return HTTPParser::PARSE_SUCCESS; |
| |
| // parse boundary line |
| if (!iBoudaryLineParsed) |
| { |
| int32 status = parseChunkBoundaryLine(aParserInput); |
| if (status != HTTPParser::PARSE_SUCCESS) return status; |
| if (!iBoudaryLineParsed) return HTTPParser::PARSE_NEED_MORE_DATA; // try next time |
| } |
| |
| // parse chunk header |
| HTTPMemoryFragment aInputLineData; |
| while (aParserInput.getNextCompleteLine(aInputLineData)) |
| { |
| if (!iBoudaryLineParsed) |
| { |
| return HTTPParser::PARSE_SYNTAX_ERROR; |
| } |
| int32 status = parseHeaderFields(aInputLineData, true); // true means replace the old field value with the new one |
| if (status == HTTPParser::PARSE_HEADER_AVAILABLE) |
| { |
| iHeaderInEntityBodyParsed = true; |
| iCounter++; |
| // update content info |
| if (!iContentInfo->parseContentInfo(*iKeyValueStore)) return HTTPParser::PARSE_MEMORY_ALLOCATION_FAILURE; |
| aParserInput.clearOutputQueue(); |
| saveEndingCRLF((char *)aInputLineData.getPtr(), (int32)aInputLineData.getAvailableSpace(), iPrevCRLF); |
| break; |
| } |
| if (status != HTTPParser::PARSE_SUCCESS) return status; |
| } |
| if (!iHeaderInEntityBodyParsed) return HTTPParser::PARSE_NEED_MORE_DATA; |
| |
| // check the extra CRLF |
| if (needSkipCRLF()) aParserInput.skipCRLF(); |
| return HTTPParser::PARSE_SUCCESS; |
| } |
| |
| |
| int32 HTTPParserMultipartContentObject::parseChunkBoundaryLine(HTTPParserInput &aParserInput) |
| { |
| HTTPMemoryFragment aInputLineData; |
| if (aParserInput.getNextCompleteLine(aInputLineData)) |
| { |
| |
| // parse boundary line : --BOUNDARY STRING |
| bool isFinalBoundary = false; |
| if (iContentInfo->parseBoudaryLine(aInputLineData, isFinalBoundary)) iBoudaryLineParsed = true; |
| if (isFinalBoundary) return HTTPParser::PARSE_SUCCESS_END_OF_MESSAGE; |
| saveEndingCRLF((char *)aInputLineData.getPtr(), (int32)aInputLineData.getAvailableSpace(), iPrevCRLF); |
| |
| if (!iBoudaryLineParsed) |
| { |
| if (aParserInput.getNextCompleteLine(aInputLineData)) |
| { |
| bool isFinalBoundary = false; |
| if (iContentInfo->parseBoudaryLine(aInputLineData, isFinalBoundary)) iBoudaryLineParsed = true; |
| } |
| } |
| } |
| |
| if (!iBoudaryLineParsed) |
| { |
| // try to see whether it is final boundary line, like --boundaryString-- (no "\r\n") |
| HTTPMemoryFragment frag; |
| if (!aParserInput.viewAvailableInputData(frag)) return HTTPParser::PARSE_NEED_MORE_DATA; |
| |
| bool isFinalBoundary = false; |
| iContentInfo->parseBoudaryLine(frag, isFinalBoundary); |
| if (isFinalBoundary) return HTTPParser::PARSE_SUCCESS_END_OF_MESSAGE; |
| } |
| return HTTPParser::PARSE_SUCCESS; |
| } |
