| /* |
| * Copyright (C) 2009 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: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. 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. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``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 APPLE COMPUTER, INC. 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 "UserContentURLPattern.h" |
| #include "KURL.h" |
| #include <wtf/StdLibExtras.h> |
| |
| namespace WebCore { |
| |
| bool UserContentURLPattern::matchesPatterns(const KURL& url, const Vector<String>* whitelist, const Vector<String>* blacklist) |
| { |
| // In order for a URL to be a match it has to be present in the whitelist and not present in the blacklist. |
| // If there is no whitelist at all, then all URLs are assumed to be in the whitelist. |
| bool matchesWhitelist = !whitelist || whitelist->isEmpty(); |
| if (!matchesWhitelist) { |
| for (unsigned i = 0; i < whitelist->size(); ++i) { |
| UserContentURLPattern contentPattern(whitelist->at(i)); |
| if (contentPattern.matches(url)) { |
| matchesWhitelist = true; |
| break; |
| } |
| } |
| } |
| |
| bool matchesBlacklist = false; |
| if (blacklist) { |
| for (unsigned i = 0; i < blacklist->size(); ++i) { |
| UserContentURLPattern contentPattern(blacklist->at(i)); |
| if (contentPattern.matches(url)) { |
| matchesBlacklist = true; |
| break; |
| } |
| } |
| } |
| |
| return matchesWhitelist && !matchesBlacklist; |
| } |
| |
| bool UserContentURLPattern::parse(const String& pattern) |
| { |
| DEFINE_STATIC_LOCAL(const String, schemeSeparator, ("://")); |
| |
| int schemeEndPos = pattern.find(schemeSeparator); |
| if (schemeEndPos == -1) |
| return false; |
| |
| m_scheme = pattern.left(schemeEndPos); |
| |
| int hostStartPos = schemeEndPos + schemeSeparator.length(); |
| if (hostStartPos >= static_cast<int>(pattern.length())) |
| return false; |
| |
| int pathStartPos = 0; |
| |
| if (m_scheme == "file") |
| pathStartPos = hostStartPos; |
| else { |
| int hostEndPos = pattern.find("/", hostStartPos); |
| if (hostEndPos == -1) |
| return false; |
| |
| m_host = pattern.substring(hostStartPos, hostEndPos - hostStartPos); |
| |
| // The first component can be '*', which means to match all subdomains. |
| Vector<String> hostComponents; |
| m_host.split(".", hostComponents); |
| if (hostComponents[0] == "*") { |
| m_matchSubdomains = true; |
| m_host = ""; |
| for (unsigned i = 1; i < hostComponents.size(); ++i) { |
| m_host = m_host + hostComponents[i]; |
| if (i < hostComponents.size() - 1) |
| m_host = m_host + "."; |
| } |
| } |
| |
| // No other '*' can occur in the host. |
| if (m_host.find("*") != -1) |
| return false; |
| |
| pathStartPos = hostEndPos; |
| } |
| |
| m_path = pattern.right(pattern.length() - pathStartPos); |
| |
| return true; |
| } |
| |
| bool UserContentURLPattern::matches(const KURL& test) const |
| { |
| if (m_invalid) |
| return false; |
| |
| if (test.protocol() != m_scheme) |
| return false; |
| |
| if (!matchesHost(test)) |
| return false; |
| |
| return matchesPath(test); |
| } |
| |
| bool UserContentURLPattern::matchesHost(const KURL& test) const |
| { |
| if (test.host() == m_host) |
| return true; |
| |
| if (!m_matchSubdomains) |
| return false; |
| |
| // If we're matching subdomains, and we have no host, that means the pattern |
| // was <scheme>://*/<whatever>, so we match anything. |
| if (!m_host.length()) |
| return true; |
| |
| // Check if the test host is a subdomain of our host. |
| return test.host().endsWith(m_host, false); |
| } |
| |
| struct MatchTester |
| { |
| const String m_pattern; |
| unsigned m_patternIndex; |
| |
| const String m_test; |
| unsigned m_testIndex; |
| |
| MatchTester(const String& pattern, const String& test) |
| : m_pattern(pattern) |
| , m_patternIndex(0) |
| , m_test(test) |
| , m_testIndex(0) |
| { |
| } |
| |
| bool testStringFinished() const { return m_testIndex >= m_test.length(); } |
| bool patternStringFinished() const { return m_patternIndex >= m_pattern.length(); } |
| |
| void eatWildcard() |
| { |
| while (!patternStringFinished()) { |
| if (m_pattern[m_patternIndex] != '*') |
| return; |
| m_patternIndex++; |
| } |
| } |
| |
| void eatSameChars() |
| { |
| while (!patternStringFinished() && !testStringFinished()) { |
| if (m_pattern[m_patternIndex] == '*') |
| return; |
| if (m_pattern[m_patternIndex] != m_test[m_testIndex]) |
| return; |
| m_patternIndex++; |
| m_testIndex++; |
| } |
| } |
| |
| bool test() |
| { |
| // Eat all the matching chars. |
| eatSameChars(); |
| |
| // If the string is finished, then the pattern must be empty too, or contains |
| // only wildcards. |
| if (testStringFinished()) { |
| eatWildcard(); |
| if (patternStringFinished()) |
| return true; |
| return false; |
| } |
| |
| // Pattern is empty but not string, this is not a match. |
| if (patternStringFinished()) |
| return false; |
| |
| // If we don't encounter a *, then we're hosed. |
| if (m_pattern[m_patternIndex] != '*') |
| return false; |
| |
| while (!testStringFinished()) { |
| MatchTester nextMatch(*this); |
| nextMatch.m_patternIndex++; |
| if (nextMatch.test()) |
| return true; |
| m_testIndex++; |
| } |
| |
| // We reached the end of the string. Let's see if the pattern contains only |
| // wildcards. |
| eatWildcard(); |
| return patternStringFinished(); |
| } |
| }; |
| |
| bool UserContentURLPattern::matchesPath(const KURL& test) const |
| { |
| MatchTester match(m_path, test.path()); |
| return match.test(); |
| } |
| |
| } // namespace WebCore |