proxygen::StructuredHeadersBuffer Class Reference

#include <StructuredHeadersBuffer.h>

Public Member Functions
	StructuredHeadersBuffer (const std::string &s)
StructuredHeaders::DecodeError	parseIdentifier (StructuredHeaderItem &result)
StructuredHeaders::DecodeError	parseIdentifier (std::string &result)
StructuredHeaders::DecodeError	parseItem (StructuredHeaderItem &result)
DecodeError	removeSymbol (const std::string &symbol, bool strict)
DecodeError	removeOptionalWhitespace ()
bool	isEmpty ()
DecodeError	handleDecodeError (const DecodeError &err)

Private Member Functions
DecodeError	parseBinaryContent (StructuredHeaderItem &result)
DecodeError	parseNumber (StructuredHeaderItem &result)
DecodeError	parseString (StructuredHeaderItem &result)
DecodeError	parseInteger (const std::string &input, StructuredHeaderItem &result)
DecodeError	parseFloat (const std::string &input, StructuredHeaderItem &result)
char	peek ()
void	advanceCursor ()
int32_t	getNumCharsParsed ()

Private Attributes
folly::StringPiece	content_
folly::StringPiece	originalContent_

Detailed Description

Definition at line 20 of file StructuredHeadersBuffer.h.

Constructor & Destructor Documentation

proxygen::StructuredHeadersBuffer::StructuredHeadersBuffer ( const std::string &  s )

inlineexplicit

Definition at line 23 of file StructuredHeadersBuffer.h.

References int32_t, folly::gen::isEmpty, and string.

                                                       :
    content_(s),
    originalContent_(s) {}

Member Function Documentation

void proxygen::StructuredHeadersBuffer::advanceCursor ( )

private

Definition at line 281 of file StructuredHeadersBuffer.cpp.

                                            {
  content_.advance(1);
}

int32_t proxygen::StructuredHeadersBuffer::getNumCharsParsed ( )

private

Definition at line 289 of file StructuredHeadersBuffer.cpp.

                                                   {
  return std::distance(originalContent_.begin(), content_.begin());
}

DecodeError proxygen::StructuredHeadersBuffer::handleDecodeError

(

const DecodeError &

err

)

Definition at line 269 of file StructuredHeadersBuffer.cpp.

References proxygen::StructuredHeaders::decodeErrorDescription, and proxygen::ERROR.

                                                                             {
  LOG_EVERY_N(ERROR, 1000) << "Error message: " <<
    decodeErrorDescription.at(err) <<
    ". Number of characters parsed before error:" <<
    getNumCharsParsed() << ". Header Content:" << originalContent_.str();
  return err;
}

bool proxygen::StructuredHeadersBuffer::isEmpty

(

)

Definition at line 285 of file StructuredHeadersBuffer.cpp.

                                      {
  return content_.begin() == content_.end();
}

DecodeError proxygen::StructuredHeadersBuffer::parseBinaryContent ( StructuredHeaderItem &  result )

private

Definition at line 97 of file StructuredHeadersBuffer.cpp.

