| /* |
| * Copyright 2007 Google Inc. All rights reserved. |
| * Copyright 2012 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "URLParse.h" |
| |
| #include "URLFile.h" |
| #include "URLParseInternal.h" |
| |
| // Interesting IE file:isms... |
| // |
| // INPUT OUTPUT |
| // ========================= ============================== |
| // file:/foo/bar file:///foo/bar |
| // The result here seems totally invalid!?!? This isn't UNC. |
| // |
| // file:/ |
| // file:// or any other number of slashes |
| // IE6 doesn't do anything at all if you click on this link. No error: |
| // nothing. IE6's history system seems to always color this link, so I'm |
| // guessing that it maps internally to the empty URL. |
| // |
| // C:\ file:///C:/ |
| // When on a file: URL source page, this link will work. When over HTTP, |
| // the file: URL will appear in the status bar but the link will not work |
| // (security restriction for all file URLs). |
| // |
| // file:foo/ file:foo/ (invalid?!?!?) |
| // file:/foo/ file:///foo/ (invalid?!?!?) |
| // file://foo/ file://foo/ (UNC to server "foo") |
| // file:///foo/ file:///foo/ (invalid, seems to be a file) |
| // file:////foo/ file://foo/ (UNC to server "foo") |
| // Any more than four slashes is also treated as UNC. |
| // |
| // file:C:/ file://C:/ |
| // file:/C:/ file://C:/ |
| // The number of slashes after "file:" don't matter if the thing following |
| // it looks like an absolute drive path. Also, slashes and backslashes are |
| // equally valid here. |
| |
| #if USE(WTFURL) |
| |
| namespace WTF { |
| |
| namespace URLParser { |
| |
| namespace { |
| |
| // A subcomponent of DoInitFileURL, the input of this function should be a UNC |
| // path name, with the index of the first character after the slashes following |
| // the scheme given in |afterSlashes|. This will initialize the host, path, |
| // query, and ref, and leave the other output components untouched |
| // (DoInitFileURL handles these for us). |
| template<typename CharacterType> |
| void doParseUNC(const CharacterType* spec, int afterSlashes, int specLength, URLSegments& parsed) |
| { |
| int nextSlash = findNextSlash(spec, afterSlashes, specLength); |
| if (nextSlash == specLength) { |
| // No additional slash found, as in "file://foo", treat the text as the |
| // host with no path (this will end up being UNC to server "foo"). |
| int hostLength = specLength - afterSlashes; |
| if (hostLength) |
| parsed.host = URLComponent(afterSlashes, hostLength); |
| else |
| parsed.host.reset(); |
| parsed.path.reset(); |
| return; |
| } |
| |
| #if OS(WINDOWS) |
| // See if we have something that looks like a path following the first |
| // component. As in "file://localhost/c:/", we get "c:/" out. We want to |
| // treat this as a having no host but the path given. Works on Windows only. |
| if (doesBeginWindowsDriveSpec(spec, nextSlash + 1, specLength)) { |
| parsed.host.reset(); |
| parsePathInternal(spec, MakeRange(nextSlash, specLength), |
| &parsed.path, &parsed.query, &parsed.ref); |
| return; |
| } |
| #endif |
| |
| // Otherwise, everything up until that first slash we found is the host name, |
| // which will end up being the UNC host. For example "file://foo/bar.txt" |
| // will get a server name of "foo" and a path of "/bar". Later, on Windows, |
| // this should be treated as the filename "\\foo\bar.txt" in proper UNC |
| // notation. |
| int hostLength = nextSlash - afterSlashes; |
| if (hostLength) |
| parsed.host = URLComponent::fromRange(afterSlashes, nextSlash); |
| else |
| parsed.host.reset(); |
| if (nextSlash < specLength) { |
| parsePathInternal(spec, URLComponent::fromRange(nextSlash, specLength), |
| &parsed.path, &parsed.query, &parsed.fragment); |
| } else |
| parsed.path.reset(); |
| } |
| |
| // A subcomponent of DoParseFileURL, the input should be a local file, with the |
| // beginning of the path indicated by the index in |pathBegin|. This will |
| // initialize the host, path, query, and ref, and leave the other output |
| // components untouched (DoInitFileURL handles these for us). |
| template<typename CharacterType> |
| void doParseLocalFile(const CharacterType* spec, int pathBegin, int specLength, URLSegments& parsed) |
| { |
| parsed.host.reset(); |
| parsePathInternal(spec, URLComponent::fromRange(pathBegin, specLength), |
| &parsed.path, &parsed.query, &parsed.fragment); |
| } |
| |
| // Backend for the external functions that operates on either char type. |
| // We are handed the character after the "file:" at the beginning of the spec. |
| // Usually this is a slash, but needn't be; we allow paths like "file:c:\foo". |
| template<typename CharacterType> |
| void doParseFileURL(const CharacterType* spec, int specLength, URLSegments& parsed) |
| { |
| ASSERT(specLength >= 0); |
| |
| // Get the parts we never use for file URLs out of the way. |
| parsed.username.reset(); |
| parsed.password.reset(); |
| parsed.port.reset(); |
| |
| // Many of the code paths don't set these, so it's convenient to just clear |
| // them. We'll write them in those cases we need them. |
| parsed.query.reset(); |
| parsed.fragment.reset(); |
| |
| // Strip leading & trailing spaces and control characters. |
| int begin = 0; |
| trimURL(spec, begin, specLength); |
| |
| // Find the scheme. |
| int numSlashes; |
| int afterScheme; |
| int afterSlashes; |
| #if OS(WINDOWS) |
| // See how many slashes there are. We want to handle cases like UNC but also |
| // "/c:/foo". This is when there is no scheme, so we can allow pages to do |
| // links like "c:/foo/bar" or "//foo/bar". This is also called by the |
| // relative URL resolver when it determines there is an absolute URL, which |
| // may give us input like "/c:/foo". |
| numSlashes = countConsecutiveSlashes(spec, begin, specLength); |
| afterSlashes = begin + numSlashes; |
| if (doesBeginWindowsDriveSpec(spec, afterSlashes, specLength)) { |
| // Windows path, don't try to extract the scheme (for example, "c:\foo"). |
| parsed.scheme.reset(); |
| afterScheme = afterSlashes; |
| } else if (doesBeginUNCPath(spec, begin, specLength, false)) { |
| // Windows UNC path: don't try to extract the scheme, but keep the slashes. |
| parsed.scheme.reset(); |
| afterScheme = begin; |
| } else |
| #endif |
| { |
| if (ExtractScheme(&spec[begin], specLength - begin, &parsed.scheme)) { |
| // Offset the results since we gave ExtractScheme a substring. |
| parsed.scheme.moveBy(begin); |
| afterScheme = parsed.scheme.end() + 1; |
| } else { |
| // No scheme found, remember that. |
| parsed.scheme.reset(); |
| afterScheme = begin; |
| } |
| } |
| |
| // Handle empty specs ones that contain only whitespace or control chars, |
| // or that are just the scheme (for example "file:"). |
| if (afterScheme == specLength) { |
| parsed.host.reset(); |
| parsed.path.reset(); |
| return; |
| } |
| |
| numSlashes = countConsecutiveSlashes(spec, afterScheme, specLength); |
| |
| afterSlashes = afterScheme + numSlashes; |
| #if OS(WINDOWS) |
| // Check whether the input is a drive again. We checked above for windows |
| // drive specs, but that's only at the very beginning to see if we have a |
| // scheme at all. This test will be duplicated in that case, but will |
| // additionally handle all cases with a real scheme such as "file:///C:/". |
| if (!doesBeginWindowsDriveSpec(spec, afterSlashes, specLength) && numSlashes != 3) { |
| // Anything not beginning with a drive spec ("c:\") on Windows is treated |
| // as UNC, with the exception of three slashes which always means a file. |
| // Even IE7 treats file:///foo/bar as "/foo/bar", which then fails. |
| doParseUNC(spec, afterSlashes, specLength, parsed); |
| return; |
| } |
| #else |
| // file: URL with exactly 2 slashes is considered to have a host component. |
| if (numSlashes == 2) { |
| doParseUNC(spec, afterSlashes, specLength, parsed); |
| return; |
| } |
| #endif // OS(WINDOWS) |
| |
| // Easy and common case, the full path immediately follows the scheme |
| // (modulo slashes), as in "file://c:/foo". Just treat everything from |
| // there to the end as the path. Empty hosts have 0 length instead of -1. |
| // We include the last slash as part of the path if there is one. |
| doParseLocalFile(spec, |
| numSlashes > 0 ? afterScheme + numSlashes - 1 : afterScheme, |
| specLength, parsed); |
| } |
| |
| } // namespace |
| |
| void ParseFileURL(const char* url, int urlLength, URLSegments* parsed) |
| { |
| doParseFileURL(url, urlLength, *parsed); |
| } |
| |
| void ParseFileURL(const UChar* url, int urlLength, URLSegments* parsed) |
| { |
| doParseFileURL(url, urlLength, *parsed); |
| } |
| |
| } // namespace URLParser |
| |
| } // namespace WTF |
| |
| #endif // USE(WTFURL) |
