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 #ifdef UNSAFE_BUFFERS_BUILD
6 // TODO(crbug.com/350788890): Remove this and spanify to fix the errors.
7 #pragma allow_unsafe_buffers
8 #endif
9
10 #include <stddef.h>
11
12 #include "testing/gtest/include/gtest/gtest.h"
13 #include "url/third_party/mozilla/url_parse.h"
14
15 // Interesting IE file:isms...
16 //
17 // file:/foo/bar file:///foo/bar
18 // The result here seems totally invalid!?!? This isn't UNC.
19 //
20 // file:/
21 // file:// or any other number of slashes
22 // IE6 doesn't do anything at all if you click on this link. No error:
23 // nothing. IE6's history system seems to always color this link, so I'm
24 // guessing that it maps internally to the empty URL.
25 //
26 // C:\ file:///C:/
27 // / file:///C:/
28 // /foo file:///C:/foo
29 // Interestingly, IE treats "/" as an alias for "c:\", which makes sense,
30 // but is weird to think about on Windows.
31 //
32 // file:foo/ file:foo/ (invalid?!?!?)
33 // file:/foo/ file:///foo/ (invalid?!?!?)
34 // file://foo/ file://foo/ (UNC to server "foo")
35 // file:///foo/ file:///foo/ (invalid)
36 // file:////foo/ file://foo/ (UNC to server "foo")
37 // Any more than four slashes is also treated as UNC.
38 //
39 // file:C:/ file://C:/
40 // file:/C:/ file://C:/
41 // The number of slashes after "file:" don't matter if the thing following
42 // it looks like an absolute drive path. Also, slashes and backslashes are
43 // equally valid here.
44
45 namespace url {
46
47 namespace {
48
49 using ::testing::AssertionFailure;
50 using ::testing::AssertionResult;
51 using ::testing::AssertionSuccess;
52
53 // Used for regular URL parse cases.
54 struct URLParseCase {
55 const char* input;
56
57 const char* scheme;
58 const char* username;
59 const char* password;
60 const char* host;
61 int port;
62 const char* path;
63 const char* query;
64 const char* ref;
65 };
66
67 // Simpler version of URLParseCase for testing path URLs.
68 struct PathURLParseCase {
69 const char* input;
70
71 const char* scheme;
72 const char* path;
73 };
74
75 // Simpler version of URLParseCase for testing mailto URLs.
76 struct MailtoURLParseCase {
77 const char* input;
78
79 const char* scheme;
80 const char* path;
81 const char* query;
82 };
83
84 // More complicated version of URLParseCase for testing filesystem URLs.
85 struct FileSystemURLParseCase {
86 const char* input;
87
88 const char* inner_scheme;
89 const char* inner_username;
90 const char* inner_password;
91 const char* inner_host;
92 int inner_port;
93 const char* inner_path;
94 const char* path;
95 const char* query;
96 const char* ref;
97 };
98
ComponentMatches(const char * input,const char * reference,const Component & component)99 AssertionResult ComponentMatches(const char* input,
100 const char* reference,
101 const Component& component) {
102 // Check that the -1 sentinel is the only allowed negative value.
103 if (!component.is_valid() && component.len != -1) {
104 return AssertionFailure()
105 << "-1 is the only allowed negative value for len";
106 }
107
108 // Begin should be valid.
109 if (component.begin < 0) {
110 return AssertionFailure() << "begin must be non-negative";
111 }
112
113 // A NULL reference means the component should be nonexistent.
114 if (!reference)
115 return component.len == -1 ? AssertionSuccess()
116 : AssertionFailure() << "len should be -1";
117 if (!component.is_valid())
118 return AssertionFailure()
119 << "for a non null reference, the component should be valid";
120
121 if (strlen(reference) != static_cast<size_t>(component.len)) {
122 return AssertionFailure() << "lengths do not match";
123 }
124
125 // Now check the actual characters.
126 return strncmp(reference, &input[component.begin], component.len) == 0
127 ? AssertionSuccess()
128 : AssertionFailure() << "characters do not match";
129 }
130
ExpectInvalidComponent(const Component & component)131 void ExpectInvalidComponent(const Component& component) {
132 EXPECT_EQ(0, component.begin);
133 EXPECT_EQ(-1, component.len);
134 }
135
URLParseCaseMatches(const URLParseCase & expected,const Parsed & parsed)136 void URLParseCaseMatches(const URLParseCase& expected, const Parsed& parsed) {
137 const char* url = expected.input;
138 SCOPED_TRACE(testing::Message()
139 << "url: \"" << url << "\", parsed: " << parsed);
140 int port = ParsePort(url, parsed.port);
141 EXPECT_TRUE(ComponentMatches(url, expected.scheme, parsed.scheme));
142 EXPECT_TRUE(ComponentMatches(url, expected.username, parsed.username));
143 EXPECT_TRUE(ComponentMatches(url, expected.password, parsed.password));
144 EXPECT_TRUE(ComponentMatches(url, expected.host, parsed.host));
145 EXPECT_EQ(expected.port, port);
146 EXPECT_TRUE(ComponentMatches(url, expected.path, parsed.path));
147 EXPECT_TRUE(ComponentMatches(url, expected.query, parsed.query));
148 EXPECT_TRUE(ComponentMatches(url, expected.ref, parsed.ref));
149 }
150
151 // Parsed ----------------------------------------------------------------------
152
TEST(URLParser,Length)153 TEST(URLParser, Length) {
154 const char* length_cases[] = {
155 // One with everything in it.
156 "http://user:pass@host:99/foo?bar#baz",
157 // One with nothing in it.
158 "",
159 // Working backwards, let's start taking off stuff from the full one.
160 "http://user:pass@host:99/foo?bar#",
161 "http://user:pass@host:99/foo?bar",
162 "http://user:pass@host:99/foo?",
163 "http://user:pass@host:99/foo",
164 "http://user:pass@host:99/",
165 "http://user:pass@host:99",
166 "http://user:pass@host:",
167 "http://user:pass@host",
168 "http://host",
169 "http://user@",
170 "http:",
171 };
172 for (const char* length_case : length_cases) {
173 int true_length = static_cast<int>(strlen(length_case));
174 Parsed parsed = ParseStandardURL(length_case);
175
176 EXPECT_EQ(true_length, parsed.Length());
177 }
178 }
179
TEST(URLParser,CountCharactersBefore)180 TEST(URLParser, CountCharactersBefore) {
181 struct CountCase {
182 const char* url;
183 Parsed::ComponentType component;
184 bool include_delimiter;
185 int expected_count;
186 } count_cases[] = {
187 // Test each possibility in the case where all components are present.
188 // 0 1 2
189 // 0123456789012345678901
190 {"http://u:p@h:8/p?q#r", Parsed::SCHEME, true, 0},
191 {"http://u:p@h:8/p?q#r", Parsed::SCHEME, false, 0},
192 {"http://u:p@h:8/p?q#r", Parsed::USERNAME, true, 7},
193 {"http://u:p@h:8/p?q#r", Parsed::USERNAME, false, 7},
194 {"http://u:p@h:8/p?q#r", Parsed::PASSWORD, true, 9},
195 {"http://u:p@h:8/p?q#r", Parsed::PASSWORD, false, 9},
196 {"http://u:p@h:8/p?q#r", Parsed::HOST, true, 11},
197 {"http://u:p@h:8/p?q#r", Parsed::HOST, false, 11},
198 {"http://u:p@h:8/p?q#r", Parsed::PORT, true, 12},
199 {"http://u:p@h:8/p?q#r", Parsed::PORT, false, 13},
200 {"http://u:p@h:8/p?q#r", Parsed::PATH, false, 14},
201 {"http://u:p@h:8/p?q#r", Parsed::PATH, true, 14},
202 {"http://u:p@h:8/p?q#r", Parsed::QUERY, true, 16},
203 {"http://u:p@h:8/p?q#r", Parsed::QUERY, false, 17},
204 {"http://u:p@h:8/p?q#r", Parsed::REF, true, 18},
205 {"http://u:p@h:8/p?q#r", Parsed::REF, false, 19},
206 // Now test when the requested component is missing.
207 {"http://u:p@h:8/p?", Parsed::REF, true, 17},
208 {"http://u:p@h:8/p?q", Parsed::REF, true, 18},
209 {"http://u:p@h:8/p#r", Parsed::QUERY, true, 16},
210 {"http://u:p@h:8#r", Parsed::PATH, true, 14},
211 {"http://u:p@h/", Parsed::PORT, true, 12},
212 {"http://u:p@/", Parsed::HOST, true, 11},
213 // This case is a little weird. It will report that the password would
214 // start where the host begins. This is arguably correct, although you
215 // could also argue that it should start at the '@' sign. Doing it
216 // starting with the '@' sign is actually harder, so we don't bother.
217 {"http://u@h/", Parsed::PASSWORD, true, 9},
218 {"http://h/", Parsed::USERNAME, true, 7},
219 {"http:", Parsed::USERNAME, true, 5},
220 {"", Parsed::SCHEME, true, 0},
221 // Make sure a random component still works when there's nothing there.
222 {"", Parsed::REF, true, 0},
223 // File URLs are special with no host, so we test those.
224 {"file:///c:/foo", Parsed::USERNAME, true, 7},
225 {"file:///c:/foo", Parsed::PASSWORD, true, 7},
226 {"file:///c:/foo", Parsed::HOST, true, 7},
227 {"file:///c:/foo", Parsed::PATH, true, 7},
228 };
229 for (const auto& count_case : count_cases) {
230 // Simple test to distinguish file and standard URLs.
231 Parsed parsed = count_case.url[0] == 'f' ? ParseFileURL(count_case.url)
232 : ParseStandardURL(count_case.url);
233
234 int chars_before = parsed.CountCharactersBefore(
235 count_case.component, count_case.include_delimiter);
236 EXPECT_EQ(count_case.expected_count, chars_before);
237 }
238 }
239
240 // Standard --------------------------------------------------------------------
241
242 // clang-format off
243 // Input Scheme Usrname Passwd Host Port Path Query Ref
244 // ------------------------------------ ------- -------- ---------- ------------ --- ---------- ------------ -----
245 static URLParseCase cases[] = {
246 // Regular URL with all the parts
247 {"http://user:pass@foo:21/bar;par?b#c", "http", "user", "pass", "foo", 21, "/bar;par","b", "c"},
248
249 // Known schemes should lean towards authority identification
250 {"http:foo.com", "http", nullptr, nullptr, "foo.com", -1, nullptr, nullptr, nullptr},
251
252 // Spaces!
253 {"\t :foo.com \n", "", nullptr, nullptr, "foo.com", -1, nullptr, nullptr, nullptr},
254 {" foo.com ", nullptr,nullptr, nullptr, "foo.com", -1, nullptr, nullptr, nullptr},
255 {"a:\t foo.com", "a", nullptr, nullptr, "\t foo.com", -1, nullptr, nullptr, nullptr},
256 {"http://f:21/ b ? d # e ", "http", nullptr, nullptr, "f", 21, "/ b ", " d ", " e"},
257
258 // Invalid port numbers should be identified and turned into -2, empty port
259 // numbers should be -1. Spaces aren't allowed in port numbers
260 {"http://f:/c", "http", nullptr, nullptr, "f", -1, "/c", nullptr, nullptr},
261 {"http://f:0/c", "http", nullptr, nullptr, "f", 0, "/c", nullptr, nullptr},
262 {"http://f:00000000000000/c", "http", nullptr, nullptr, "f", 0, "/c", nullptr, nullptr},
263 {"http://f:00000000000000000000080/c", "http", nullptr, nullptr, "f", 80, "/c", nullptr, nullptr},
264 {"http://f:b/c", "http", nullptr, nullptr, "f", -2, "/c", nullptr, nullptr},
265 {"http://f: /c", "http", nullptr, nullptr, "f", -2, "/c", nullptr, nullptr},
266 {"http://f:\n/c", "http", nullptr, nullptr, "f", -2, "/c", nullptr, nullptr},
267 {"http://f:fifty-two/c", "http", nullptr, nullptr, "f", -2, "/c", nullptr, nullptr},
268 {"http://f:999999/c", "http", nullptr, nullptr, "f", -2, "/c", nullptr, nullptr},
269 {"http://f: 21 / b ? d # e ", "http", nullptr, nullptr, "f", -2, "/ b ", " d ", " e"},
270
271 // Creative URLs missing key elements
272 {"", nullptr,nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
273 {" \t", nullptr,nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
274 {":foo.com/", "", nullptr, nullptr, "foo.com", -1, "/", nullptr, nullptr},
275 {":foo.com\\", "", nullptr, nullptr, "foo.com", -1, "\\", nullptr, nullptr},
276 {":", "", nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
277 {":a", "", nullptr, nullptr, "a", -1, nullptr, nullptr, nullptr},
278 {":/", "", nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
279 {":\\", "", nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
280 {":#", "", nullptr, nullptr, nullptr, -1, nullptr, nullptr, ""},
281 {"#", nullptr,nullptr, nullptr, nullptr, -1, nullptr, nullptr, ""},
282 {"#/", nullptr,nullptr, nullptr, nullptr, -1, nullptr, nullptr, "/"},
283 {"#\\", nullptr,nullptr, nullptr, nullptr, -1, nullptr, nullptr, "\\"},
284 {"#;?", nullptr,nullptr, nullptr, nullptr, -1, nullptr, nullptr, ";?"},
285 {"?", nullptr,nullptr, nullptr, nullptr, -1, nullptr, "", nullptr},
286 {"/", nullptr,nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
287 {":23", "", nullptr, nullptr, "23", -1, nullptr, nullptr, nullptr},
288 {"/:23", "/", nullptr, nullptr, "23", -1, nullptr, nullptr, nullptr},
289 {"//", nullptr,nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
290 {"::", "", nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
291 {"::23", "", nullptr, nullptr, nullptr, 23, nullptr, nullptr, nullptr},
292 {"foo://", "foo", nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
293
294 // Username/passwords and things that look like them
295 {"http://a:b@c:29/d", "http", "a", "b", "c", 29, "/d", nullptr, nullptr},
296 {"http::@c:29", "http", "", "", "c", 29, nullptr, nullptr, nullptr},
297 // ... "]" in the password field isn't allowed, but we tolerate it here...
298 {"http://&a:foo(b]c@d:2/", "http", "&a", "foo(b]c", "d", 2, "/", nullptr, nullptr},
299 {"http://::@c@d:2", "http", "", ":@c", "d", 2, nullptr, nullptr, nullptr},
300 {"http://foo.com:b@d/", "http", "foo.com","b", "d", -1, "/", nullptr, nullptr},
301
302 {"http://foo.com/\\@", "http", nullptr, nullptr, "foo.com", -1, "/\\@", nullptr, nullptr},
303 {"http:\\\\foo.com\\", "http", nullptr, nullptr, "foo.com", -1, "\\", nullptr, nullptr},
304 {"http:\\\\a\\b:c\\d@foo.com\\", "http", nullptr, nullptr, "a", -1, "\\b:c\\d@foo.com\\", nullptr,nullptr},
305
306 // Tolerate different numbers of slashes.
307 {"foo:/", "foo", nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
308 {"foo:/bar.com/", "foo", nullptr, nullptr, "bar.com", -1, "/", nullptr, nullptr},
309 {"foo://///////", "foo", nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
310 {"foo://///////bar.com/", "foo", nullptr, nullptr, "bar.com", -1, "/", nullptr, nullptr},
311 {"foo:////://///", "foo", nullptr, nullptr, nullptr, -1, "/////", nullptr, nullptr},
312
313 // Raw file paths on Windows aren't handled by the parser.
314 {"c:/foo", "c", nullptr, nullptr, "foo", -1, nullptr, nullptr, nullptr},
315 {"//foo/bar", nullptr,nullptr, nullptr, "foo", -1, "/bar", nullptr, nullptr},
316
317 // Use the first question mark for the query and the ref.
318 {"http://foo/path;a??e#f#g", "http", nullptr, nullptr, "foo", -1, "/path;a", "?e", "f#g"},
319 {"http://foo/abcd?efgh?ijkl", "http", nullptr, nullptr, "foo", -1, "/abcd", "efgh?ijkl", nullptr},
320 {"http://foo/abcd#foo?bar", "http", nullptr, nullptr, "foo", -1, "/abcd", nullptr, "foo?bar"},
321
322 // IPv6, check also interesting uses of colons.
323 {"[61:24:74]:98", "[61", nullptr, nullptr, "24:74]", 98, nullptr, nullptr, nullptr},
324 {"http://[61:27]:98", "http", nullptr, nullptr, "[61:27]", 98, nullptr, nullptr, nullptr},
325 {"http:[61:27]/:foo", "http", nullptr, nullptr, "[61:27]", -1, "/:foo", nullptr, nullptr},
326 {"http://[1::2]:3:4", "http", nullptr, nullptr, "[1::2]:3", 4, nullptr, nullptr, nullptr},
327
328 // Partially-complete IPv6 literals, and related cases.
329 {"http://2001::1", "http", nullptr, nullptr, "2001:", 1, nullptr, nullptr, nullptr},
330 {"http://[2001::1", "http", nullptr, nullptr, "[2001::1", -1, nullptr, nullptr, nullptr},
331 {"http://2001::1]", "http", nullptr, nullptr, "2001::1]", -1, nullptr, nullptr, nullptr},
332 {"http://2001::1]:80", "http", nullptr, nullptr, "2001::1]", 80, nullptr, nullptr, nullptr},
333 {"http://[2001::1]", "http", nullptr, nullptr, "[2001::1]", -1, nullptr, nullptr, nullptr},
334 {"http://[2001::1]:80", "http", nullptr, nullptr, "[2001::1]", 80, nullptr, nullptr, nullptr},
335 {"http://[[::]]", "http", nullptr, nullptr, "[[::]]", -1, nullptr, nullptr, nullptr},
336
337 };
338 // clang-format on
339
TEST(URLParser,Standard)340 TEST(URLParser, Standard) {
341 // Declared outside for loop to try to catch cases in init() where we forget
342 // to reset something that is reset by the constructor.
343 for (const auto& i : cases) {
344 Parsed parsed = ParseStandardURL(i.input);
345 URLParseCaseMatches(i, parsed);
346 }
347 }
348
349 // PathURL --------------------------------------------------------------------
350
351 // Various incarnations of path URLs.
352 // clang-format off
353 static PathURLParseCase path_cases[] = {
354 {"", nullptr, nullptr},
355 {":", "", nullptr},
356 {":/", "", "/"},
357 {"/", nullptr, "/"},
358 {" This is \\interesting// \t", nullptr, "This is \\interesting// \t"},
359 {"about:", "about", nullptr},
360 {"about:blank", "about", "blank"},
361 {" about: blank ", "about", " blank "},
362 {"javascript :alert(\"He:/l\\l#o?foo\"); ", "javascript ", "alert(\"He:/l\\l#o?foo\"); "},
363 };
364 // clang-format on
365
TEST(URLParser,PathURL)366 TEST(URLParser, PathURL) {
367 // Declared outside for loop to try to catch cases in init() where we forget
368 // to reset something that is reset by the constructor.
369 for (size_t i = 0; i < std::size(path_cases); i++) {
370 const char* url = path_cases[i].input;
371 Parsed parsed = ParsePathURL(url, false);
372
373 EXPECT_TRUE(ComponentMatches(url, path_cases[i].scheme, parsed.scheme))
374 << i;
375 EXPECT_TRUE(ComponentMatches(url, path_cases[i].path, parsed.GetContent()))
376 << i;
377
378 // The remaining components are never used for path URLs.
379 ExpectInvalidComponent(parsed.username);
380 ExpectInvalidComponent(parsed.password);
381 ExpectInvalidComponent(parsed.host);
382 ExpectInvalidComponent(parsed.port);
383 }
384 }
385
386 // Various incarnations of file URLs.
387 // clang-format off
388 static URLParseCase file_cases[] = {
389 #ifdef WIN32
390 {"file:server", "file", nullptr, nullptr, "server", -1, nullptr, nullptr, nullptr},
391 {" file: server \t", "file", nullptr, nullptr, " server",-1, nullptr, nullptr, nullptr},
392 {"FiLe:c|", "FiLe", nullptr, nullptr, nullptr, -1, "c|", nullptr, nullptr},
393 {"FILE:/\\\\/server/file", "FILE", nullptr, nullptr, "server", -1, "/file", nullptr, nullptr},
394 {"file://server/", "file", nullptr, nullptr, "server", -1, "/", nullptr, nullptr},
395 {"file://localhost/c:/", "file", nullptr, nullptr, "localhost", -1, "/c:/", nullptr, nullptr},
396 {"file://127.0.0.1/c|\\", "file", nullptr, nullptr, "127.0.0.1", -1, "/c|\\", nullptr, nullptr},
397 {"file:/", "file", nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
398 {"file:", "file", nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
399 // If there is a Windows drive letter, treat any number of slashes as the
400 // path part.
401 {"file:c:\\fo\\b", "file", nullptr, nullptr, nullptr, -1, "c:\\fo\\b", nullptr, nullptr},
402 {"file:/c:\\foo/bar", "file", nullptr, nullptr, nullptr, -1, "/c:\\foo/bar",nullptr, nullptr},
403 {"file://c:/f\\b", "file", nullptr, nullptr, nullptr, -1, "/c:/f\\b", nullptr, nullptr},
404 {"file:///C:/foo", "file", nullptr, nullptr, nullptr, -1, "/C:/foo", nullptr, nullptr},
405 {"file://///\\/\\/c:\\f\\b", "file", nullptr, nullptr, nullptr, -1, "/c:\\f\\b", nullptr, nullptr},
406 // If there is not a drive letter, we should treat is as UNC EXCEPT for
407 // three slashes, which we treat as a Unix style path.
408 {"file:server/file", "file", nullptr, nullptr, "server", -1, "/file", nullptr, nullptr},
409 {"file:/server/file", "file", nullptr, nullptr, "server", -1, "/file", nullptr, nullptr},
410 {"file://server/file", "file", nullptr, nullptr, "server", -1, "/file", nullptr, nullptr},
411 {"file:///server/file", "file", nullptr, nullptr, nullptr, -1, "/server/file",nullptr, nullptr},
412 {"file://\\server/file", "file", nullptr, nullptr, nullptr, -1, "\\server/file",nullptr, nullptr},
413 {"file:////server/file", "file", nullptr, nullptr, "server", -1, "/file", nullptr, nullptr},
414 // Queries and refs are valid for file URLs as well.
415 {"file:///C:/foo.html?#", "file", nullptr, nullptr, nullptr, -1, "/C:/foo.html", "", ""},
416 {"file:///C:/foo.html?query=yes#ref", "file", nullptr, nullptr, nullptr, -1, "/C:/foo.html", "query=yes", "ref"},
417 #else // WIN32
418 // No slashes.
419 {"file:", "file", nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
420 {"file:path", "file", nullptr, nullptr, nullptr, -1, "path", nullptr, nullptr},
421 {"file:path/", "file", nullptr, nullptr, nullptr, -1, "path/", nullptr, nullptr},
422 {"file:path/f.txt", "file", nullptr, nullptr, nullptr, -1, "path/f.txt", nullptr, nullptr},
423 // One slash.
424 {"file:/", "file", nullptr, nullptr, nullptr, -1, "/", nullptr, nullptr},
425 {"file:/path", "file", nullptr, nullptr, nullptr, -1, "/path", nullptr, nullptr},
426 {"file:/path/", "file", nullptr, nullptr, nullptr, -1, "/path/", nullptr, nullptr},
427 {"file:/path/f.txt", "file", nullptr, nullptr, nullptr, -1, "/path/f.txt", nullptr, nullptr},
428 // Two slashes.
429 {"file://", "file", nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
430 {"file://server", "file", nullptr, nullptr, "server", -1, nullptr, nullptr, nullptr},
431 {"file://server/", "file", nullptr, nullptr, "server", -1, "/", nullptr, nullptr},
432 {"file://server/f.txt", "file", nullptr, nullptr, "server", -1, "/f.txt", nullptr, nullptr},
433 // Three slashes.
434 {"file:///", "file", nullptr, nullptr, nullptr, -1, "/", nullptr, nullptr},
435 {"file:///path", "file", nullptr, nullptr, nullptr, -1, "/path", nullptr, nullptr},
436 {"file:///path/", "file", nullptr, nullptr, nullptr, -1, "/path/", nullptr, nullptr},
437 {"file:///path/f.txt", "file", nullptr, nullptr, nullptr, -1, "/path/f.txt", nullptr, nullptr},
438 // More than three slashes.
439 {"file:////", "file", nullptr, nullptr, nullptr, -1, "/", nullptr, nullptr},
440 {"file:////path", "file", nullptr, nullptr, nullptr, -1, "/path", nullptr, nullptr},
441 {"file:////path/", "file", nullptr, nullptr, nullptr, -1, "/path/", nullptr, nullptr},
442 {"file:////path/f.txt", "file", nullptr, nullptr, nullptr, -1, "/path/f.txt", nullptr, nullptr},
443 // Schemeless URLs
444 {"path/f.txt", nullptr,nullptr, nullptr, nullptr, -1, "path/f.txt", nullptr, nullptr},
445 {"path:80/f.txt", "path", nullptr, nullptr, nullptr, -1, "80/f.txt", nullptr, nullptr},
446 {"path/f.txt:80", "path/f.txt",nullptr, nullptr, nullptr,-1,"80", nullptr, nullptr}, // Wrong.
447 {"/path/f.txt", nullptr,nullptr, nullptr, nullptr, -1, "/path/f.txt", nullptr, nullptr},
448 {"/path:80/f.txt", nullptr,nullptr, nullptr, nullptr, -1, "/path:80/f.txt",nullptr, nullptr},
449 {"/path/f.txt:80", nullptr,nullptr, nullptr, nullptr, -1, "/path/f.txt:80",nullptr, nullptr},
450 {"//server/f.txt", nullptr,nullptr, nullptr, "server", -1, "/f.txt", nullptr, nullptr},
451 {"//server:80/f.txt", nullptr,nullptr, nullptr, "server:80",-1, "/f.txt", nullptr, nullptr},
452 {"//server/f.txt:80", nullptr,nullptr, nullptr, "server", -1, "/f.txt:80", nullptr, nullptr},
453 {"///path/f.txt", nullptr,nullptr, nullptr, nullptr, -1, "/path/f.txt", nullptr, nullptr},
454 {"///path:80/f.txt", nullptr,nullptr, nullptr, nullptr, -1, "/path:80/f.txt",nullptr, nullptr},
455 {"///path/f.txt:80", nullptr,nullptr, nullptr, nullptr, -1, "/path/f.txt:80",nullptr, nullptr},
456 {"////path/f.txt", nullptr,nullptr, nullptr, nullptr, -1, "/path/f.txt", nullptr, nullptr},
457 {"////path:80/f.txt", nullptr,nullptr, nullptr, nullptr, -1, "/path:80/f.txt",nullptr, nullptr},
458 {"////path/f.txt:80", nullptr,nullptr, nullptr, nullptr, -1, "/path/f.txt:80",nullptr, nullptr},
459 // Queries and refs are valid for file URLs as well.
460 {"file:///foo.html?#", "file", nullptr, nullptr, nullptr, -1, "/foo.html", "", ""},
461 {"file:///foo.html?q=y#ref", "file", nullptr, nullptr, nullptr, -1, "/foo.html", "q=y", "ref"},
462 #endif // WIN32
463 };
464 // clang-format on
465
TEST(URLParser,ParseFileURL)466 TEST(URLParser, ParseFileURL) {
467 // Declared outside for loop to try to catch cases in init() where we forget
468 // to reset something that is reset by the construtor.
469 for (const auto& file_case : file_cases) {
470 Parsed parsed = ParseFileURL(file_case.input);
471 URLParseCaseMatches(file_case, parsed);
472 EXPECT_FALSE(parsed.has_opaque_path);
473 }
474 }
475
TEST(URLParser,ExtractFileName)476 TEST(URLParser, ExtractFileName) {
477 struct FileCase {
478 const char* input;
479 const char* expected;
480 } extract_cases[] = {
481 {"http://www.google.com", nullptr},
482 {"http://www.google.com/", ""},
483 {"http://www.google.com/search", "search"},
484 {"http://www.google.com/search/", ""},
485 {"http://www.google.com/foo/bar.html?baz=22", "bar.html"},
486 {"http://www.google.com/foo/bar.html#ref", "bar.html"},
487 {"http://www.google.com/search/;param", ""},
488 {"http://www.google.com/foo/bar.html;param#ref", "bar.html"},
489 {"http://www.google.com/foo/bar.html;foo;param#ref", "bar.html"},
490 {"http://www.google.com/foo/bar.html?query#ref", "bar.html"},
491 {"http://www.google.com/foo;/bar.html", "bar.html"},
492 {"http://www.google.com/foo;/", ""},
493 {"http://www.google.com/foo;", "foo"},
494 {"http://www.google.com/;", ""},
495 {"http://www.google.com/foo;bar;html", "foo"},
496 };
497
498 for (const auto& extract_case : extract_cases) {
499 const char* url = extract_case.input;
500 Parsed parsed = ParseStandardURL(url);
501
502 Component file_name;
503 ExtractFileName(url, parsed.path, &file_name);
504
505 EXPECT_TRUE(ComponentMatches(url, extract_case.expected, file_name));
506 }
507 }
508
509 // Returns true if the parameter with index |parameter| in the given URL's
510 // query string. The expected key can be NULL to indicate no such key index
511 // should exist. The parameter number is 1-based.
NthParameterIs(const char * url,int parameter,const char * expected_key,const char * expected_value)512 static bool NthParameterIs(const char* url,
513 int parameter,
514 const char* expected_key,
515 const char* expected_value) {
516 Parsed parsed = ParseStandardURL(url);
517
518 Component query = parsed.query;
519
520 for (int i = 1; i <= parameter; i++) {
521 Component key, value;
522 if (!ExtractQueryKeyValue(url, &query, &key, &value)) {
523 if (parameter >= i && !expected_key)
524 return true; // Expected nonexistent key, got one.
525 return false; // Not enough keys.
526 }
527
528 if (i == parameter) {
529 if (!expected_key)
530 return false;
531
532 if (strncmp(&url[key.begin], expected_key, key.len) != 0)
533 return false;
534 if (strncmp(&url[value.begin], expected_value, value.len) != 0)
535 return false;
536 return true;
537 }
538 }
539 return expected_key == nullptr; // We didn't find that many parameters.
540 }
541
TEST(URLParser,ExtractQueryKeyValue)542 TEST(URLParser, ExtractQueryKeyValue) {
543 EXPECT_TRUE(NthParameterIs("http://www.google.com", 1, nullptr, nullptr));
544
545 // Basic case.
546 char a[] = "http://www.google.com?arg1=1&arg2=2&bar";
547 EXPECT_TRUE(NthParameterIs(a, 1, "arg1", "1"));
548 EXPECT_TRUE(NthParameterIs(a, 2, "arg2", "2"));
549 EXPECT_TRUE(NthParameterIs(a, 3, "bar", ""));
550 EXPECT_TRUE(NthParameterIs(a, 4, nullptr, nullptr));
551
552 // Empty param at the end.
553 char b[] = "http://www.google.com?foo=bar&";
554 EXPECT_TRUE(NthParameterIs(b, 1, "foo", "bar"));
555 EXPECT_TRUE(NthParameterIs(b, 2, nullptr, nullptr));
556
557 // Empty param at the beginning.
558 char c[] = "http://www.google.com?&foo=bar";
559 EXPECT_TRUE(NthParameterIs(c, 1, "", ""));
560 EXPECT_TRUE(NthParameterIs(c, 2, "foo", "bar"));
561 EXPECT_TRUE(NthParameterIs(c, 3, nullptr, nullptr));
562
563 // Empty key with value.
564 char d[] = "http://www.google.com?=foo";
565 EXPECT_TRUE(NthParameterIs(d, 1, "", "foo"));
566 EXPECT_TRUE(NthParameterIs(d, 2, nullptr, nullptr));
567
568 // Empty value with key.
569 char e[] = "http://www.google.com?foo=";
570 EXPECT_TRUE(NthParameterIs(e, 1, "foo", ""));
571 EXPECT_TRUE(NthParameterIs(e, 2, nullptr, nullptr));
572
573 // Empty key and values.
574 char f[] = "http://www.google.com?&&==&=";
575 EXPECT_TRUE(NthParameterIs(f, 1, "", ""));
576 EXPECT_TRUE(NthParameterIs(f, 2, "", ""));
577 EXPECT_TRUE(NthParameterIs(f, 3, "", "="));
578 EXPECT_TRUE(NthParameterIs(f, 4, "", ""));
579 EXPECT_TRUE(NthParameterIs(f, 5, nullptr, nullptr));
580 }
581
582 // MailtoURL --------------------------------------------------------------------
583
584 // clang-format off
585 static MailtoURLParseCase mailto_cases[] = {
586 //|input |scheme |path |query
587 {"mailto:foo@gmail.com", "mailto", "foo@gmail.com", nullptr},
588 {" mailto: to \t", "mailto", " to", nullptr},
589 {"mailto:addr1%2C%20addr2 ", "mailto", "addr1%2C%20addr2", nullptr},
590 {"Mailto:addr1, addr2 ", "Mailto", "addr1, addr2", nullptr},
591 {"mailto:addr1:addr2 ", "mailto", "addr1:addr2", nullptr},
592 {"mailto:?to=addr1,addr2", "mailto", nullptr, "to=addr1,addr2"},
593 {"mailto:?to=addr1%2C%20addr2", "mailto", nullptr, "to=addr1%2C%20addr2"},
594 {"mailto:addr1?to=addr2", "mailto", "addr1", "to=addr2"},
595 {"mailto:?body=#foobar#", "mailto", nullptr, "body=#foobar#",},
596 {"mailto:#?body=#foobar#", "mailto", "#", "body=#foobar#"},
597 };
598 // clang-format on
599
TEST(URLParser,MailtoUrl)600 TEST(URLParser, MailtoUrl) {
601 // Declared outside for loop to try to catch cases in init() where we forget
602 // to reset something that is reset by the constructor.
603 for (const auto& mailto_case : mailto_cases) {
604 const char* url = mailto_case.input;
605 Parsed parsed = ParseMailtoURL(url);
606 int port = ParsePort(url, parsed.port);
607
608 EXPECT_TRUE(ComponentMatches(url, mailto_case.scheme, parsed.scheme));
609 EXPECT_TRUE(ComponentMatches(url, mailto_case.path, parsed.path));
610 EXPECT_TRUE(ComponentMatches(url, mailto_case.query, parsed.query));
611 EXPECT_EQ(PORT_UNSPECIFIED, port);
612 EXPECT_FALSE(parsed.has_opaque_path);
613
614 // The remaining components are never used for mailto URLs.
615 ExpectInvalidComponent(parsed.username);
616 ExpectInvalidComponent(parsed.password);
617 ExpectInvalidComponent(parsed.port);
618 ExpectInvalidComponent(parsed.ref);
619 }
620 }
621
622 // Various incarnations of filesystem URLs.
623 static FileSystemURLParseCase filesystem_cases[] = {
624 // Regular URL with all the parts
625 {"filesystem:http://user:pass@foo:21/temporary/bar;par?b#c", "http", "user",
626 "pass", "foo", 21, "/temporary", "/bar;par", "b", "c"},
627 {"filesystem:https://foo/persistent/bar;par/", "https", nullptr, nullptr,
628 "foo", -1, "/persistent", "/bar;par/", nullptr, nullptr},
629 {"filesystem:file:///persistent/bar;par/", "file", nullptr, nullptr,
630 nullptr, -1, "/persistent", "/bar;par/", nullptr, nullptr},
631 {"filesystem:file:///persistent/bar;par/?query#ref", "file", nullptr,
632 nullptr, nullptr, -1, "/persistent", "/bar;par/", "query", "ref"},
633 {"filesystem:file:///persistent", "file", nullptr, nullptr, nullptr, -1,
634 "/persistent", "", nullptr, nullptr},
635 {"filesystem:", nullptr, nullptr, nullptr, nullptr, -1, nullptr, nullptr,
636 nullptr, nullptr},
637 };
638
TEST(URLParser,FileSystemURL)639 TEST(URLParser, FileSystemURL) {
640 // Declared outside for loop to try to catch cases in init() where we forget
641 // to reset something that is reset by the constructor.
642 for (const auto& filesystem_case : filesystem_cases) {
643 const char* url = filesystem_case.input;
644 Parsed parsed = ParseFileSystemURL(url);
645
646 EXPECT_TRUE(ComponentMatches(url, "filesystem", parsed.scheme));
647 EXPECT_EQ(!filesystem_case.inner_scheme, !parsed.inner_parsed());
648 // Only check the inner_parsed if there is one.
649 if (parsed.inner_parsed()) {
650 EXPECT_TRUE(ComponentMatches(url, filesystem_case.inner_scheme,
651 parsed.inner_parsed()->scheme));
652 EXPECT_TRUE(ComponentMatches(url, filesystem_case.inner_username,
653 parsed.inner_parsed()->username));
654 EXPECT_TRUE(ComponentMatches(url, filesystem_case.inner_password,
655 parsed.inner_parsed()->password));
656 EXPECT_TRUE(ComponentMatches(url, filesystem_case.inner_host,
657 parsed.inner_parsed()->host));
658 int port = ParsePort(url, parsed.inner_parsed()->port);
659 EXPECT_EQ(filesystem_case.inner_port, port);
660
661 // The remaining components are never used for filesystem URLs.
662 ExpectInvalidComponent(parsed.inner_parsed()->query);
663 ExpectInvalidComponent(parsed.inner_parsed()->ref);
664 }
665
666 EXPECT_TRUE(ComponentMatches(url, filesystem_case.path, parsed.path));
667 EXPECT_TRUE(ComponentMatches(url, filesystem_case.query, parsed.query));
668 EXPECT_TRUE(ComponentMatches(url, filesystem_case.ref, parsed.ref));
669 EXPECT_FALSE(parsed.has_opaque_path);
670
671 // The remaining components are never used for filesystem URLs.
672 ExpectInvalidComponent(parsed.username);
673 ExpectInvalidComponent(parsed.password);
674 ExpectInvalidComponent(parsed.host);
675 ExpectInvalidComponent(parsed.port);
676 }
677 }
678
679 // Non-special URLs which don't have an opaque path.
680 static URLParseCase non_special_cases[] = {
681 {"git://user:pass@foo:21/bar;par?b#c", "git", "user", "pass", "foo", 21,
682 "/bar;par", "b", "c"},
683 {"git://host", "git", nullptr, nullptr, "host", -1, nullptr, nullptr,
684 nullptr},
685 {"git://host/a/../b", "git", nullptr, nullptr, "host", -1, "/a/../b",
686 nullptr, nullptr},
687 {"git://host/a b", "git", nullptr, nullptr, "host", -1, "/a b", nullptr,
688 nullptr},
689 {"git://ho\\st/", "git", nullptr, nullptr, "ho\\st", -1, "/", nullptr,
690 nullptr},
691 // Empty users
692 {"git://@host", "git", "", nullptr, "host", -1, nullptr, nullptr, nullptr},
693 // Empty user and invalid host. "git://@" is an invalid URL.
694 {"git://@", "git", "", nullptr, nullptr, -1, nullptr, nullptr, nullptr},
695 // Invalid host and non-empty port. "git://:80" is an invalid URL.
696 {"git://:80", "git", nullptr, nullptr, nullptr, 80, nullptr, nullptr,
697 nullptr},
698 // Empty host cases
699 {"git://", "git", nullptr, nullptr, "", -1, nullptr, nullptr, nullptr},
700 {"git:///", "git", nullptr, nullptr, "", -1, "/", nullptr, nullptr},
701 {"git:////", "git", nullptr, nullptr, "", -1, "//", nullptr, nullptr},
702 // Null host cases
703 {"git:/", "git", nullptr, nullptr, nullptr, -1, "/", nullptr, nullptr},
704 {"git:/trailing-space ", "git", nullptr, nullptr, nullptr, -1,
705 "/trailing-space", nullptr, nullptr},
706 };
707
TEST(URLParser,NonSpecial)708 TEST(URLParser, NonSpecial) {
709 // Declared outside for loop to try to catch cases in init() where we forget
710 // to reset something that is reset by the constructor.
711 for (const auto& i : non_special_cases) {
712 Parsed parsed = ParseNonSpecialURL(i.input);
713 URLParseCaseMatches(i, parsed);
714 EXPECT_FALSE(parsed.has_opaque_path) << "url: " << i.input;
715 }
716 }
717
718 // Non-special URLs which have an opaque path.
719 static URLParseCase non_special_opaque_path_cases[] = {
720 {"git:", "git", nullptr, nullptr, nullptr, -1, nullptr, nullptr, nullptr},
721 {"git:opaque", "git", nullptr, nullptr, nullptr, -1, "opaque", nullptr,
722 nullptr},
723 {"git:opaque?a=b#c", "git", nullptr, nullptr, nullptr, -1, "opaque", "a=b",
724 "c"},
725 {"git: o p a q u e ", "git", nullptr, nullptr, nullptr, -1, " o p a q u e",
726 nullptr, nullptr},
727 {"git:opa\\que", "git", nullptr, nullptr, nullptr, -1, "opa\\que", nullptr,
728 nullptr},
729 };
730
TEST(URLParser,NonSpecialOpaquePath)731 TEST(URLParser, NonSpecialOpaquePath) {
732 // Declared outside for loop to try to catch cases in init() where we forget
733 // to reset something that is reset by the constructor.
734 for (const auto& i : non_special_opaque_path_cases) {
735 Parsed parsed = ParseNonSpecialURL(i.input);
736 URLParseCaseMatches(i, parsed);
737 EXPECT_TRUE(parsed.has_opaque_path) << "url: " << i.input;
738 }
739 }
740
741 } // namespace
742 } // namespace url
743