WebCore/websockets/WebSocket.cpp

   1 /*
   2  * Copyright (C) 2009 Google Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32
  33 #if ENABLE(WEB_SOCKETS)
  34
  35 #include "WebSocket.h"
  36
  37 #include "CString.h"
  38 #include "DOMWindow.h"
  39 #include "Event.h"
  40 #include "EventException.h"
  41 #include "EventListener.h"
  42 #include "EventNames.h"
  43 #include "Logging.h"
  44 #include "MessageEvent.h"
  45 #include "ScriptExecutionContext.h"
  46 #include "WebSocketChannel.h"
  47 #include <wtf/StdLibExtras.h>
  48
  49 namespace WebCore {
  50
  51 class ProcessWebSocketEventTask : public ScriptExecutionContext::Task {
  52 public:
  53     typedef void (WebSocket::*Method)(Event*);
  54     static PassOwnPtr<ProcessWebSocketEventTask> create(PassRefPtr<WebSocket> webSocket, PassRefPtr<Event> event)
  55     {
  56         return new ProcessWebSocketEventTask(webSocket, event);
  57     }
  58     virtual void performTask(ScriptExecutionContext*)
  59     {
  60         ExceptionCode ec = 0;
  61         m_webSocket->dispatchEvent(m_event.get(), ec);
  62         ASSERT(!ec);
  63     }
  64
  65   private:
  66     ProcessWebSocketEventTask(PassRefPtr<WebSocket> webSocket, PassRefPtr<Event> event)
  67         : m_webSocket(webSocket)
  68         , m_event(event) { }
  69
  70     RefPtr<WebSocket> m_webSocket;
  71     RefPtr<Event> m_event;
  72 };
  73
  74 static bool isValidProtocolString(const WebCore::String& protocol)
  75 {
  76     if (protocol.isNull())
  77         return true;
  78     if (protocol.isEmpty())
  79         return false;
  80     const UChar* characters = protocol.characters();
  81     for (size_t i = 0; i < protocol.length(); i++) {
  82         if (characters[i] < 0x21 || characters[i] > 0x7E)
  83             return false;
  84     }
  85     return true;
  86 }
  87
  88 #if USE(V8)
  89
  90 static bool webSocketsAvailable = false;
  91
  92 void WebSocket::setIsAvailable(bool available)
  93 {
  94     webSocketsAvailable = available;
  95 }
  96
  97 bool WebSocket::isAvailable()
  98 {
  99     return webSocketsAvailable;
 100 }
 101
 102 #endif
 103
 104 WebSocket::WebSocket(ScriptExecutionContext* context)
 105     : ActiveDOMObject(context, this)
 106     , m_state(CONNECTING)
 107 {
 108 }
 109
 110 WebSocket::~WebSocket()
 111 {
 112     if (m_channel)
 113         m_channel->disconnect();
 114 }
 115
 116 void WebSocket::connect(const KURL& url, ExceptionCode& ec)
 117 {
 118     connect(url, String(), ec);
 119 }
 120
 121 void WebSocket::connect(const KURL& url, const String& protocol, ExceptionCode& ec)
 122 {
 123     LOG(Network, "WebSocket %p connect to %s protocol=%s", this, url.string().utf8().data(), protocol.utf8().data());
 124     m_url = url;
 125     m_protocol = protocol;
 126
 127     if (!m_url.protocolIs("ws") && !m_url.protocolIs("wss")) {
 128         LOG(Network, "Wrong url scheme for WebSocket %s", url.string().utf8().data());
 129         m_state = CLOSED;
 130         ec = SYNTAX_ERR;
 131         return;
 132     }
 133     if (!isValidProtocolString(m_protocol)) {
 134         LOG(Network, "Wrong protocol for WebSocket %s", m_protocol.utf8().data());
 135         m_state = CLOSED;
 136         ec = SYNTAX_ERR;
 137         return;
 138     }
 139     if (!portAllowed(url)) {
 140         LOG(Network, "WebSocket port %d blocked", url.port());
 141         m_state = CLOSED;
 142         ec = SECURITY_ERR;
 143         return;
 144     }
 145
 146     m_channel = WebSocketChannel::create(scriptExecutionContext(), this, m_url, m_protocol);
 147     m_channel->connect();
 148 }
 149
 150 bool WebSocket::send(const String& message, ExceptionCode& ec)
 151 {
 152     LOG(Network, "WebSocket %p send %s", this, message.utf8().data());
 153     if (m_state == CONNECTING) {
 154         ec = INVALID_STATE_ERR;
 155         return false;
 156     }
 157     // No exception is raised if the connection was once established but has subsequently been closed.
 158     if (m_state == CLOSED)
 159         return false;
 160     // FIXME: check message is valid utf8.
 161     return m_channel->send(message);
 162 }
 163
 164 void WebSocket::close()
 165 {
 166     LOG(Network, "WebSocket %p close", this);
 167     if (m_state == CLOSED)
 168         return;
 169     m_state = CLOSED;
 170     m_channel->close();
 171 }
 172
 173 const KURL& WebSocket::url() const
 174 {
 175     return m_url;
 176 }
 177
 178 WebSocket::State WebSocket::readyState() const
 179 {
 180     return m_state;
 181 }
 182
 183 unsigned long WebSocket::bufferedAmount() const
 184 {
 185     if (m_state == OPEN)
 186         return m_channel->bufferedAmount();
 187     return 0;
 188 }
 189
 190 ScriptExecutionContext* WebSocket::scriptExecutionContext() const
 191 {
 192     return ActiveDOMObject::scriptExecutionContext();
 193 }
 194
 195 void WebSocket::didConnect()
 196 {
 197     LOG(Network, "WebSocket %p didConnect", this);
 198     if (m_state != CONNECTING || !scriptExecutionContext()) {
 199         didClose();
 200         return;
 201     }
 202     m_state = OPEN;
 203     scriptExecutionContext()->postTask(ProcessWebSocketEventTask::create(this, Event::create(eventNames().openEvent, false, false)));
 204 }
 205
 206 void WebSocket::didReceiveMessage(const String& msg)
 207 {
 208     LOG(Network, "WebSocket %p didReceiveMessage %s", this, msg.utf8().data());
 209     if (m_state != OPEN || !scriptExecutionContext())
 210         return;
 211     RefPtr<MessageEvent> evt = MessageEvent::create();
 212     // FIXME: origin, lastEventId, source, messagePort.
 213     evt->initMessageEvent(eventNames().messageEvent, false, false, SerializedScriptValue::create(msg), "", "", 0, 0);
 214     scriptExecutionContext()->postTask(ProcessWebSocketEventTask::create(this, evt));
 215 }
 216
 217 void WebSocket::didClose()
 218 {
 219     LOG(Network, "WebSocket %p didClose", this);
 220     m_state = CLOSED;
 221     if (scriptExecutionContext())
 222         scriptExecutionContext()->postTask(ProcessWebSocketEventTask::create(this, Event::create(eventNames().closeEvent, false, false)));
 223 }
 224
 225 EventTargetData* WebSocket::eventTargetData()
 226 {
 227     return &m_eventTargetData;
 228 }
 229
 230 EventTargetData* WebSocket::ensureEventTargetData()
 231 {
 232     return &m_eventTargetData;
 233 }
 234
 235 }  // namespace WebCore
 236
 237 #endif