References proxygen::StructuredHeaders::StructuredHeaderItem::BINARYCONTENT, current, proxygen::StructuredHeaders::decodeBase64(), proxygen::StructuredHeaders::encodeBase64(), proxygen::StructuredHeaders::INVALID_CHARACTER, folly::gen::isEmpty, proxygen::StructuredHeaders::isValidEncodedBinaryContent(), proxygen::StructuredHeaders::isValidEncodedBinaryContentChar(), folly::gen::move, proxygen::StructuredHeaders::OK, string, proxygen::StructuredHeaders::StructuredHeaderItem::tag, proxygen::StructuredHeaders::UNDECODEABLE_BINARY_CONTENT, proxygen::StructuredHeaders::UNEXPECTED_END_OF_BUFFER, and proxygen::StructuredHeaders::StructuredHeaderItem::value.

                                {

  std::string outputString;
  if (isEmpty()) {
    return handleDecodeError(DecodeError::UNEXPECTED_END_OF_BUFFER);
  }

  if (peek() != '*') {
    return handleDecodeError(DecodeError::INVALID_CHARACTER);
  }

  advanceCursor();

  while (!isEmpty()) {
    char current = peek();
    advanceCursor();
    if (current == '*') {
      if (!isValidEncodedBinaryContent(
         outputString)) {
        return handleDecodeError(DecodeError::UNDECODEABLE_BINARY_CONTENT);
      }

      std::string decodedContent = decodeBase64(outputString);
      if (encodeBase64(decodedContent) != outputString) {
        return handleDecodeError(DecodeError::UNDECODEABLE_BINARY_CONTENT);
      }

      result.value = std::move(decodedContent);
      result.tag = StructuredHeaderItem::Type::BINARYCONTENT;
      return DecodeError::OK;
    } else if (!isValidEncodedBinaryContentChar(
        current)) {
      return handleDecodeError(DecodeError::INVALID_CHARACTER);
    } else {
      outputString.push_back(current);
    }
  }

  return handleDecodeError(DecodeError::UNEXPECTED_END_OF_BUFFER);
}

DecodeError proxygen::StructuredHeadersBuffer::parseFloat ( const std::string &  input, StructuredHeaderItem &  result  )

private

Definition at line 191 of file StructuredHeadersBuffer.cpp.

References proxygen::StructuredHeaders::StructuredHeaderItem::DOUBLE, proxygen::StructuredHeaders::OK, proxygen::StructuredHeaders::StructuredHeaderItem::tag, proxygen::StructuredHeaders::UNPARSEABLE_NUMERIC_TYPE, and proxygen::StructuredHeaders::StructuredHeaderItem::value.

                                {

  try {
    result.value = boost::lexical_cast<double>(input);
    result.tag = StructuredHeaderItem::Type::DOUBLE;
  } catch (boost::bad_lexical_cast &) {
    return handleDecodeError(DecodeError::UNPARSEABLE_NUMERIC_TYPE);
  }
  return DecodeError::OK;
}

DecodeError proxygen::StructuredHeadersBuffer::parseIdentifier

(

StructuredHeaderItem &

result

)

Definition at line 139 of file StructuredHeadersBuffer.cpp.

References proxygen::StructuredHeaders::StructuredHeaderItem::IDENTIFIER, proxygen::StructuredHeaders::OK, string, proxygen::StructuredHeaders::StructuredHeaderItem::tag, and proxygen::StructuredHeaders::StructuredHeaderItem::value.

Referenced by proxygen::TEST_F().

                                {

  std::string outputString;

  auto err = parseIdentifier(outputString);
  if (err != DecodeError::OK) {
    return err;
  }

  result.value = outputString;
  result.tag = StructuredHeaderItem::Type::IDENTIFIER;

  return DecodeError::OK;
}

DecodeError proxygen::StructuredHeadersBuffer::parseIdentifier

(

std::string &

result

)

Definition at line 155 of file StructuredHeadersBuffer.cpp.

References current, proxygen::StructuredHeaders::INVALID_CHARACTER, folly::gen::isEmpty, proxygen::StructuredHeaders::isLcAlpha(), proxygen::StructuredHeaders::isValidIdentifierChar(), proxygen::StructuredHeaders::OK, and proxygen::StructuredHeaders::UNEXPECTED_END_OF_BUFFER.

                     {

  if (isEmpty()) {
    return handleDecodeError(DecodeError::UNEXPECTED_END_OF_BUFFER);
  }

  if (!isLcAlpha(peek())) {
    return handleDecodeError(DecodeError::INVALID_CHARACTER);
  }

  while (!isEmpty()) {
    char current = peek();
    if (!isValidIdentifierChar(current)) {
      break;
    } else {
      advanceCursor();
      result.push_back(current);
    }
  }

  return DecodeError::OK;
}

DecodeError proxygen::StructuredHeadersBuffer::parseInteger ( const std::string &  input, StructuredHeaderItem &  result  )

private

