proxygen::ParseURL Class Reference

#include <ParseURL.h>

Public Member Functions
	ParseURL ()
	ParseURL (folly::StringPiece urlVal) noexcept
void	init (folly::StringPiece urlVal)
folly::StringPiece	url () const
folly::StringPiece	scheme () const
std::string	authority () const
bool	hasHost () const
folly::StringPiece	host () const
uint16_t	port () const
std::string	hostAndPort () const
folly::StringPiece	path () const
folly::StringPiece	query () const
folly::StringPiece	fragment () const
bool	valid () const
folly::StringPiece	hostNoBrackets ()
bool	hostIsIPAddress ()
FB_EXPORT void	stripBrackets () noexcept

Private Member Functions
FB_EXPORT void	parse () noexcept
void	parseNonFully () noexcept
bool	parseAuthority () noexcept

Private Attributes
folly::StringPiece	url_
folly::StringPiece	scheme_
std::string	authority_
folly::StringPiece	host_
folly::StringPiece	hostNoBrackets_
folly::StringPiece	path_
folly::StringPiece	query_
folly::StringPiece	fragment_
uint16_t	port_ {0}
bool	valid_ {false}
bool	initialized_ {false}

Detailed Description

Definition at line 22 of file ParseURL.h.

Constructor & Destructor Documentation

proxygen::ParseURL::ParseURL ( )

inline

Definition at line 24 of file ParseURL.h.

{}

proxygen::ParseURL::ParseURL ( folly::StringPiece  urlVal )

inlineexplicitnoexcept

Definition at line 25 of file ParseURL.h.

References init().

                                                      {
    init(urlVal);
  }

Member Function Documentation

std::string proxygen::ParseURL::authority ( ) const

inline

Definition at line 44 of file ParseURL.h.

References authority_.

Referenced by proxygen::HTTPMessage::setQueryString(), and testParseURL().

                              {
    return authority_;
  }

folly::StringPiece proxygen::ParseURL::fragment ( ) const

inline

Definition at line 76 of file ParseURL.h.

References fragment_.

Referenced by proxygen::HTTPMessage::setQueryString(), and proxygen::URL::URL().

                                    {
    return fragment_;
  }

bool proxygen::ParseURL::hasHost ( ) const

inline

Definition at line 48 of file ParseURL.h.

References folly::Range< Iter >::empty(), host_, and valid().

Referenced by proxygen::HTTP1xCodec::onHeadersComplete().

                       {
    return valid() && !host_.empty();
  }

folly::StringPiece proxygen::ParseURL::host ( ) const

inline

Definition at line 52 of file ParseURL.h.

References host_.

Referenced by TEST(), and testParseURL().

                                {
    return host_;
  }

std::string proxygen::ParseURL::hostAndPort ( ) const

inline

Definition at line 60 of file ParseURL.h.

References host_, port_, folly::Range< Iter >::str(), string, and folly::toAppend().

Referenced by proxygen::HTTP1xCodec::onHeadersComplete().

                                {
    std::string rc = host_.str();
    if (port_ != 0) {
      folly::toAppend(":", port_, &rc);
    }
    return rc;
  }

bool proxygen::ParseURL::hostIsIPAddress

(

)

Definition at line 177 of file ParseURL.cpp.

References folly::Range< Iter >::find(), hostNoBrackets_, folly::Range< Iter >::str(), stripBrackets(), and valid_.

Referenced by hostNoBrackets(), and testHostIsIpAddress().

                               {
  if (!valid_) {
    return false;
  }

  stripBrackets();
  int af = hostNoBrackets_.find(':') == std::string::npos ? AF_INET : AF_INET6;
  char buf4[sizeof(in_addr)];
  char buf6[sizeof(in6_addr)];
  // we have to make a copy of hostNoBrackets_ since the string piece is not
  // null-terminated
  return inet_pton(af, hostNoBrackets_.str().c_str(),
                   af == AF_INET ? buf4 : buf6) == 1;
}

folly::StringPiece proxygen::ParseURL::hostNoBrackets ( )

inline

Definition at line 84 of file ParseURL.h.

References FB_EXPORT, hostIsIPAddress(), hostNoBrackets_, folly::pushmi::__adl::noexcept(), parse(), parseAuthority(), parseNonFully(), and stripBrackets().

Referenced by TEST(), and proxygen::URL::URL().

                                    {
    stripBrackets();
    return hostNoBrackets_;
  }

void proxygen::ParseURL::init ( folly::StringPiece  urlVal )

inline

Definition at line 29 of file ParseURL.h.

References initialized_, parse(), and url_.

Referenced by ParseURL().

                                     {
    CHECK(!initialized_);
    url_ = urlVal;
    parse();
    initialized_ = true;
  }

