Protocol CHttpUrl::CheckProtocol(boost::string_ref const &url, size_t &index) { Protocol protocol; auto pos = url.find("://"); if (pos != url.size()) { if (url.substr(0, pos) == "https") { protocol = Protocol::HTTPS; } else if (url.substr(0, pos) == "http") { protocol = Protocol::HTTP; } else { throw std::invalid_argument("Protocol uncorrect."); } if (index == url.size()) { throw std::invalid_argument("Invalid url was introduced"); } } index = pos + 3; return protocol; }
std::shared_ptr<Response> request(const std::string& request_type, const std::string& path = "/", boost::string_ref content = "", const std::map<std::string, std::string>& header = std::map<std::string, std::string>()) { std::string corrected_path = path; if (corrected_path == "") corrected_path = "/"; boost::asio::streambuf write_buffer; std::ostream write_stream(&write_buffer); write_stream << request_type << " " << corrected_path << " HTTP/1.1\r\n"; write_stream << "Host: " << host << "\r\n"; for (auto& h : header) { write_stream << h.first << ": " << h.second << "\r\n"; } if (content.size()>0) write_stream << "Content-Length: " << content.size() << "\r\n"; write_stream << "\r\n"; try { connect(); boost::asio::write(*socket, write_buffer); if (content.size()>0) boost::asio::write(*socket, boost::asio::buffer(content.data(), content.size())); } catch (const std::exception& e) { socket_error = true; throw std::invalid_argument(e.what()); } return request_read(); }
unsigned short CHttpUrl::ParsePort(boost::string_ref & str) { if (str.front() == ':') { auto portPos = str.find('/'); string port; if (portPos == boost::string_ref::npos) { port = str.substr(1, str.size()).to_string(); } else { port = str.substr(1, portPos - 1).to_string(); } str = str.substr(port.size() + 1, str.size()); bool portOk = !port.empty(); if (portOk) { try { return boost::lexical_cast<unsigned short>(port); } catch (...) { portOk = false; } } if (!portOk) { throw CUrlParsingError("Port parsing error"); } } return 0; }
std::string CHttpUrl::ParseDomain(boost::string_ref & url) { auto domainPos = url.find(':'); if (domainPos == boost::string_ref::npos) { domainPos = url.find("/"); domainPos = (domainPos == boost::string_ref::npos ? url.size() : domainPos); } auto domain = url.substr(0, domainPos).to_string(); url = url.substr(domainPos, url.size()); return domain; }
bool operator()(const boost::string_ref& strRef1, const boost::string_ref& strRef2) const { auto oneSize = strRef1.size(); auto twoSize = strRef2.size(); if (oneSize != twoSize) { return false; } return std::memcmp(strRef1.begin(), strRef2.begin(), oneSize) == 0; }
void on_request( boost::string_ref const& method_, boost::string_ref const& path_, int version_, error_code& ec) { method = std::string( method_.data(), method_.size()); path = std::string( path_.data(), path_.size()); version = version_; got_on_begin = true; if(fc_) fc_->fail(ec); }
table_features( std::uint8_t const table_id , boost::string_ref const name , std::uint64_t const metadata_match , std::uint64_t const metadata_write , std::uint32_t const config , std::uint32_t const max_entries , properties_type properties) : table_features_{ properties.calc_ofp_length(sizeof(ofp_type)) , table_id , { 0, 0, 0, 0, 0 } , "" , metadata_match , metadata_write , config , max_entries } , properties_(std::move(properties)) { auto const name_size = std::min(name.size(), sizeof(table_features_.name) - 1); using boost::adaptors::sliced; boost::copy(name | sliced(0, name_size), table_features_.name); }
void CInfixExpressionCalculator::SkipSpaces(boost::string_ref &ref) { size_t i = 0; while (i < ref.size() && std::isspace(ref[i])) ++i; ref.remove_prefix(i); }
std::vector<std::pair<boost::string_ref, boost::string_ref>>::const_iterator find(const boost::string_ref key) const { return std::find_if(m_collection.begin(), m_collection.end(), [key](const std::pair<boost::string_ref, boost::string_ref>& str)-> bool { auto oneSize = str.first.size(); auto twoSize = key.size(); if (oneSize != twoSize) { return false; } if (oneSize >= 4) { if ((str.first[0] == key[0]) && (str.first[1] == key[1]) && (str.first[oneSize - 1] == key[oneSize - 1]) && (str.first[oneSize - 2] == key[oneSize - 2])) { return std::memcmp(str.first.begin(), key.begin(), oneSize) == 0; } } else { return std::memcmp(str.first.begin(), key.begin(), oneSize) == 0; } return false; } ); }
inline boost::string_ref remove_leading_spaces(boost::string_ref string, const char* spaces = " \t\r\n") { auto pos = string.find_first_not_of(spaces); if (pos == std::string::npos) pos = string.size(); string.remove_prefix(pos); return string; }
void DatabaseImpl::checkSimpleArgumentFor(const boost::string_ref& key, partNum_t partNum) const { RAISE_INVALID_ARGUMENT_IF(key.size() > MAX_KEY_SIZE, "key too long"); RAISE_INVALID_ARGUMENT_IF(key.empty(), "empty key is not allowed"); RAISE_INVALID_ARGUMENT_IF(partNum > MAX_PARTNUM, "partNum is too large"); RAISE_INVALID_ARGUMENT_IF(partNum == ALL_PARTS, "partNum ALL_PARTS is not allowed"); RAISE_INVALID_ARGUMENT_IF(partNum < 0, "negative partNum is not allowed"); }
unsigned short CHttpUrl::ParsePort(boost::string_ref const &url, size_t index) { std::string port; if (index == url.size() || (index < url.size() && !isdigit(url[index]))) { throw CUrlParsingError("Unknown port in the url address"); } for (; index != url.size(); ++index) { if (!isdigit(url[index])) { break; } port += url[index]; } return static_cast<unsigned short>(atoi(port.c_str())); }
SimpleTemplate::SimpleTemplate(boost::string_ref text) { static char const rawMarker[] = "@@"; static boost::string_ref const marker(rawMarker, sizeof(rawMarker) - 1); auto beg = text.find(marker); while (beg != boost::string_ref::npos) { m_literals.emplace_back(text.data(), beg); text.remove_prefix(beg + marker.size()); auto end = text.find(marker); if (end == boost::string_ref::npos) { std::string& lit = m_literals.back(); lit.reserve(lit.size() + marker.size() + text.size()); lit.append(marker.data(), marker.size()); lit.append(text.data(), text.size()); assert(m_literals.size() == m_insertionKeys.size() + 1); return; } m_insertionKeys.emplace_back(text.data(), end); text.remove_prefix(end + marker.size()); beg = text.find(marker); } m_literals.emplace_back(text.data(), text.size()); assert(m_literals.size() == m_insertionKeys.size() + 1); }
std::string CHttpUrl::ParseDomainName(boost::string_ref const &url, size_t &index) { for (size_t i = 0; i != url.size(); ++i) { if (url[i] == '/') { index += i; return std::string(url.substr(0, i)); } if (url[i] == ':') { m_port = ParsePort(url, i + 1); return std::string(url.substr(0, i)); } } index += url.size(); return std::string(url); }
inline boost::string_ref extract_word(boost::string_ref string) { const char spaces[] = " \t\r\n"; string = remove_leading_spaces(string, spaces); auto new_size = string.find_first_of(spaces); if (new_size == boost::string_ref::npos) new_size = string.size(); return boost::string_ref(string.data(), new_size); }
void on_response(int status_, boost::string_ref const& reason_, int version_, error_code& ec) { status = status_; reason = std::string( reason_.data(), reason_.size()); version = version_; got_on_begin = true; if(fc_) fc_->fail(ec); }
Protocol CHttpUrl::ParseProtocol(boost::string_ref & str) { const string schemeDelimiter = "://"; auto schemePos = str.find(schemeDelimiter); if (schemePos == boost::string_ref::npos) { throw CUrlParsingError("Protocol parsing error"); } string protocol = str.substr(0, schemePos).to_string(); str = str.substr(schemePos + schemeDelimiter.size() , str.size() - 1); return ToProtocol(protocol); }
void url:: rebuild(const boost::string_ref &scheme, const boost::optional<boost::string_ref> &host, const boost::optional<uint16_t> &port, const boost::optional<boost::string_ref> &path, const boost::optional<boost::string_ref> &query, const boost::optional<boost::string_ref> &fragment, const boost::optional<boost::string_ref> &user_info) { std::string str; str.append(scheme.data(), scheme.size()); if (has_authority()) { str.append("://"); if (user_info) { str.append(user_info->data(), user_info->size()); str.append("@"); } str.append(host->data(), host->size()); if (port) { str.append(":"); str.append(std::to_string(*port)); } } else { str.append(":"); } if (path) { str.append(path->data(), path->size()); } if (query) { str.append("?"); str.append(query->data(), query->size()); } if (fragment) { str.append("#"); str.append(fragment->data(), fragment->size()); } url new_url { std::move(str) }; swap(new_url); }
inline bool drive_letter_exists(Iterator itr, Iterator end) { boost::string_ref const str( ":\\" ); if( std::distance( itr, end ) < static_cast< std::ptrdiff_t >( str.size() + 1 ) ) { return false; } for( int i = 'A'; i <= 'Z'; ++i ) { if( *itr == i ) { return std::equal( str.begin(), str.end(), itr + 1 ); } } return false; }
size_type DataPage::addSingleRecord(const boost::string_ref& recordInlineData) { const size_type recordInlineSize = static_cast<size_type>(recordInlineData.size()); const bool canAdd = freeSpace() >= sizeof(uint16_t) + recordInlineSize; if (canAdd) { // Compute offsets. const size_type endOfFreeArea = getEndOfFreeArea(); const size_type recordOffset = endOfFreeArea - recordInlineSize; // Copy the record, add pointer to its start and adjust "end of free area". putBytes(recordOffset, recordInlineData); addRecordOffset(recordOffset); setEndOfFreeArea(recordOffset); } return (canAdd)? recordInlineSize : 0; }
std::string encode_string(boost::string_ref str) { std::string result; result.reserve(str.size()); for (boost::string_ref::const_iterator it = str.begin(); it != str.end(); ++it) { switch (*it) { case '<': result += "<"; break; case '>': result += ">"; break; case '&': result += "&"; break; case '"': result += """; break; default: result += *it; break; } } return result; }
std::string escaped_string(boost::string_ref const& s) { std::string out; out.reserve(s.size()); char const* p = s.data(); while(p != s.end()) { if(*p == '\r') out.append("\\r"); else if(*p == '\n') out.append("\\n"); else if(*p == '\t') out.append("\\t"); else out.append(p, 1); ++p; } return out; }
bool server::p_raw(const boost::string_ref &raw) { char tbuf[4096]; if (!raw.empty()) { if (raw.size() < sizeof (tbuf) - 3) { auto len = snprintf(tbuf, sizeof(tbuf), "%s\r\n", raw.data()); if (len < 0) { PrintText(current_sess, _("Unable to send message to server, and error has occurred")); return false; } tcp_send_len(*this, boost::string_ref{ tbuf, static_cast<std::size_t>(len)}); } else { tcp_send_len (*this, raw); tcp_send_len(*this, boost::string_ref{ "\r\n", 2 }); } return true; } return false; }
void stringoutput (boost::string_ref const& bytes) { markstarted (); std::size_t position = 0, writtenuntil = 0; output_ ({"e, 1}); auto data = bytes.data(); for (; position < bytes.size(); ++position) { auto i = jsonspecialcharacterescape.find (data[position]); if (i != jsonspecialcharacterescape.end ()) { if (writtenuntil < position) { output_ ({data + writtenuntil, position - writtenuntil}); } output_ ({i->second, jsonescapelength}); writtenuntil = position + 1; }; } if (writtenuntil < position) output_ ({data + writtenuntil, position - writtenuntil}); output_ ({"e, 1}); }
explicit message(boost::string_ref str) : message(boost::asio::buffer(str.data(), str.size())) { }
void on_body(boost::string_ref const& s, error_code& ec) { r_.write(s.data(), s.size(), ec); }
bool HttpAbpBaseFilter::IsMatch(boost::string_ref data, const HttpAbpFilterSettings dataSettings, boost::string_ref dataHost) const { if (!SettingsApply(dataSettings, m_settings)) { return false; } size_t i = 0; auto len = m_ruleParts.size(); size_t lastMatch = 0; for (i = 0; i < m_ruleParts.size(); ++i) { switch (m_rulePartTypes[i]) { // Anchored address matching is basically a confusing way to say that we // must match against the host of the request, AFAIK. // // However, we have a double wammy. If we match against the host, we // need to then find that same matched string in the full request and // substring the data from beyond our matched address string. This is a // PITA and a bit of a waste, but we check the dataHost member first // specifically, to avoid false positives, such as Google search results // that embed a URL we're trying to match against in GET parameters. case RulePartType::AnchoredAddress: { auto hostLen = dataHost.size(); auto plen = m_ruleParts[i].size(); if (plen <= hostLen) { auto res = dataHost.find(m_ruleParts[i]); if (res != boost::string_ref::npos) { auto hostInReqPos = data.find(dataHost); if (hostInReqPos != boost::string_ref::npos) { lastMatch = hostInReqPos + res + plen; continue; } } } return false; } break; case RulePartType::Wildcard: { // Wildcard, so as long as we have one additional character, we can move on. if (lastMatch + 1 <= data.size()) { ++lastMatch; continue; } return false; } break; case RulePartType::Separator: { if (lastMatch < data.size()) { data = data.substr(lastMatch); auto sepPosition = data.find_first_of(SeparatorStrRef); if (sepPosition != boost::string_ref::npos) { lastMatch = sepPosition + 1; continue; } } return false; } break; case RulePartType::StringLiteral: { if (lastMatch < data.size()) { data = data.substr(lastMatch); size_t literalTextPosition = data.find(m_ruleParts[i]); if(literalTextPosition != boost::string_ref::npos) { lastMatch = literalTextPosition + m_ruleParts[i].size(); continue; } } return false; } break; // Must be an exact match. case RulePartType::RequestLiteralMatch: { return util::string::Equal(data, m_ruleParts[i]); } break; // Basically just a substring match against the start of the request. case RulePartType::RequestLiteralPartialMatch: { auto plen = m_ruleParts[i].size(); auto reqSize = data.size(); if (plen <= reqSize) { auto sub = data.substr(0, plen); if (util::string::Equal(m_ruleParts[i], sub)) { lastMatch = plen; continue; } } return false; } break; } } // All matches were found successfully so, we matched return true; }
DataPage::AddedValueRef::AddedValueRef(const boost::string_ref& value) : valueSizeOrTag_(static_cast<uint16_t>(value.size())) , valueReference_(value) , largeValueRef_(0LL) { }
void on_data(boost::string_ref const& s, error_code& ec) { body.append(s.data(), s.size()); }
void operator()(clmdep_msgpack::object& o, const boost::string_ref& v) const { uint32_t size = checked_get_container_size(v.size()); o.type = clmdep_msgpack::type::STR; o.via.str.ptr = v.data(); o.via.str.size = size; }