url/url_canon_stdurl.cc

   1 // Copyright 2013 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Functions to canonicalize "standard" URLs, which are ones that have an
   6 // authority section including a host name.
   7
   8 #include "url/url_canon.h"
   9 #include "url/url_canon_internal.h"
  10 #include "url/url_constants.h"
  11
  12 namespace url {
  13
  14 namespace {
  15
  16 template <typename CHAR, typename UCHAR>
  17 bool DoCanonicalizeStandardURL(const URLComponentSource<CHAR>& source,
  18                                const Parsed& parsed,
  19                                SchemeType scheme_type,
  20                                CharsetConverter* query_converter,
  21                                CanonOutput* output,
  22                                Parsed* new_parsed) {
  23   // Scheme: this will append the colon.
  24   bool success = CanonicalizeScheme(source.scheme, parsed.scheme,
  25                                     output, &new_parsed->scheme);
  26
  27   bool scheme_supports_user_info =
  28       (scheme_type == SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION);
  29   bool scheme_supports_ports =
  30       (scheme_type == SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION ||
  31        scheme_type == SCHEME_WITH_HOST_AND_PORT);
  32
  33   // Authority (username, password, host, port)
  34   bool have_authority;
  35   if ((scheme_supports_user_info &&
  36        (parsed.username.is_valid() || parsed.password.is_valid())) ||
  37       parsed.host.is_nonempty() ||
  38       (scheme_supports_ports && parsed.port.is_valid())) {
  39     have_authority = true;
  40
  41     // Only write the authority separators when we have a scheme.
  42     if (parsed.scheme.is_valid()) {
  43       output->push_back('/');
  44       output->push_back('/');
  45     }
  46
  47     // User info: the canonicalizer will handle the : and @.
  48     if (scheme_supports_user_info) {
  49       success &= CanonicalizeUserInfo(
  50           source.username, parsed.username, source.password, parsed.password,
  51           output, &new_parsed->username, &new_parsed->password);
  52     } else {
  53       new_parsed->username.reset();
  54       new_parsed->password.reset();
  55     }
  56
  57     success &= CanonicalizeHost(source.host, parsed.host,
  58                                 output, &new_parsed->host);
  59
  60     // Host must not be empty for standard URLs.
  61     if (parsed.host.is_empty())
  62       success = false;
  63
  64     // Port: the port canonicalizer will handle the colon.
  65     if (scheme_supports_ports) {
  66       int default_port = DefaultPortForScheme(
  67           &output->data()[new_parsed->scheme.begin], new_parsed->scheme.len);
  68       success &= CanonicalizePort(source.port, parsed.port, default_port,
  69                                   output, &new_parsed->port);
  70     } else {
  71       new_parsed->port.reset();
  72     }
  73   } else {
  74     // No authority, clear the components.
  75     have_authority = false;
  76     new_parsed->host.reset();
  77     new_parsed->username.reset();
  78     new_parsed->password.reset();
  79     new_parsed->port.reset();
  80     success = false;  // Standard URLs must have an authority.
  81   }
  82
  83   // Path
  84   if (parsed.path.is_valid()) {
  85     success &= CanonicalizePath(source.path, parsed.path,
  86                                 output, &new_parsed->path);
  87   } else if (have_authority ||
  88              parsed.query.is_valid() || parsed.ref.is_valid()) {
  89     // When we have an empty path, make up a path when we have an authority
  90     // or something following the path. The only time we allow an empty
  91     // output path is when there is nothing else.
  92     new_parsed->path = Component(output->length(), 1);
  93     output->push_back('/');
  94   } else {
  95     // No path at all
  96     new_parsed->path.reset();
  97   }
  98
  99   // Query
 100   CanonicalizeQuery(source.query, parsed.query, query_converter,
 101                     output, &new_parsed->query);
 102
 103   // Ref: ignore failure for this, since the page can probably still be loaded.
 104   CanonicalizeRef(source.ref, parsed.ref, output, &new_parsed->ref);
 105
 106   // Carry over the flag for potentially dangling markup:
 107   if (parsed.potentially_dangling_markup)
 108     new_parsed->potentially_dangling_markup = true;
 109
 110   return success;
 111 }
 112
 113 }  // namespace
 114
 115 // Returns the default port for the given canonical scheme, or PORT_UNSPECIFIED
 116 // if the scheme is unknown.
 117 //
 118 // Please keep blink::DefaultPortForProtocol and url::DefaultPortForProtocol in
 119 // sync.
 120 int DefaultPortForScheme(const char* scheme, int scheme_len) {
 121   int default_port = PORT_UNSPECIFIED;
 122   switch (scheme_len) {
 123     case 4:
 124       if (!strncmp(scheme, kHttpScheme, scheme_len))
 125         default_port = 80;
 126       break;
 127     case 5:
 128       if (!strncmp(scheme, kHttpsScheme, scheme_len))
 129         default_port = 443;
 130       break;
 131     case 3:
 132       if (!strncmp(scheme, kFtpScheme, scheme_len))
 133         default_port = 21;
 134       else if (!strncmp(scheme, kWssScheme, scheme_len))
 135         default_port = 443;
 136       break;
 137     case 2:
 138       if (!strncmp(scheme, kWsScheme, scheme_len))
 139         default_port = 80;
 140       break;
 141   }
 142   return default_port;
 143 }
 144
 145 bool CanonicalizeStandardURL(const char* spec,
 146                              int spec_len,
 147                              const Parsed& parsed,
 148                              SchemeType scheme_type,
 149                              CharsetConverter* query_converter,
 150                              CanonOutput* output,
 151                              Parsed* new_parsed) {
 152   return DoCanonicalizeStandardURL<char, unsigned char>(
 153       URLComponentSource<char>(spec), parsed, scheme_type, query_converter,
 154       output, new_parsed);
 155 }
 156
 157 bool CanonicalizeStandardURL(const char16_t* spec,
 158                              int spec_len,
 159                              const Parsed& parsed,
 160                              SchemeType scheme_type,
 161                              CharsetConverter* query_converter,
 162                              CanonOutput* output,
 163                              Parsed* new_parsed) {
 164   return DoCanonicalizeStandardURL<char16_t, char16_t>(
 165       URLComponentSource<char16_t>(spec), parsed, scheme_type, query_converter,
 166       output, new_parsed);
 167 }
 168
 169 // It might be nice in the future to optimize this so unchanged components don't
 170 // need to be recanonicalized. This is especially true since the common case for
 171 // ReplaceComponents is removing things we don't want, like reference fragments
 172 // and usernames. These cases can become more efficient if we can assume the
 173 // rest of the URL is OK with these removed (or only the modified parts
 174 // recanonicalized). This would be much more complex to implement, however.
 175 //
 176 // You would also need to update DoReplaceComponents in url_util.cc which
 177 // relies on this re-checking everything (see the comment there for why).
 178 bool ReplaceStandardURL(const char* base,
 179                         const Parsed& base_parsed,
 180                         const Replacements<char>& replacements,
 181                         SchemeType scheme_type,
 182                         CharsetConverter* query_converter,
 183                         CanonOutput* output,
 184                         Parsed* new_parsed) {
 185   URLComponentSource<char> source(base);
 186   Parsed parsed(base_parsed);
 187   SetupOverrideComponents(base, replacements, &source, &parsed);
 188   return DoCanonicalizeStandardURL<char, unsigned char>(
 189       source, parsed, scheme_type, query_converter, output, new_parsed);
 190 }
 191
 192 // For 16-bit replacements, we turn all the replacements into UTF-8 so the
 193 // regular code path can be used.
 194 bool ReplaceStandardURL(const char* base,
 195                         const Parsed& base_parsed,
 196                         const Replacements<char16_t>& replacements,
 197                         SchemeType scheme_type,
 198                         CharsetConverter* query_converter,
 199                         CanonOutput* output,
 200                         Parsed* new_parsed) {
 201   RawCanonOutput<1024> utf8;
 202   URLComponentSource<char> source(base);
 203   Parsed parsed(base_parsed);
 204   SetupUTF16OverrideComponents(base, replacements, &utf8, &source, &parsed);
 205   return DoCanonicalizeStandardURL<char, unsigned char>(
 206       source, parsed, scheme_type, query_converter, output, new_parsed);
 207 }
 208
 209 }  // namespace url