void proxygen::ParseURL::parse ( )

privatenoexcept

Definition at line 60 of file ParseURL.cpp.

References authority_, folly::Range< Iter >::data(), http_parser_url::field_data, fragment_, host_, http_parser_parse_url(), http_parser_url::len, http_parser_url::off, parseNonFully(), path_, http_parser_url::port, port_, query_, scheme_, folly::Range< Iter >::size(), folly::Range< Iter >::str(), folly::Range< Iter >::subpiece(), UF_FRAGMENT, UF_HOST, UF_PATH, UF_QUERY, UF_SCHEMA, url_, valid_, and proxygen::validateScheme().

Referenced by hostNoBrackets(), and init().

                              {
  if (validateScheme(url_)) {
    struct http_parser_url u;
    memset(&u, 0, sizeof(struct http_parser_url)); // init before used
    valid_ = !(http_parser_parse_url(url_.data(), url_.size(), 0, &u));

    if(valid_) {
      // Since we init the http_parser_url with all fields to 0, if the field
      // not present in url, it would be [0, 0], means that this field starts at
      // 0 and len = 0, we will get "" from this.  So no need to check field_set
      // before get field.

      scheme_ = url_.subpiece(u.field_data[UF_SCHEMA].off,
                              u.field_data[UF_SCHEMA].len);

      if(u.field_data[UF_HOST].off != 0 &&
         url_[u.field_data[UF_HOST].off - 1] == '[') {
        // special case: host: [::1]
        host_ = url_.subpiece(u.field_data[UF_HOST].off - 1,
                              u.field_data[UF_HOST].len + 2);
      } else {
        host_ = url_.subpiece(u.field_data[UF_HOST].off,
                              u.field_data[UF_HOST].len);
      }

      port_ = u.port;

      path_ = url_.subpiece(u.field_data[UF_PATH].off,
                            u.field_data[UF_PATH].len);
      query_ = url_.subpiece(u.field_data[UF_QUERY].off,
                             u.field_data[UF_QUERY].len);
      fragment_ = url_.subpiece(u.field_data[UF_FRAGMENT].off,
                                u.field_data[UF_FRAGMENT].len);

      authority_ = (port_) ? folly::to<std::string>(host_, ":", port_)
                           : host_.str();
    }
  } else {
    parseNonFully();
  }
}

bool proxygen::ParseURL::parseAuthority ( )

privatenoexcept

Definition at line 150 of file ParseURL.cpp.

References authority_, host_, and port_.

Referenced by hostNoBrackets(), and parseNonFully().

                                       {
  auto left = authority_.find("[");
  auto right = authority_.find("]");

  auto pos = authority_.find(":", right != std::string::npos ? right : 0);
  if (pos != std::string::npos) {
    try {
      port_ = folly::to<uint16_t>(
        folly::StringPiece(authority_, pos+1, std::string::npos));
    } catch (...) {
      return false;
    }
  }

  if (left == std::string::npos && right == std::string::npos) {
    // not a ipv6 literal
    host_ = folly::StringPiece(authority_, 0, pos);
    return true;
  } else if (left < right && right != std::string::npos) {
    // a ipv6 literal
    host_ = folly::StringPiece(authority_, left, right - left + 1);
    return true;
  } else {
    return false;
  }
}

void proxygen::ParseURL::parseNonFully ( )

privatenoexcept

Definition at line 102 of file ParseURL.cpp.

References authority_, folly::Range< Iter >::empty(), folly::Range< Iter >::find(), fragment_, min, parseAuthority(), path_, query_, folly::Range< Iter >::str(), folly::Range< Iter >::subpiece(), url_, valid_, and proxygen::validateURL().

Referenced by hostNoBrackets(), and parse().

                                      {
  if (url_.empty()) {
    valid_ = false;
    return;
  }

  // Check if the URL has only printable characters and no control character.
  if (!validateURL(url_)) {
    valid_ = false;
    return;
  }

  auto pathStart = url_.find('/');
  auto queryStart = url_.find('?');
  auto hashStart = url_.find('#');

  auto queryEnd = std::min(hashStart, std::string::npos);
  auto pathEnd = std::min(queryStart, hashStart);
  auto authorityEnd = std::min(pathStart, pathEnd);

  authority_ = url_.subpiece(0, authorityEnd).str();

  if (pathStart < pathEnd) {
    path_ = url_.subpiece(pathStart, pathEnd - pathStart);
  } else {
    // missing the '/', e.g. '?query=3'
    path_ = "";
  }

  if (queryStart < queryEnd) {
    query_ = url_.subpiece(queryStart + 1, queryEnd - queryStart - 1);
  } else if (queryStart != std::string::npos && hashStart < queryStart) {
    valid_ = false;
    return;
  }

  if (hashStart != std::string::npos) {
    fragment_ = url_.subpiece(hashStart + 1, std::string::npos);
  }

  if (!parseAuthority()) {
    valid_ = false;
    return;
  }

  valid_ = true;
}

