Integrate most of GoogleURL in WTFURL
[WebKit-https.git] / Source / WTF / wtf / url / src / URLCanonStdURL.cpp
1 /*
2  * Copyright 2007 Google Inc. All rights reserved.
3  * Copyright 2012 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 // Functions to canonicalize "standard" URLs, which are ones that have an
33 // authority section including a host name.
34
35 #include "config.h"
36 #include "URLCanon.h"
37
38 #include "RawURLBuffer.h"
39 #include "URLCanonInternal.h"
40
41 #if USE(WTFURL)
42
43 namespace WTF {
44
45 namespace URLCanonicalizer {
46
47 namespace {
48
49 template<typename CHAR, typename UCHAR>
50 bool doCanonicalizeStandardURL(const URLComponentSource<CHAR>& source,
51                                const URLSegments& parsed,
52                                CharsetConverter* queryConverter,
53                                URLBuffer<char>& output,
54                                URLSegments& outputParsed)
55 {
56     // Scheme: this will append the colon.
57     bool success = canonicalizeScheme(source.scheme, parsed.scheme, output, outputParsed.scheme);
58
59     // Authority (username, password, host, port)
60     bool haveAuthority;
61     if (parsed.username.isNonEmpty() || parsed.password.isValid() || parsed.host.isNonEmpty() || parsed.port.isValid()) {
62         haveAuthority = true;
63
64         // Only write the authority separators when we have a scheme.
65         if (parsed.scheme.isValid())
66             output.append("//", 2);
67
68         // User info: the canonicalizer will handle the : and @.
69         success &= canonicalizeUserInfo(source.username, parsed.username, source.password, parsed.password,
70                                         output, outputParsed.username, outputParsed.password);
71         success &= canonicalizeHost(source.host, parsed.host, output, outputParsed.host);
72
73         // Host must not be empty for standard URLs.
74         if (!parsed.host.isNonEmpty())
75             success = false;
76
77         // Port: the port canonicalizer will handle the colon.
78         int defaultPort = defaultPortForScheme(&output.data()[outputParsed.scheme.begin()], outputParsed.scheme.length());
79         success &= canonicalizePort(source.port, parsed.port, defaultPort, output, outputParsed.port);
80     } else {
81         // No authority, clear the components.
82         haveAuthority = false;
83         outputParsed.host.reset();
84         outputParsed.username.reset();
85         outputParsed.password.reset();
86         outputParsed.port.reset();
87         success = false; // Standard URLs must have an authority.
88     }
89
90     // Path
91     if (parsed.path.isNonEmpty())
92         success &= CanonicalizePath(source.path, parsed.path, output, &outputParsed.path);
93     else if (haveAuthority || parsed.query.isNonEmpty() || parsed.fragment.isNonEmpty()) {
94         // When we have an empty path, make up a path when we have an authority
95         // or something following the path. The only time we allow an empty
96         // output path is when there is nothing else.
97         outputParsed.path = URLComponent(output.length(), 1);
98         output.append('/');
99     } else
100         outputParsed.path.reset(); // No path at all
101
102     // Query
103     CanonicalizeQuery(source.query, parsed.query, queryConverter, output, &outputParsed.query);
104
105     // Ref: ignore failure for this, since the page can probably still be loaded.
106     canonicalizeFragment(source.ref, parsed.fragment, output, outputParsed.fragment);
107
108     return success;
109 }
110
111 } // namespace
112
113
114 // Returns the default port for the given canonical scheme, or PORT_UNSPECIFIED
115 // if the scheme is unknown.
116 int defaultPortForScheme(const char* scheme, int schemeLength)
117 {
118     int defaultPort = URLParser::PORT_UNSPECIFIED;
119     switch (schemeLength) {
120     case 4:
121         if (!strncmp(scheme, "http", schemeLength))
122             defaultPort = 80;
123         break;
124     case 5:
125         if (!strncmp(scheme, "https", schemeLength))
126             defaultPort = 443;
127         break;
128     case 3:
129         if (!strncmp(scheme, "ftp", schemeLength))
130             defaultPort = 21;
131         else if (!strncmp(scheme, "wss", schemeLength))
132             defaultPort = 443;
133         break;
134     case 6:
135         if (!strncmp(scheme, "gopher", schemeLength))
136             defaultPort = 70;
137         break;
138     case 2:
139         if (!strncmp(scheme, "ws", schemeLength))
140             defaultPort = 80;
141         break;
142     }
143     return defaultPort;
144 }
145
146 bool CanonicalizeStandardURL(const char* spec,
147                              int /* specLength */,
148                              const URLSegments& parsed,
149                              CharsetConverter* queryConverter,
150                              URLBuffer<char>& output,
151                              URLSegments* outputParsed)
152 {
153     return doCanonicalizeStandardURL<char, unsigned char>(URLComponentSource<char>(spec), parsed, queryConverter,
154                                                           output, *outputParsed);
155 }
156
157 bool CanonicalizeStandardURL(const UChar* spec,
158                              int /* specLength */,
159                              const URLSegments& parsed,
160                              CharsetConverter* queryConverter,
161                              URLBuffer<char>& output,
162                              URLSegments* outputParsed)
163 {
164     return doCanonicalizeStandardURL<UChar, UChar>(URLComponentSource<UChar>(spec), parsed, queryConverter,
165                                                    output, *outputParsed);
166 }
167
168 // It might be nice in the future to optimize this so unchanged components don't
169 // need to be recanonicalized. This is especially true since the common case for
170 // ReplaceComponents is removing things we don't want, like reference fragments
171 // and usernames. These cases can become more efficient if we can assume the
172 // rest of the URL is OK with these removed (or only the modified parts
173 // recanonicalized). This would be much more complex to implement, however.
174 //
175 // You would also need to update DoReplaceComponents in URLUtilities.cc which
176 // relies on this re-checking everything (see the comment there for why).
177 bool ReplaceStandardURL(const char* base,
178                         const URLSegments& baseParsed,
179                         const Replacements<char>& replacements,
180                         CharsetConverter* queryConverter,
181                         URLBuffer<char>& output,
182                         URLSegments* outputParsed)
183 {
184     URLComponentSource<char> source(base);
185     URLSegments parsed(baseParsed);
186     SetupOverrideComponents(base, replacements, &source, &parsed);
187     return doCanonicalizeStandardURL<char, unsigned char>(source, parsed, queryConverter, output, *outputParsed);
188 }
189
190 // For 16-bit replacements, we turn all the replacements into UTF-8 so the
191 // regular codepath can be used.
192 bool ReplaceStandardURL(const char* base,
193                         const URLSegments& baseParsed,
194                         const Replacements<UChar>& replacements,
195                         CharsetConverter* queryConverter,
196                         URLBuffer<char>& output,
197                         URLSegments* outputParsed)
198 {
199     RawURLBuffer<char> utf8;
200     URLComponentSource<char> source(base);
201     URLSegments parsed(baseParsed);
202     SetupUTF16OverrideComponents(base, replacements, utf8, &source, &parsed);
203     return doCanonicalizeStandardURL<char, unsigned char>(source, parsed, queryConverter, output, *outputParsed);
204 }
205
206 } // namespace URLCanonicalizer
207
208 } // namespace WTF
209
210 #endif // USE(WTFURL)