Definition at line 179 of file StructuredHeadersBuffer.cpp.

References proxygen::StructuredHeaders::StructuredHeaderItem::INT64, int64_t, proxygen::StructuredHeaders::OK, proxygen::StructuredHeaders::StructuredHeaderItem::tag, proxygen::StructuredHeaders::UNPARSEABLE_NUMERIC_TYPE, and proxygen::StructuredHeaders::StructuredHeaderItem::value.

                                {

  try {
    result.value = boost::lexical_cast<int64_t>(input);
    result.tag = StructuredHeaderItem::Type::INT64;
  } catch (boost::bad_lexical_cast &) {
    return handleDecodeError(DecodeError::UNPARSEABLE_NUMERIC_TYPE);
  }
  return DecodeError::OK;
}

DecodeError proxygen::StructuredHeadersBuffer::parseItem

(

StructuredHeaderItem &

result

)

Definition at line 19 of file StructuredHeadersBuffer.cpp.

References proxygen::StructuredHeaders::INVALID_CHARACTER, folly::gen::isEmpty, and proxygen::StructuredHeaders::UNEXPECTED_END_OF_BUFFER.

Referenced by proxygen::TEST_F().

                                                                           {

  removeOptionalWhitespace();

  if (isEmpty()) {
    return handleDecodeError(DecodeError::UNEXPECTED_END_OF_BUFFER);
  } else {
    char firstCharacter = peek();
    if (firstCharacter == '"') {
      return parseString(result);
    } else if (firstCharacter == '*') {
      return parseBinaryContent(result);
    } else if (std::isdigit(firstCharacter) || firstCharacter == '-') {
      return parseNumber(result);
    } else {
      return handleDecodeError(DecodeError::INVALID_CHARACTER);
    }
  }
}

DecodeError proxygen::StructuredHeadersBuffer::parseNumber ( StructuredHeaderItem &  result )

private

Definition at line 39 of file StructuredHeadersBuffer.cpp.

References current, proxygen::StructuredHeaders::StructuredHeaderItem::DOUBLE, proxygen::StructuredHeaders::StructuredHeaderItem::INT64, proxygen::StructuredHeaders::INVALID_CHARACTER, folly::gen::isEmpty, proxygen::StructuredHeaders::kMaxValidFloatLength, proxygen::StructuredHeaders::kMaxValidIntegerLength, proxygen::StructuredHeaders::OK, string, type, proxygen::StructuredHeaders::UNEXPECTED_END_OF_BUFFER, and proxygen::StructuredHeaders::VALUE_TOO_LONG.

                                                                             {
  auto type = StructuredHeaderItem::Type::INT64;

  bool positive = true;
  std::string input;

  if (isEmpty()) {
    return handleDecodeError(DecodeError::UNEXPECTED_END_OF_BUFFER);
  }

  if (peek() == '-') {
    advanceCursor();
    positive = false;
    input.push_back('-');
  }

  if (isEmpty()) {
    return handleDecodeError(DecodeError::UNEXPECTED_END_OF_BUFFER);
  }

  if (!std::isdigit(peek())) {
    return handleDecodeError(DecodeError::INVALID_CHARACTER);
  }

  while (!isEmpty()) {
    char current = peek();
    if (std::isdigit(current)) {
      input.push_back(current);
      advanceCursor();
    } else if (type == StructuredHeaderItem::Type::INT64 && current == '.') {
      type = StructuredHeaderItem::Type::DOUBLE;
      input.push_back(current);
      advanceCursor();
    } else {
      break;
    }

    int numDigits = input.length() - (positive ? 0 : 1);
    if (type == StructuredHeaderItem::Type::INT64 &&
       numDigits > StructuredHeaders::kMaxValidIntegerLength) {
      return handleDecodeError(DecodeError::VALUE_TOO_LONG);
    } else if (type == StructuredHeaderItem::Type::DOUBLE &&
       numDigits > StructuredHeaders::kMaxValidFloatLength) {
      return handleDecodeError(DecodeError::VALUE_TOO_LONG);
    }
  }

  if (type == StructuredHeaderItem::Type::INT64) {
    return parseInteger(input, result);
  } else if (input.back() == '.') {
    return handleDecodeError(DecodeError::INVALID_CHARACTER);
  } else {
    return parseFloat(input, result);
  }

  return DecodeError::OK;
}