folly::StringPiece proxygen::ParseURL::path ( ) const

inline

Definition at line 68 of file ParseURL.h.

References path_.

Referenced by proxygen::HTTPMessage::setQueryString(), proxygen::HTTPMessage::setURL(), testParseURL(), and proxygen::URL::URL().

                                {
    return path_;
  }

uint16_t proxygen::ParseURL::port ( ) const

inline

Definition at line 56 of file ParseURL.h.

References port_.

Referenced by testParseURL(), and proxygen::URL::URL().

                        {
    return port_;
  }

folly::StringPiece proxygen::ParseURL::query ( ) const

inline

Definition at line 72 of file ParseURL.h.

References query_.

Referenced by proxygen::HTTPMessage::setURL(), testParseURL(), and proxygen::URL::URL().

                                 {
    return query_;
  }

folly::StringPiece proxygen::ParseURL::scheme ( ) const

inline

Definition at line 40 of file ParseURL.h.

References scheme_.

Referenced by proxygen::HTTPMessage::setQueryString(), testParseURL(), and proxygen::URL::URL().

                                  {
    return scheme_;
  }

void proxygen::ParseURL::stripBrackets ( )

noexcept

Definition at line 192 of file ParseURL.cpp.

References folly::Range< Iter >::back(), folly::Range< Iter >::empty(), folly::Range< Iter >::front(), host_, hostNoBrackets_, folly::Range< Iter >::size(), and folly::Range< Iter >::subpiece().

Referenced by hostIsIPAddress(), and hostNoBrackets().

                                      {
  if (hostNoBrackets_.empty()) {
    if (!host_.empty() && host_.front() == '[' && host_.back() == ']') {
      hostNoBrackets_ = host_.subpiece(1, host_.size() - 2);
    } else {
      hostNoBrackets_ = host_;
    }
  }
}

folly::StringPiece proxygen::ParseURL::url ( ) const

inline

Definition at line 36 of file ParseURL.h.

References url_.

Referenced by testParseURL(), and proxygen::URL::URL().

                               {
    return url_;
  }

bool proxygen::ParseURL::valid ( ) const

inline

Definition at line 80 of file ParseURL.h.

References valid_.

Referenced by hasHost(), proxygen::HTTPMessage::setQueryString(), proxygen::HTTPMessage::setURL(), and testParseURL().

                     {
    return valid_;
  }

Member Data Documentation

std::string proxygen::ParseURL::authority_

private

Definition at line 102 of file ParseURL.h.

Referenced by authority(), parse(), parseAuthority(), and parseNonFully().

folly::StringPiece proxygen::ParseURL::fragment_

private

Definition at line 107 of file ParseURL.h.

Referenced by fragment(), parse(), and parseNonFully().

folly::StringPiece proxygen::ParseURL::host_

private

Definition at line 103 of file ParseURL.h.

Referenced by hasHost(), host(), hostAndPort(), parse(), parseAuthority(), and stripBrackets().

folly::StringPiece proxygen::ParseURL::hostNoBrackets_

private

Definition at line 104 of file ParseURL.h.

Referenced by hostIsIPAddress(), hostNoBrackets(), and stripBrackets().

bool proxygen::ParseURL::initialized_ {false}

private

Definition at line 110 of file ParseURL.h.

Referenced by init().

folly::StringPiece proxygen::ParseURL::path_

private

Definition at line 105 of file ParseURL.h.

Referenced by parse(), parseNonFully(), and path().

uint16_t proxygen::ParseURL::port_ {0}

private

Definition at line 108 of file ParseURL.h.

Referenced by hostAndPort(), parse(), parseAuthority(), and port().

folly::StringPiece proxygen::ParseURL::query_

private

Definition at line 106 of file ParseURL.h.

Referenced by parse(), parseNonFully(), and query().

folly::StringPiece proxygen::ParseURL::scheme_

private

Definition at line 101 of file ParseURL.h.

Referenced by parse(), and scheme().

folly::StringPiece proxygen::ParseURL::url_

private

Definition at line 100 of file ParseURL.h.

Referenced by init(), parse(), parseNonFully(), and url().

bool proxygen::ParseURL::valid_ {false}

private

Definition at line 109 of file ParseURL.h.

Referenced by hostIsIPAddress(), parse(), parseNonFully(), and valid().

---

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

• proxygen/lib/utils/ParseURL.h
• proxygen/lib/utils/ParseURL.cpp