Source/WebCore/Modules/navigatorcontentutils/NavigatorContentUtils.cpp

   1 /*
   2  * Copyright (C) 2011, Google Inc. All rights reserved.
   3  * Copyright (C) 2012, Samsung Electronics. 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 met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  20  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  21  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  24  * DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "NavigatorContentUtils.h"
  29
  30 #if ENABLE(NAVIGATOR_CONTENT_UTILS)
  31
  32 #include "Document.h"
  33 #include "ExceptionCode.h"
  34 #include "Frame.h"
  35 #include "Navigator.h"
  36 #include "Page.h"
  37 #include <wtf/HashSet.h>
  38
  39 namespace WebCore {
  40
  41 static HashSet<String>* protocolWhitelist;
  42
  43 static void initProtocolHandlerWhitelist()
  44 {
  45     protocolWhitelist = new HashSet<String>;
  46 #if !PLATFORM(BLACKBERRY)
  47     static const char* protocols[] = {
  48         "irc",
  49         "geo",
  50         "mailto",
  51         "magnet",
  52         "mms",
  53         "news",
  54         "nntp",
  55         "sip",
  56         "sms",
  57         "smsto",
  58         "ssh",
  59         "tel",
  60         "urn",
  61         "webcal",
  62         "xmpp"
  63     };
  64     for (size_t i = 0; i < WTF_ARRAY_LENGTH(protocols); ++i)
  65         protocolWhitelist->add(protocols[i]);
  66 #endif
  67 }
  68
  69 static bool verifyCustomHandlerURL(const String& baseURL, const String& url, ExceptionCode& ec)
  70 {
  71     // The specification requires that it is a SYNTAX_ERR if the "%s" token is
  72     // not present.
  73     static const char token[] = "%s";
  74     int index = url.find(token);
  75     if (-1 == index) {
  76         ec = SYNTAX_ERR;
  77         return false;
  78     }
  79
  80     // It is also a SYNTAX_ERR if the custom handler URL, as created by removing
  81     // the "%s" token and prepending the base url, does not resolve.
  82     String newURL = url;
  83     newURL.remove(index, WTF_ARRAY_LENGTH(token) - 1);
  84
  85     KURL base(ParsedURLString, baseURL);
  86     KURL kurl(base, newURL);
  87
  88     if (kurl.isEmpty() || !kurl.isValid()) {
  89         ec = SYNTAX_ERR;
  90         return false;
  91     }
  92
  93     return true;
  94 }
  95
  96 static bool isProtocolWhitelisted(const String& scheme)
  97 {
  98     if (!protocolWhitelist)
  99         initProtocolHandlerWhitelist();
 100     return protocolWhitelist->contains(scheme);
 101 }
 102
 103 static bool verifyProtocolHandlerScheme(const String& scheme, ExceptionCode& ec)
 104 {
 105     if (scheme.startsWith("web+")) {
 106         if (isValidProtocol(scheme))
 107             return true;
 108         ec = SECURITY_ERR;
 109         return false;
 110     }
 111
 112     if (isProtocolWhitelisted(scheme))
 113         return true;
 114     ec = SECURITY_ERR;
 115     return false;
 116 }
 117
 118 NavigatorContentUtils* NavigatorContentUtils::from(Page* page)
 119 {
 120     return static_cast<NavigatorContentUtils*>(RefCountedSupplement<Page, NavigatorContentUtils>::from(page, NavigatorContentUtils::supplementName()));
 121 }
 122
 123 NavigatorContentUtils::~NavigatorContentUtils()
 124 {
 125 }
 126
 127 PassRefPtr<NavigatorContentUtils> NavigatorContentUtils::create(NavigatorContentUtilsClient* client)
 128 {
 129     return adoptRef(new NavigatorContentUtils(client));
 130 }
 131
 132 void NavigatorContentUtils::registerProtocolHandler(Navigator* navigator, const String& scheme, const String& url, const String& title, ExceptionCode& ec)
 133 {
 134     if (!navigator->frame())
 135         return;
 136
 137     Document* document = navigator->frame()->document();
 138     if (!document)
 139         return;
 140
 141     String baseURL = document->baseURL().baseAsString();
 142
 143     if (!verifyCustomHandlerURL(baseURL, url, ec))
 144         return;
 145
 146     if (!verifyProtocolHandlerScheme(scheme, ec))
 147         return;
 148
 149     NavigatorContentUtils::from(navigator->frame()->page())->client()->registerProtocolHandler(scheme, baseURL, url, navigator->frame()->displayStringModifiedByEncoding(title));
 150 }
 151
 152 #if ENABLE(CUSTOM_SCHEME_HANDLER)
 153 static String customHandlersStateString(const NavigatorContentUtilsClient::CustomHandlersState state)
 154 {
 155     DEFINE_STATIC_LOCAL(const String, newHandler, (ASCIILiteral("new")));
 156     DEFINE_STATIC_LOCAL(const String, registeredHandler, (ASCIILiteral("registered")));
 157     DEFINE_STATIC_LOCAL(const String, declinedHandler, (ASCIILiteral("declined")));
 158
 159     switch (state) {
 160     case NavigatorContentUtilsClient::CustomHandlersNew:
 161         return newHandler;
 162     case NavigatorContentUtilsClient::CustomHandlersRegistered:
 163         return registeredHandler;
 164     case NavigatorContentUtilsClient::CustomHandlersDeclined:
 165         return declinedHandler;
 166     }
 167
 168     ASSERT_NOT_REACHED();
 169     return String();
 170 }
 171
 172 String NavigatorContentUtils::isProtocolHandlerRegistered(Navigator* navigator, const String& scheme, const String& url, ExceptionCode& ec)
 173 {
 174     DEFINE_STATIC_LOCAL(const String, declined, ("declined"));
 175
 176     if (!navigator->frame())
 177         return declined;
 178
 179     Document* document = navigator->frame()->document();
 180     String baseURL = document->baseURL().baseAsString();
 181
 182     if (!verifyCustomHandlerURL(baseURL, url, ec))
 183         return declined;
 184
 185     if (!verifyProtocolHandlerScheme(scheme, ec))
 186         return declined;
 187
 188     return customHandlersStateString(NavigatorContentUtils::from(navigator->frame()->page())->client()->isProtocolHandlerRegistered(scheme, baseURL, url));
 189 }
 190
 191 void NavigatorContentUtils::unregisterProtocolHandler(Navigator* navigator, const String& scheme, const String& url, ExceptionCode& ec)
 192 {
 193     if (!navigator->frame())
 194         return;
 195
 196     Document* document = navigator->frame()->document();
 197     String baseURL = document->baseURL().baseAsString();
 198
 199     if (!verifyCustomHandlerURL(baseURL, url, ec))
 200         return;
 201
 202     if (!verifyProtocolHandlerScheme(scheme, ec))
 203         return;
 204
 205     NavigatorContentUtils::from(navigator->frame()->page())->client()->unregisterProtocolHandler(scheme, baseURL, url);
 206 }
 207 #endif
 208
 209 const char* NavigatorContentUtils::supplementName()
 210 {
 211     return "NavigatorContentUtils";
 212 }
 213
 214 void provideNavigatorContentUtilsTo(Page* page, NavigatorContentUtilsClient* client)
 215 {
 216     RefCountedSupplement<Page, NavigatorContentUtils>::provideTo(page, NavigatorContentUtils::supplementName(), NavigatorContentUtils::create(client));
 217 }
 218
 219 } // namespace WebCore
 220
 221 #endif // ENABLE(NAVIGATOR_CONTENT_UTILS)
 222