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.
5 #include "base/check.h"
6 #include "url/third_party/mozilla/url_parse.h"
7 #include "url/url_file.h"
8 #include "url/url_parse_internal.h"
10 // Interesting IE file:isms...
13 // ========================= ==============================
14 // file:/foo/bar file:///foo/bar
15 // The result here seems totally invalid!?!? This isn't UNC.
18 // file:// or any other number of slashes
19 // IE6 doesn't do anything at all if you click on this link. No error:
20 // nothing. IE6's history system seems to always color this link, so I'm
21 // guessing that it maps internally to the empty URL.
24 // When on a file: URL source page, this link will work. When over HTTP,
25 // the file: URL will appear in the status bar but the link will not work
26 // (security restriction for all file URLs).
28 // file:foo/ file:foo/ (invalid?!?!?)
29 // file:/foo/ file:///foo/ (invalid?!?!?)
30 // file://foo/ file://foo/ (UNC to server "foo")
31 // file:///foo/ file:///foo/ (invalid, seems to be a file)
32 // file:////foo/ file://foo/ (UNC to server "foo")
33 // Any more than four slashes is also treated as UNC.
35 // file:C:/ file://C:/
36 // file:/C:/ file://C:/
37 // The number of slashes after "file:" don't matter if the thing following
38 // it looks like an absolute drive path. Also, slashes and backslashes are
39 // equally valid here.
45 // A subcomponent of DoParseFileURL, the input of this function should be a UNC
46 // path name, with the index of the first character after the slashes following
47 // the scheme given in |after_slashes|. This will initialize the host, path,
48 // query, and ref, and leave the other output components untouched
49 // (DoParseFileURL handles these for us).
50 template <typename CHAR>
51 void DoParseUNC(const CHAR* spec,
55 int next_slash = FindNextSlash(spec, after_slashes, spec_len);
57 // Everything up until that first slash we found (or end of string) is the
58 // host name, which will end up being the UNC host. For example,
59 // "file://foo/bar.txt" will get a server name of "foo" and a path of "/bar".
60 // Later, on Windows, this should be treated as the filename "\\foo\bar.txt"
61 // in proper UNC notation.
62 if (after_slashes < next_slash)
63 parsed->host = MakeRange(after_slashes, next_slash);
66 if (next_slash < spec_len) {
67 ParsePathInternal(spec, MakeRange(next_slash, spec_len),
68 &parsed->path, &parsed->query, &parsed->ref);
74 // A subcomponent of DoParseFileURL, the input should be a local file, with the
75 // beginning of the path indicated by the index in |path_begin|. This will
76 // initialize the host, path, query, and ref, and leave the other output
77 // components untouched (DoParseFileURL handles these for us).
78 template<typename CHAR>
79 void DoParseLocalFile(const CHAR* spec,
84 ParsePathInternal(spec, MakeRange(path_begin, spec_len),
85 &parsed->path, &parsed->query, &parsed->ref);
88 // Backend for the external functions that operates on either char type.
89 // Handles cases where there is a scheme, but also when handed the first
90 // character following the "file:" at the beginning of the spec. If so,
91 // this is usually a slash, but needn't be; we allow paths like "file:c:\foo".
92 template<typename CHAR>
93 void DoParseFileURL(const CHAR* spec, int spec_len, Parsed* parsed) {
94 DCHECK(spec_len >= 0);
96 // Get the parts we never use for file URLs out of the way.
97 parsed->username.reset();
98 parsed->password.reset();
101 // Many of the code paths don't set these, so it's convenient to just clear
102 // them. We'll write them in those cases we need them.
103 parsed->query.reset();
106 // Strip leading & trailing spaces and control characters.
108 TrimURL(spec, &begin, &spec_len);
110 // Find the scheme, if any.
111 int num_slashes = CountConsecutiveSlashes(spec, begin, spec_len);
115 // See how many slashes there are. We want to handle cases like UNC but also
116 // "/c:/foo". This is when there is no scheme, so we can allow pages to do
117 // links like "c:/foo/bar" or "//foo/bar". This is also called by the
118 // relative URL resolver when it determines there is an absolute URL, which
119 // may give us input like "/c:/foo".
120 after_slashes = begin + num_slashes;
121 if (DoesBeginWindowsDriveSpec(spec, after_slashes, spec_len)) {
122 // Windows path, don't try to extract the scheme (for example, "c:\foo").
123 parsed->scheme.reset();
124 after_scheme = after_slashes;
125 } else if (DoesBeginUNCPath(spec, begin, spec_len, false)) {
126 // Windows UNC path: don't try to extract the scheme, but keep the slashes.
127 parsed->scheme.reset();
128 after_scheme = begin;
132 // ExtractScheme doesn't understand the possibility of filenames with
133 // colons in them, in which case it returns the entire spec up to the
134 // colon as the scheme. So handle /foo.c:5 as a file but foo.c:5 as
135 // the foo.c: scheme.
137 ExtractScheme(&spec[begin], spec_len - begin, &parsed->scheme)) {
138 // Offset the results since we gave ExtractScheme a substring.
139 parsed->scheme.begin += begin;
140 after_scheme = parsed->scheme.end() + 1;
142 // No scheme found, remember that.
143 parsed->scheme.reset();
144 after_scheme = begin;
148 // Handle empty specs ones that contain only whitespace or control chars,
149 // or that are just the scheme (for example "file:").
150 if (after_scheme == spec_len) {
151 parsed->host.reset();
152 parsed->path.reset();
156 num_slashes = CountConsecutiveSlashes(spec, after_scheme, spec_len);
157 after_slashes = after_scheme + num_slashes;
159 // Check whether the input is a drive again. We checked above for windows
160 // drive specs, but that's only at the very beginning to see if we have a
161 // scheme at all. This test will be duplicated in that case, but will
162 // additionally handle all cases with a real scheme such as "file:///C:/".
163 if (!DoesBeginWindowsDriveSpec(spec, after_slashes, spec_len) &&
165 // Anything not beginning with a drive spec ("c:\") on Windows is treated
166 // as UNC, with the exception of three slashes which always means a file.
167 // Even IE7 treats file:///foo/bar as "/foo/bar", which then fails.
168 DoParseUNC(spec, after_slashes, spec_len, parsed);
172 // file: URL with exactly 2 slashes is considered to have a host component.
173 if (num_slashes == 2) {
174 DoParseUNC(spec, after_slashes, spec_len, parsed);
179 // Easy and common case, the full path immediately follows the scheme
180 // (modulo slashes), as in "file://c:/foo". Just treat everything from
181 // there to the end as the path. Empty hosts have 0 length instead of -1.
182 // We include the last slash as part of the path if there is one.
183 DoParseLocalFile(spec,
184 num_slashes > 0 ? after_scheme + num_slashes - 1 : after_scheme,
190 void ParseFileURL(const char* url, int url_len, Parsed* parsed) {
191 DoParseFileURL(url, url_len, parsed);
194 void ParseFileURL(const char16_t* url, int url_len, Parsed* parsed) {
195 DoParseFileURL(url, url_len, parsed);