url/gurl.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifdef WIN32
   6 #include <windows.h>
   7 #else
   8 #include <pthread.h>
   9 #endif
  10
  11 #include <algorithm>
  12 #include <ostream>
  13
  14 #include "url/gurl.h"
  15
  16 #include "base/logging.h"
  17 #include "url/url_canon_stdstring.h"
  18 #include "url/url_util.h"
  19
  20 namespace {
  21
  22 static std::string* empty_string = NULL;
  23 static GURL* empty_gurl = NULL;
  24
  25 #ifdef WIN32
  26
  27 // Returns a static reference to an empty string for returning a reference
  28 // when there is no underlying string.
  29 const std::string& EmptyStringForGURL() {
  30   // Avoid static object construction/destruction on startup/shutdown.
  31   if (!empty_string) {
  32     // Create the string. Be careful that we don't break in the case that this
  33     // is being called from multiple threads. Statics are not threadsafe.
  34     std::string* new_empty_string = new std::string;
  35     if (InterlockedCompareExchangePointer(
  36         reinterpret_cast<PVOID*>(&empty_string), new_empty_string, NULL)) {
  37       // The old value was non-NULL, so no replacement was done. Another
  38       // thread did the initialization out from under us.
  39       delete new_empty_string;
  40     }
  41   }
  42   return *empty_string;
  43 }
  44
  45 #else
  46
  47 static pthread_once_t empty_string_once = PTHREAD_ONCE_INIT;
  48 static pthread_once_t empty_gurl_once = PTHREAD_ONCE_INIT;
  49
  50 void EmptyStringForGURLOnce(void) {
  51   empty_string = new std::string;
  52 }
  53
  54 const std::string& EmptyStringForGURL() {
  55   // Avoid static object construction/destruction on startup/shutdown.
  56   pthread_once(&empty_string_once, EmptyStringForGURLOnce);
  57   return *empty_string;
  58 }
  59
  60 #endif  // WIN32
  61
  62 } // namespace
  63
  64 GURL::GURL() : is_valid_(false) {
  65 }
  66
  67 GURL::GURL(const GURL& other)
  68     : spec_(other.spec_),
  69       is_valid_(other.is_valid_),
  70       parsed_(other.parsed_) {
  71   if (other.inner_url_)
  72     inner_url_.reset(new GURL(*other.inner_url_));
  73   // Valid filesystem urls should always have an inner_url_.
  74   DCHECK(!is_valid_ || !SchemeIsFileSystem() || inner_url_);
  75 }
  76
  77 GURL::GURL(const std::string& url_string) {
  78   InitCanonical(url_string, true);
  79 }
  80
  81 GURL::GURL(const base::string16& url_string) {
  82   InitCanonical(url_string, true);
  83 }
  84
  85 GURL::GURL(const std::string& url_string, RetainWhiteSpaceSelector) {
  86   InitCanonical(url_string, false);
  87 }
  88
  89 GURL::GURL(const char* canonical_spec, size_t canonical_spec_len,
  90            const url_parse::Parsed& parsed, bool is_valid)
  91     : spec_(canonical_spec, canonical_spec_len),
  92       is_valid_(is_valid),
  93       parsed_(parsed) {
  94   InitializeFromCanonicalSpec();
  95 }
  96
  97 GURL::GURL(std::string canonical_spec,
  98            const url_parse::Parsed& parsed, bool is_valid)
  99     : is_valid_(is_valid),
 100       parsed_(parsed) {
 101   spec_.swap(canonical_spec);
 102   InitializeFromCanonicalSpec();
 103 }
 104
 105 template<typename STR>
 106 void GURL::InitCanonical(const STR& input_spec, bool trim_path_end) {
 107   // Reserve enough room in the output for the input, plus some extra so that
 108   // we have room if we have to escape a few things without reallocating.
 109   spec_.reserve(input_spec.size() + 32);
 110   url_canon::StdStringCanonOutput output(&spec_);
 111   is_valid_ = url_util::Canonicalize(
 112       input_spec.data(), static_cast<int>(input_spec.length()), trim_path_end,
 113       NULL, &output, &parsed_);
 114
 115   output.Complete();  // Must be done before using string.
 116   if (is_valid_ && SchemeIsFileSystem()) {
 117     inner_url_.reset(new GURL(spec_.data(), parsed_.Length(),
 118                               *parsed_.inner_parsed(), true));
 119   }
 120 }
 121
 122 void GURL::InitializeFromCanonicalSpec() {
 123   if (is_valid_ && SchemeIsFileSystem()) {
 124     inner_url_.reset(
 125         new GURL(spec_.data(), parsed_.Length(),
 126                  *parsed_.inner_parsed(), true));
 127   }
 128
 129 #ifndef NDEBUG
 130   // For testing purposes, check that the parsed canonical URL is identical to
 131   // what we would have produced. Skip checking for invalid URLs have no meaning
 132   // and we can't always canonicalize then reproducabely.
 133   if (is_valid_) {
 134     url_parse::Component scheme;
 135     // We can't do this check on the inner_url of a filesystem URL, as
 136     // canonical_spec actually points to the start of the outer URL, so we'd
 137     // end up with infinite recursion in this constructor.
 138     if (!url_util::FindAndCompareScheme(spec_.data(), spec_.length(),
 139                                         "filesystem", &scheme) ||
 140         scheme.begin == parsed_.scheme.begin) {
 141       // We need to retain trailing whitespace on path URLs, as the |parsed_|
 142       // spec we originally received may legitimately contain trailing white-
 143       // space on the path or  components e.g. if the #ref has been
 144       // removed from a "foo:hello #ref" URL (see http://crbug.com/291747).
 145       GURL test_url(spec_, RETAIN_TRAILING_PATH_WHITEPACE);
 146
 147       DCHECK(test_url.is_valid_ == is_valid_);
 148       DCHECK(test_url.spec_ == spec_);
 149
 150       DCHECK(test_url.parsed_.scheme == parsed_.scheme);
 151       DCHECK(test_url.parsed_.username == parsed_.username);
 152       DCHECK(test_url.parsed_.password == parsed_.password);
 153       DCHECK(test_url.parsed_.host == parsed_.host);
 154       DCHECK(test_url.parsed_.port == parsed_.port);
 155       DCHECK(test_url.parsed_.path == parsed_.path);
 156       DCHECK(test_url.parsed_.query == parsed_.query);
 157       DCHECK(test_url.parsed_.ref == parsed_.ref);
 158     }
 159   }
 160 #endif
 161 }
 162
 163 GURL::~GURL() {
 164 }
 165
 166 GURL& GURL::operator=(GURL other) {
 167   Swap(&other);
 168   return *this;
 169 }
 170
 171 const std::string& GURL::spec() const {
 172   if (is_valid_ || spec_.empty())
 173     return spec_;
 174
 175   DCHECK(false) << "Trying to get the spec of an invalid URL!";
 176   return EmptyStringForGURL();
 177 }
 178
 179 GURL GURL::Resolve(const std::string& relative) const {
 180   return ResolveWithCharsetConverter(relative, NULL);
 181 }
 182 GURL GURL::Resolve(const base::string16& relative) const {
 183   return ResolveWithCharsetConverter(relative, NULL);
 184 }
 185
 186 // Note: code duplicated below (it's inconvenient to use a template here).
 187 GURL GURL::ResolveWithCharsetConverter(
 188     const std::string& relative,
 189     url_canon::CharsetConverter* charset_converter) const {
 190   // Not allowed for invalid URLs.
 191   if (!is_valid_)
 192     return GURL();
 193
 194   GURL result;
 195
 196   // Reserve enough room in the output for the input, plus some extra so that
 197   // we have room if we have to escape a few things without reallocating.
 198   result.spec_.reserve(spec_.size() + 32);
 199   url_canon::StdStringCanonOutput output(&result.spec_);
 200
 201   if (!url_util::ResolveRelative(
 202           spec_.data(), static_cast<int>(spec_.length()), parsed_,
 203           relative.data(), static_cast<int>(relative.length()),
 204           charset_converter, &output, &result.parsed_)) {
 205     // Error resolving, return an empty URL.
 206     return GURL();
 207   }
 208
 209   output.Complete();
 210   result.is_valid_ = true;
 211   if (result.SchemeIsFileSystem()) {
 212     result.inner_url_.reset(
 213         new GURL(result.spec_.data(), result.parsed_.Length(),
 214                  *result.parsed_.inner_parsed(), true));
 215   }
 216   return result;
 217 }
 218
 219 // Note: code duplicated above (it's inconvenient to use a template here).
 220 GURL GURL::ResolveWithCharsetConverter(
 221     const base::string16& relative,
 222     url_canon::CharsetConverter* charset_converter) const {
 223   // Not allowed for invalid URLs.
 224   if (!is_valid_)
 225     return GURL();
 226
 227   GURL result;
 228
 229   // Reserve enough room in the output for the input, plus some extra so that
 230   // we have room if we have to escape a few things without reallocating.
 231   result.spec_.reserve(spec_.size() + 32);
 232   url_canon::StdStringCanonOutput output(&result.spec_);
 233
 234   if (!url_util::ResolveRelative(
 235           spec_.data(), static_cast<int>(spec_.length()), parsed_,
 236           relative.data(), static_cast<int>(relative.length()),
 237           charset_converter, &output, &result.parsed_)) {
 238     // Error resolving, return an empty URL.
 239     return GURL();
 240   }
 241
 242   output.Complete();
 243   result.is_valid_ = true;
 244   if (result.SchemeIsFileSystem()) {
 245     result.inner_url_.reset(
 246         new GURL(result.spec_.data(), result.parsed_.Length(),
 247                  *result.parsed_.inner_parsed(), true));
 248   }
 249   return result;
 250 }
 251
 252 // Note: code duplicated below (it's inconvenient to use a template here).
 253 GURL GURL::ReplaceComponents(
 254     const url_canon::Replacements<char>& replacements) const {
 255   GURL result;
 256
 257   // Not allowed for invalid URLs.
 258   if (!is_valid_)
 259     return GURL();
 260
 261   // Reserve enough room in the output for the input, plus some extra so that
 262   // we have room if we have to escape a few things without reallocating.
 263   result.spec_.reserve(spec_.size() + 32);
 264   url_canon::StdStringCanonOutput output(&result.spec_);
 265
 266   result.is_valid_ = url_util::ReplaceComponents(
 267       spec_.data(), static_cast<int>(spec_.length()), parsed_, replacements,
 268       NULL, &output, &result.parsed_);
 269
 270   output.Complete();
 271   if (result.is_valid_ && result.SchemeIsFileSystem()) {
 272     result.inner_url_.reset(new GURL(spec_.data(), result.parsed_.Length(),
 273                                      *result.parsed_.inner_parsed(), true));
 274   }
 275   return result;
 276 }
 277
 278 // Note: code duplicated above (it's inconvenient to use a template here).
 279 GURL GURL::ReplaceComponents(
 280     const url_canon::Replacements<base::char16>& replacements) const {
 281   GURL result;
 282
 283   // Not allowed for invalid URLs.
 284   if (!is_valid_)
 285     return GURL();
 286
 287   // Reserve enough room in the output for the input, plus some extra so that
 288   // we have room if we have to escape a few things without reallocating.
 289   result.spec_.reserve(spec_.size() + 32);
 290   url_canon::StdStringCanonOutput output(&result.spec_);
 291
 292   result.is_valid_ = url_util::ReplaceComponents(
 293       spec_.data(), static_cast<int>(spec_.length()), parsed_, replacements,
 294       NULL, &output, &result.parsed_);
 295
 296   output.Complete();
 297   if (result.is_valid_ && result.SchemeIsFileSystem()) {
 298     result.inner_url_.reset(new GURL(spec_.data(), result.parsed_.Length(),
 299                                      *result.parsed_.inner_parsed(), true));
 300   }
 301   return result;
 302 }
 303
 304 GURL GURL::GetOrigin() const {
 305   // This doesn't make sense for invalid or nonstandard URLs, so return
 306   // the empty URL
 307   if (!is_valid_ || !IsStandard())
 308     return GURL();
 309
 310   if (SchemeIsFileSystem())
 311     return inner_url_->GetOrigin();
 312
 313   url_canon::Replacements<char> replacements;
 314   replacements.ClearUsername();
 315   replacements.ClearPassword();
 316   replacements.ClearPath();
 317   replacements.ClearQuery();
 318   replacements.ClearRef();
 319
 320   return ReplaceComponents(replacements);
 321 }
 322
 323 GURL GURL::GetAsReferrer() const {
 324   if (!is_valid_ ||
 325       (!has_ref() && !has_username() && !has_password()))
 326     return GURL(*this);
 327
 328   url_canon::Replacements<char> replacements;
 329   replacements.ClearRef();
 330   replacements.ClearUsername();
 331   replacements.ClearPassword();
 332   return ReplaceComponents(replacements);
 333 }
 334
 335 GURL GURL::GetWithEmptyPath() const {
 336   // This doesn't make sense for invalid or nonstandard URLs, so return
 337   // the empty URL.
 338   if (!is_valid_ || !IsStandard())
 339     return GURL();
 340
 341   // We could optimize this since we know that the URL is canonical, and we are
 342   // appending a canonical path, so avoiding re-parsing.
 343   GURL other(*this);
 344   if (parsed_.path.len == 0)
 345     return other;
 346
 347   // Clear everything after the path.
 348   other.parsed_.query.reset();
 349   other.parsed_.ref.reset();
 350
 351   // Set the path, since the path is longer than one, we can just set the
 352   // first character and resize.
 353   other.spec_[other.parsed_.path.begin] = '/';
 354   other.parsed_.path.len = 1;
 355   other.spec_.resize(other.parsed_.path.begin + 1);
 356   return other;
 357 }
 358
 359 bool GURL::IsStandard() const {
 360   return url_util::IsStandard(spec_.data(), parsed_.scheme);
 361 }
 362
 363 bool GURL::SchemeIs(const char* lower_ascii_scheme) const {
 364   if (parsed_.scheme.len <= 0)
 365     return lower_ascii_scheme == NULL;
 366   return url_util::LowerCaseEqualsASCII(spec_.data() + parsed_.scheme.begin,
 367                                         spec_.data() + parsed_.scheme.end(),
 368                                         lower_ascii_scheme);
 369 }
 370
 371 bool GURL::SchemeIsHTTPOrHTTPS() const {
 372   return SchemeIs("http") || SchemeIs("https");
 373 }
 374
 375 bool GURL::SchemeIsWSOrWSS() const {
 376   return SchemeIs("ws") || SchemeIs("wss");
 377 }
 378
 379 int GURL::IntPort() const {
 380   if (parsed_.port.is_nonempty())
 381     return url_parse::ParsePort(spec_.data(), parsed_.port);
 382   return url_parse::PORT_UNSPECIFIED;
 383 }
 384
 385 int GURL::EffectiveIntPort() const {
 386   int int_port = IntPort();
 387   if (int_port == url_parse::PORT_UNSPECIFIED && IsStandard())
 388     return url_canon::DefaultPortForScheme(spec_.data() + parsed_.scheme.begin,
 389                                            parsed_.scheme.len);
 390   return int_port;
 391 }
 392
 393 std::string GURL::ExtractFileName() const {
 394   url_parse::Component file_component;
 395   url_parse::ExtractFileName(spec_.data(), parsed_.path, &file_component);
 396   return ComponentString(file_component);
 397 }
 398
 399 std::string GURL::PathForRequest() const {
 400   DCHECK(parsed_.path.len > 0) << "Canonical path for requests should be non-empty";
 401   if (parsed_.ref.len >= 0) {
 402     // Clip off the reference when it exists. The reference starts after the #
 403     // sign, so we have to subtract one to also remove it.
 404     return std::string(spec_, parsed_.path.begin,
 405                        parsed_.ref.begin - parsed_.path.begin - 1);
 406   }
 407   // Compute the actual path length, rather than depending on the spec's
 408   // terminator.  If we're an inner_url, our spec continues on into our outer
 409   // url's path/query/ref.
 410   int path_len = parsed_.path.len;
 411   if (parsed_.query.is_valid())
 412     path_len = parsed_.query.end() - parsed_.path.begin;
 413
 414   return std::string(spec_, parsed_.path.begin, path_len);
 415 }
 416
 417 std::string GURL::HostNoBrackets() const {
 418   // If host looks like an IPv6 literal, strip the square brackets.
 419   url_parse::Component h(parsed_.host);
 420   if (h.len >= 2 && spec_[h.begin] == '[' && spec_[h.end() - 1] == ']') {
 421     h.begin++;
 422     h.len -= 2;
 423   }
 424   return ComponentString(h);
 425 }
 426
 427 std::string GURL::GetContent() const {
 428   return is_valid_ ? ComponentString(parsed_.GetContent()) : std::string();
 429 }
 430
 431 bool GURL::HostIsIPAddress() const {
 432   if (!is_valid_ || spec_.empty())
 433      return false;
 434
 435   url_canon::RawCanonOutputT<char, 128> ignored_output;
 436   url_canon::CanonHostInfo host_info;
 437   url_canon::CanonicalizeIPAddress(spec_.c_str(), parsed_.host,
 438                                    &ignored_output, &host_info);
 439   return host_info.IsIPAddress();
 440 }
 441
 442 #ifdef WIN32
 443
 444 const GURL& GURL::EmptyGURL() {
 445   // Avoid static object construction/destruction on startup/shutdown.
 446   if (!empty_gurl) {
 447     // Create the string. Be careful that we don't break in the case that this
 448     // is being called from multiple threads.
 449     GURL* new_empty_gurl = new GURL;
 450     if (InterlockedCompareExchangePointer(
 451         reinterpret_cast<PVOID*>(&empty_gurl), new_empty_gurl, NULL)) {
 452       // The old value was non-NULL, so no replacement was done. Another
 453       // thread did the initialization out from under us.
 454       delete new_empty_gurl;
 455     }
 456   }
 457   return *empty_gurl;
 458 }
 459
 460 #else
 461
 462 void EmptyGURLOnce(void) {
 463   empty_gurl = new GURL;
 464 }
 465
 466 const GURL& GURL::EmptyGURL() {
 467   // Avoid static object construction/destruction on startup/shutdown.
 468   pthread_once(&empty_gurl_once, EmptyGURLOnce);
 469   return *empty_gurl;
 470 }
 471
 472 #endif  // WIN32
 473
 474 bool GURL::DomainIs(const char* lower_ascii_domain,
 475                     int domain_len) const {
 476   // Return false if this URL is not valid or domain is empty.
 477   if (!is_valid_ || !domain_len)
 478     return false;
 479
 480   // FileSystem URLs have empty parsed_.host, so check this first.
 481   if (SchemeIsFileSystem() && inner_url_)
 482     return inner_url_->DomainIs(lower_ascii_domain, domain_len);
 483
 484   if (!parsed_.host.is_nonempty())
 485     return false;
 486
 487   // Check whether the host name is end with a dot. If yes, treat it
 488   // the same as no-dot unless the input comparison domain is end
 489   // with dot.
 490   const char* last_pos = spec_.data() + parsed_.host.end() - 1;
 491   int host_len = parsed_.host.len;
 492   if ('.' == *last_pos && '.' != lower_ascii_domain[domain_len - 1]) {
 493     last_pos--;
 494     host_len--;
 495   }
 496
 497   // Return false if host's length is less than domain's length.
 498   if (host_len < domain_len)
 499     return false;
 500
 501   // Compare this url whether belong specific domain.
 502   const char* start_pos = spec_.data() + parsed_.host.begin +
 503                           host_len - domain_len;
 504
 505   if (!url_util::LowerCaseEqualsASCII(start_pos,
 506                                       last_pos + 1,
 507                                       lower_ascii_domain,
 508                                       lower_ascii_domain + domain_len))
 509     return false;
 510
 511   // Check whether host has right domain start with dot, make sure we got
 512   // right domain range. For example www.google.com has domain
 513   // "google.com" but www.iamnotgoogle.com does not.
 514   if ('.' != lower_ascii_domain[0] && host_len > domain_len &&
 515       '.' != *(start_pos - 1))
 516     return false;
 517
 518   return true;
 519 }
 520
 521 void GURL::Swap(GURL* other) {
 522   spec_.swap(other->spec_);
 523   std::swap(is_valid_, other->is_valid_);
 524   std::swap(parsed_, other->parsed_);
 525   inner_url_.swap(other->inner_url_);
 526 }
 527
 528 std::ostream& operator<<(std::ostream& out, const GURL& url) {
 529   return out << url.possibly_invalid_spec();
 530 }