DecodeError proxygen::StructuredHeadersBuffer::parseString ( StructuredHeaderItem &  result )

private

Definition at line 203 of file StructuredHeadersBuffer.cpp.

References current, proxygen::StructuredHeaders::INVALID_CHARACTER, folly::gen::isEmpty, proxygen::StructuredHeaders::isValidStringChar(), proxygen::StructuredHeaders::OK, proxygen::StructuredHeaders::StructuredHeaderItem::STRING, string, proxygen::StructuredHeaders::StructuredHeaderItem::tag, proxygen::StructuredHeaders::UNEXPECTED_END_OF_BUFFER, and proxygen::StructuredHeaders::StructuredHeaderItem::value.

                                                                             {

  std::string outputString;

  if (isEmpty()) {
    return handleDecodeError(DecodeError::UNEXPECTED_END_OF_BUFFER);
  }

  if (peek() != '"') {
    return handleDecodeError(DecodeError::INVALID_CHARACTER);
  }

  advanceCursor();

  while (!isEmpty()) {
    char current = peek();
    if (current == '\\') {
      advanceCursor();
      if (isEmpty()) {
        return handleDecodeError(DecodeError::UNEXPECTED_END_OF_BUFFER);
      } else {
        char nextChar = peek();
        advanceCursor();
        if (nextChar != '"' && nextChar != '\\') {
          return handleDecodeError(DecodeError::INVALID_CHARACTER);
        }
        outputString.push_back(nextChar);
      }
    } else if (current == '"') {
      advanceCursor();
      result.value = outputString;
      result.tag = StructuredHeaderItem::Type::STRING;
      return DecodeError::OK;
    } else if (!isValidStringChar(current)) {
      return handleDecodeError(DecodeError::INVALID_CHARACTER);
    } else {
      advanceCursor();
      outputString.push_back(current);
    }
  }

  return handleDecodeError(DecodeError::UNEXPECTED_END_OF_BUFFER);
}

char proxygen::StructuredHeadersBuffer::peek ( )

private

Definition at line 277 of file StructuredHeadersBuffer.cpp.

                                   {
  return *content_.begin();
}

DecodeError proxygen::StructuredHeadersBuffer::removeOptionalWhitespace

(

)

Definition at line 247 of file StructuredHeadersBuffer.cpp.

References proxygen::StructuredHeaders::OK.

                                                              {
  while (peek() == ' ' || peek() == '\t') {
    advanceCursor();
  }
  return DecodeError::OK;
}

DecodeError proxygen::StructuredHeadersBuffer::removeSymbol	(	const std::string &	symbol,
		bool	strict
	)

Definition at line 254 of file StructuredHeadersBuffer.cpp.

References proxygen::StructuredHeaders::INVALID_CHARACTER, and proxygen::StructuredHeaders::OK.

Referenced by proxygen::TEST_F().

               {

  if (content_.startsWith(symbol)) {
    content_.advance(symbol.length());
    return DecodeError::OK;
  } else {
    if (strict) {
      // Do some error logging
      return handleDecodeError(DecodeError::INVALID_CHARACTER);
    }
    return DecodeError::INVALID_CHARACTER;
  }
}

Member Data Documentation

folly::StringPiece proxygen::StructuredHeadersBuffer::content_

private

Definition at line 67 of file StructuredHeadersBuffer.h.

folly::StringPiece proxygen::StructuredHeadersBuffer::originalContent_

private

Definition at line 68 of file StructuredHeadersBuffer.h.

---

The documentation for this class was generated from the following files:

• proxygen/lib/http/structuredheaders/StructuredHeadersBuffer.h
• proxygen/lib/http/structuredheaders/StructuredHeadersBuffer.cpp