folly/Uri.cpp

   1 /*
   2  * Copyright 2014 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <folly/Uri.h>
  18
  19 #include <ctype.h>
  20 #include <boost/regex.hpp>
  21
  22 namespace folly {
  23
  24 namespace {
  25
  26 fbstring submatch(const boost::cmatch& m, size_t idx) {
  27   auto& sub = m[idx];
  28   return fbstring(sub.first, sub.second);
  29 }
  30
  31 template <class String>
  32 void toLower(String& s) {
  33   for (auto& c : s) {
  34     c = tolower(c);
  35   }
  36 }
  37
  38 }  // namespace
  39
  40 Uri::Uri(StringPiece str) : port_(0) {
  41   static const boost::regex uriRegex(
  42       "([a-zA-Z][a-zA-Z0-9+.-]*):"  // scheme:
  43       "([^?#]*)"                    // authority and path
  44       "(?:\\?([^#]*))?"             // ?query
  45       "(?:#(.*))?");                // #fragment
  46   static const boost::regex authorityAndPathRegex("//([^/]*)(/.*)?");
  47
  48   boost::cmatch match;
  49   if (UNLIKELY(!boost::regex_match(str.begin(), str.end(), match, uriRegex))) {
  50     throw std::invalid_argument(to<std::string>("invalid URI ", str));
  51   }
  52
  53   scheme_ = submatch(match, 1);
  54   toLower(scheme_);
  55
  56   StringPiece authorityAndPath(match[2].first, match[2].second);
  57   boost::cmatch authorityAndPathMatch;
  58   if (!boost::regex_match(authorityAndPath.begin(),
  59                           authorityAndPath.end(),
  60                           authorityAndPathMatch,
  61                           authorityAndPathRegex)) {
  62     // Does not start with //, doesn't have authority
  63     path_ = authorityAndPath.fbstr();
  64   } else {
  65     static const boost::regex authorityRegex(
  66         "(?:([^@:]*)(?::([^@]*))?@)?"  // username, password
  67         "(\\[[^\\]]*\\]|[^\\[:]*)"     // host (IP-literal (e.g. '['+IPv6+']',
  68                                        // dotted-IPv4, or named host)
  69         "(?::(\\d*))?");               // port
  70
  71     auto authority = authorityAndPathMatch[1];
  72     boost::cmatch authorityMatch;
  73     if (!boost::regex_match(authority.first,
  74                             authority.second,
  75                             authorityMatch,
  76                             authorityRegex)) {
  77       throw std::invalid_argument(
  78           to<std::string>("invalid URI authority ",
  79                           StringPiece(authority.first, authority.second)));
  80     }
  81
  82     StringPiece port(authorityMatch[4].first, authorityMatch[4].second);
  83     if (!port.empty()) {
  84       port_ = to<uint16_t>(port);
  85     }
  86
  87     username_ = submatch(authorityMatch, 1);
  88     password_ = submatch(authorityMatch, 2);
  89     host_ = submatch(authorityMatch, 3);
  90     path_ = submatch(authorityAndPathMatch, 2);
  91   }
  92
  93   query_ = submatch(match, 3);
  94   if (!query_.empty()) {
  95     // Parse query string
  96     static const boost::regex queryParamRegex(
  97       "(^|&)([^=&]*)=?([^=&]*)(?=(&|$))");
  98     boost::cregex_iterator paramBeginItr(
  99       match[3].first,
 100       match[3].second,
 101       queryParamRegex);
 102     boost::cregex_iterator paramEndItr;
 103     for(auto itr = paramBeginItr; itr != paramEndItr; itr++) {
 104       if (itr->length(2) == 0) {
 105         // key is empty, ignore it
 106         continue;
 107       }
 108       queryParams_.emplace_back(
 109         fbstring((*itr)[2].first, (*itr)[2].second), // parameter name
 110         fbstring((*itr)[3].first, (*itr)[3].second)  // parameter value
 111       );
 112     }
 113   }
 114   fragment_ = submatch(match, 4);
 115 }
 116
 117 fbstring Uri::authority() const {
 118   fbstring result;
 119
 120   // Port is 5 characters max and we have up to 3 delimiters.
 121   result.reserve(host().size() + username().size() + password().size() + 8);
 122
 123   if (!username().empty() || !password().empty()) {
 124     result.append(username());
 125
 126     if (!password().empty()) {
 127       result.push_back(':');
 128       result.append(password());
 129     }
 130
 131     result.push_back('@');
 132   }
 133
 134   result.append(host());
 135
 136   if (port() != 0) {
 137     result.push_back(':');
 138     toAppend(port(), &result);
 139   }
 140
 141   return result;
 142 }
 143
 144 fbstring Uri::hostname() const {
 145   if (host_.size() > 0 && host_[0] == '[') {
 146     // If it starts with '[', then it should end with ']', this is ensured by
 147     // regex
 148     return host_.substr(1, host_.size() - 2);
 149   }
 150   return host_;
 151 }
 152
 153 }  // namespace folly