title: Error during WebSocket handshake: Unexpected response code: 200
body: <p>I am trying to run a simple chat application from this tutorial: <a href="http://www.binarytides.com/websockets-php-tutorial/" rel="nofollow">http://www.binarytides.com/websockets-php-tutorial/</a></p>
  
  <p>I am using XAMPP localhost Apache with ports 80 and 443.</p>
  
  <p>I keep getting: <strong>WebSocket connection to 'ws://localhost/IceEscape/server.php/websocket' failed: Error during WebSocket handshake: Unexpected response code: 200</strong></p>
  
  <p><strong>What do I change to resolve this?</strong></p>
  
  <p>I have tried toying with the </p>
  
  <pre><code>var host = "ws://localhost:80/IceEscape/server.php/websocket";
  </code></pre>
  
  <p>also tried </p>
  
  <pre><code>var host = "ws://localhost:80/IceEscape/server.php";
  </code></pre>
  
  <p>code:</p>
  
  <p>users.php:</p>
  
  <pre><code>&lt;?php
  class WebSocketUser {
    public $socket;
    public $id;
    public $headers = array();
    public $handshake = false;
    public $handlingPartialPacket = false;
    public $partialBuffer = "";
    public $sendingContinuous = false;
    public $partialMessage = "";
  
    public $hasSentClose = false;
    function __construct($id, $socket) {
      $this-&gt;id = $id;
      $this-&gt;socket = $socket;
    }
  }
  </code></pre>
  
  <p>websockets.php:</p>
  
  <pre><code>&lt;?php
  //require_once('./daemonize.php');
  require_once('./users.php');
  abstract class WebSocketServer {
    protected $userClass = 'WebSocketUser'; // redefine this if you want a custom user class.  The custom user class should inherit from WebSocketUser.
    protected $maxBufferSize;        
    protected $master;
    protected $sockets                              = array();
    protected $users                                = array();
    protected $heldMessages                         = array();
    protected $interactive                          = true;
    protected $headerOriginRequired                 = false;
    protected $headerSecWebSocketProtocolRequired   = false;
    protected $headerSecWebSocketExtensionsRequired = false;
    function __construct($addr, $port, $bufferLength = 2048) {
      $this-&gt;maxBufferSize = $bufferLength;
      $this-&gt;master = socket_create(AF_INET, SOCK_STREAM, SOL_TCP)  or die("Failed: socket_create()");
      socket_set_option($this-&gt;master, SOL_SOCKET, SO_REUSEADDR, 1) or die("Failed: socket_option()");
      socket_bind($this-&gt;master, $addr, $port)                      or die("Failed: socket_bind()");
      socket_listen($this-&gt;master,20)                               or die("Failed: socket_listen()");
      $this-&gt;sockets['m'] = $this-&gt;master;
      $this-&gt;stdout("Server started\nListening on: $addr:$port\nMaster socket: ".$this-&gt;master);
  
    }
    abstract protected function process($user,$message); // Called immediately when the data is recieved. 
    abstract protected function connected($user);        // Called after the handshake response is sent to the client.
    abstract protected function closed($user);           // Called after the connection is closed.
    protected function connecting($user) {
      // Override to handle a connecting user, after the instance of the User is created, but before
      // the handshake has completed.
    }
  
    protected function send($user, $message) {
      if ($user-&gt;handshake) {
        $message = $this-&gt;frame($message,$user);
        $result = @socket_write($user-&gt;socket, $message, strlen($message));
      }
      else {
        // User has not yet performed their handshake.  Store for sending later.
        $holdingMessage = array('user' =&gt; $user, 'message' =&gt; $message);
        $this-&gt;heldMessages[] = $holdingMessage;
      }
    }
    protected function tick() {
      // Override this for any process that should happen periodically.  Will happen at least once
      // per second, but possibly more often.
    }
    protected function _tick() {
      // Core maintenance processes, such as retrying failed messages.
      foreach ($this-&gt;heldMessages as $key =&gt; $hm) {
        $found = false;
        foreach ($this-&gt;users as $currentUser) {
          if ($hm['user']-&gt;socket == $currentUser-&gt;socket) {
            $found = true;
            if ($currentUser-&gt;handshake) {
              unset($this-&gt;heldMessages[$key]);
              $this-&gt;send($currentUser, $hm['message']);
            }
          }
        }
        if (!$found) {
          // If they're no longer in the list of connected users, drop the message.
          unset($this-&gt;heldMessages[$key]);
        }
      }
    }
    /**
     * Main processing loop
     */
    public function run() {
      while(true) {
        if (empty($this-&gt;sockets)) {
          $this-&gt;sockets['m'] = $this-&gt;master;
        }
        $read = $this-&gt;sockets;
        $write = $except = null;
        $this-&gt;_tick();
        $this-&gt;tick();
        @socket_select($read,$write,$except,1);
        foreach ($read as $socket) {
          if ($socket == $this-&gt;master) {
            $client = socket_accept($socket);
            if ($client &lt; 0) {
              $this-&gt;stderr("Failed: socket_accept()");
              continue;
            } 
            else {
              $this-&gt;connect($client);
              $this-&gt;stdout("Client connected. " . $client);
            }
          } 
          else {
            $numBytes = @socket_recv($socket, $buffer, $this-&gt;maxBufferSize, 0); 
            if ($numBytes === false) {
              $sockErrNo = socket_last_error($socket);
              switch ($sockErrNo)
              {
                case 102: // ENETRESET    -- Network dropped connection because of reset
                case 103: // ECONNABORTED -- Software caused connection abort
                case 104: // ECONNRESET   -- Connection reset by peer
                case 108: // ESHUTDOWN    -- Cannot send after transport endpoint shutdown -- probably more of an error on our part, if we're trying to write after the socket is closed.  Probably not a critical error, though.
                case 110: // ETIMEDOUT    -- Connection timed out
                case 111: // ECONNREFUSED -- Connection refused -- We shouldn't see this one, since we're listening... Still not a critical error.
                case 112: // EHOSTDOWN    -- Host is down -- Again, we shouldn't see this, and again, not critical because it's just one connection and we still want to listen to/for others.
                case 113: // EHOSTUNREACH -- No route to host
                case 121: // EREMOTEIO    -- Rempte I/O error -- Their hard drive just blew up.
                case 125: // ECANCELED    -- Operation canceled
  
                  $this-&gt;stderr("Unusual disconnect on socket " . $socket);
                  $this-&gt;disconnect($socket, true, $sockErrNo); // disconnect before clearing error, in case someone with their own implementation wants to check for error conditions on the socket.
                  break;
                default:
                  $this-&gt;stderr('Socket error: ' . socket_strerror($sockErrNo));
              }
  
            }
            elseif ($numBytes == 0) {
              $this-&gt;disconnect($socket);
              $this-&gt;stderr("Client disconnected. TCP connection lost: " . $socket);
            } 
            else {
              $user = $this-&gt;getUserBySocket($socket);
              if (!$user-&gt;handshake) {
                $tmp = str_replace("\r", '', $buffer);
                if (strpos($tmp, "\n\n") === false ) {
                  continue; // If the client has not finished sending the header, then wait before sending our upgrade response.
                }
                $this-&gt;doHandshake($user,$buffer);
              } 
              else {
                //split packet into frame and send it to deframe
                $this-&gt;split_packet($numBytes,$buffer, $user);
              }
            }
          }
        }
      }
    }
    protected function connect($socket) {
      $user = new $this-&gt;userClass(uniqid('u'), $socket);
      $this-&gt;users[$user-&gt;id] = $user;
      $this-&gt;sockets[$user-&gt;id] = $socket;
      $this-&gt;connecting($user);
    }
    protected function disconnect($socket, $triggerClosed = true, $sockErrNo = null) {
      $disconnectedUser = $this-&gt;getUserBySocket($socket);
  
      if ($disconnectedUser !== null) {
        unset($this-&gt;users[$disconnectedUser-&gt;id]);
  
        if (array_key_exists($disconnectedUser-&gt;id, $this-&gt;sockets)) {
          unset($this-&gt;sockets[$disconnectedUser-&gt;id]);
        }
  
        if (!is_null($sockErrNo)) {
          socket_clear_error($socket);
        }
        if ($triggerClosed) {
          $this-&gt;closed($disconnectedUser);
          socket_close($disconnectedUser-&gt;socket);
        }
        else {
          $message = $this-&gt;frame('', $disconnectedUser, 'close');
          @socket_write($disconnectedUser-&gt;socket, $message, strlen($message));
        }
      }
    }
    protected function doHandshake($user, $buffer) {
      $magicGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
      $headers = array();
      $lines = explode("\n",$buffer);
      foreach ($lines as $line) {
        if (strpos($line,":") !== false) {
          $header = explode(":",$line,2);
          $headers[strtolower(trim($header[0]))] = trim($header[1]);
        }
        elseif (stripos($line,"get ") !== false) {
          preg_match("/GET (.*) HTTP/i", $buffer, $reqResource);
          $headers['get'] = trim($reqResource[1]);
        }
      }
      if (isset($headers['get'])) {
        $user-&gt;requestedResource = $headers['get'];
      } 
      else {
        // todo: fail the connection
        $handshakeResponse = "HTTP/1.1 405 Method Not Allowed\r\n\r\n";     
      }
      if (!isset($headers['host']) || !$this-&gt;checkHost($headers['host'])) {
        $handshakeResponse = "HTTP/1.1 400 Bad Request";
      }
      if (!isset($headers['upgrade']) || strtolower($headers['upgrade']) != 'websocket') {
        $handshakeResponse = "HTTP/1.1 400 Bad Request";
      } 
      if (!isset($headers['connection']) || strpos(strtolower($headers['connection']), 'upgrade') === FALSE) {
        $handshakeResponse = "HTTP/1.1 400 Bad Request";
      }
      if (!isset($headers['sec-websocket-key'])) {
        $handshakeResponse = "HTTP/1.1 400 Bad Request";
      } 
      else {
      }
      if (!isset($headers['sec-websocket-version']) || strtolower($headers['sec-websocket-version']) != 13) {
        $handshakeResponse = "HTTP/1.1 426 Upgrade Required\r\nSec-WebSocketVersion: 13";
      }
      if (($this-&gt;headerOriginRequired &amp;&amp; !isset($headers['origin']) ) || ($this-&gt;headerOriginRequired &amp;&amp; !$this-&gt;checkOrigin($headers['origin']))) {
        $handshakeResponse = "HTTP/1.1 403 Forbidden";
      }
      if (($this-&gt;headerSecWebSocketProtocolRequired &amp;&amp; !isset($headers['sec-websocket-protocol'])) || ($this-&gt;headerSecWebSocketProtocolRequired &amp;&amp; !$this-&gt;checkWebsocProtocol($headers['sec-websocket-protocol']))) {
        $handshakeResponse = "HTTP/1.1 400 Bad Request";
      }
      if (($this-&gt;headerSecWebSocketExtensionsRequired &amp;&amp; !isset($headers['sec-websocket-extensions'])) || ($this-&gt;headerSecWebSocketExtensionsRequired &amp;&amp; !$this-&gt;checkWebsocExtensions($headers['sec-websocket-extensions']))) {
        $handshakeResponse = "HTTP/1.1 400 Bad Request";
      }
      // Done verifying the _required_ headers and optionally required headers.
      if (isset($handshakeResponse)) {
        socket_write($user-&gt;socket,$handshakeResponse,strlen($handshakeResponse));
        $this-&gt;disconnect($user-&gt;socket);
        return;
      }
      $user-&gt;headers = $headers;
      $user-&gt;handshake = $buffer;
      $webSocketKeyHash = sha1($headers['sec-websocket-key'] . $magicGUID);
      $rawToken = "";
      for ($i = 0; $i &lt; 20; $i++) {
        $rawToken .= chr(hexdec(substr($webSocketKeyHash,$i*2, 2)));
      }
      $handshakeToken = base64_encode($rawToken) . "\r\n";
      $subProtocol = (isset($headers['sec-websocket-protocol'])) ? $this-&gt;processProtocol($headers['sec-websocket-protocol']) : "";
      $extensions = (isset($headers['sec-websocket-extensions'])) ? $this-&gt;processExtensions($headers['sec-websocket-extensions']) : "";
      $handshakeResponse = "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: $handshakeToken$subProtocol$extensions\r\n";
      socket_write($user-&gt;socket,$handshakeResponse,strlen($handshakeResponse));
      $this-&gt;connected($user);
    }
    protected function checkHost($hostName) {
      return true; // Override and return false if the host is not one that you would expect.
                   // Ex: You only want to accept hosts from the my-domain.com domain,
                   // but you receive a host from malicious-site.com instead.
    }
    protected function checkOrigin($origin) {
      return true; // Override and return false if the origin is not one that you would expect.
    }
    protected function checkWebsocProtocol($protocol) {
      return true; // Override and return false if a protocol is not found that you would expect.
    }
    protected function checkWebsocExtensions($extensions) {
      return true; // Override and return false if an extension is not found that you would expect.
    }
    protected function processProtocol($protocol) {
      return ""; // return either "Sec-WebSocket-Protocol: SelectedProtocolFromClientList\r\n" or return an empty string.  
             // The carriage return/newline combo must appear at the end of a non-empty string, and must not
             // appear at the beginning of the string nor in an otherwise empty string, or it will be considered part of 
             // the response body, which will trigger an error in the client as it will not be formatted correctly.
    }
    protected function processExtensions($extensions) {
      return ""; // return either "Sec-WebSocket-Extensions: SelectedExtensions\r\n" or return an empty string.
    }
    protected function getUserBySocket($socket) {
      foreach ($this-&gt;users as $user) {
        if ($user-&gt;socket == $socket) {
          return $user;
        }
      }
      return null;
    }
    public function stdout($message) {
      if ($this-&gt;interactive) {
        echo "$message\n";
      }
    }
    public function stderr($message) {
      if ($this-&gt;interactive) {
        echo "$message\n";
      }
    }
    protected function frame($message, $user, $messageType='text', $messageContinues=false) {
      switch ($messageType) {
        case 'continuous':
          $b1 = 0;
          break;
        case 'text':
          $b1 = ($user-&gt;sendingContinuous) ? 0 : 1;
          break;
        case 'binary':
          $b1 = ($user-&gt;sendingContinuous) ? 0 : 2;
          break;
        case 'close':
          $b1 = 8;
          break;
        case 'ping':
          $b1 = 9;
          break;
        case 'pong':
          $b1 = 10;
          break;
      }
      if ($messageContinues) {
        $user-&gt;sendingContinuous = true;
      } 
      else {
        $b1 += 128;
        $user-&gt;sendingContinuous = false;
      }
      $length = strlen($message);
      $lengthField = "";
      if ($length &lt; 126) {
        $b2 = $length;
      } 
      elseif ($length &lt;= 65536) {
        $b2 = 126;
        $hexLength = dechex($length);
        //$this-&gt;stdout("Hex Length: $hexLength");
        if (strlen($hexLength)%2 == 1) {
          $hexLength = '0' . $hexLength;
        } 
        $n = strlen($hexLength) - 2;
        for ($i = $n; $i &gt;= 0; $i=$i-2) {
          $lengthField = chr(hexdec(substr($hexLength, $i, 2))) . $lengthField;
        }
        while (strlen($lengthField) &lt; 2) {
          $lengthField = chr(0) . $lengthField;
        }
      } 
      else {
        $b2 = 127;
        $hexLength = dechex($length);
        if (strlen($hexLength)%2 == 1) {
          $hexLength = '0' . $hexLength;
        } 
        $n = strlen($hexLength) - 2;
        for ($i = $n; $i &gt;= 0; $i=$i-2) {
          $lengthField = chr(hexdec(substr($hexLength, $i, 2))) . $lengthField;
        }
        while (strlen($lengthField) &lt; 8) {
          $lengthField = chr(0) . $lengthField;
        }
      }
      return chr($b1) . chr($b2) . $lengthField . $message;
    }
  
    //check packet if he have more than one frame and process each frame individually
    protected function split_packet($length,$packet, $user) {
      //add PartialPacket and calculate the new $length
      if ($user-&gt;handlingPartialPacket) {
        $packet = $user-&gt;partialBuffer . $packet;
        $user-&gt;handlingPartialPacket = false;
        $length=strlen($packet);
      }
      $fullpacket=$packet;
      $frame_pos=0;
      $frame_id=1;
      while($frame_pos&lt;$length) {
        $headers = $this-&gt;extractHeaders($packet);
        $headers_size = $this-&gt;calcoffset($headers);
        $framesize=$headers['length']+$headers_size;
  
        //split frame from packet and process it
        $frame=substr($fullpacket,$frame_pos,$framesize);
        if (($message = $this-&gt;deframe($frame, $user,$headers)) !== FALSE) {
          if ($user-&gt;hasSentClose) {
            $this-&gt;disconnect($user-&gt;socket);
          } else {
            if ((preg_match('//u', $message)) || ($headers['opcode']==2)) {
              //$this-&gt;stdout("Text msg encoded UTF-8 or Binary msg\n".$message); 
              $this-&gt;process($user, $message);
            } else {
              $this-&gt;stderr("not UTF-8\n");
            }
          }
        } 
        //get the new position also modify packet data
        $frame_pos+=$framesize;
        $packet=substr($fullpacket,$frame_pos);
        $frame_id++;
      }
    }
    protected function calcoffset($headers) {
      $offset = 2;
      if ($headers['hasmask']) {
        $offset += 4;
      }
      if ($headers['length'] &gt; 65535) {
        $offset += 8;
      } elseif ($headers['length'] &gt; 125) {
        $offset += 2;
      }
      return $offset;
    }
    protected function deframe($message, &amp;$user) {
      //echo $this-&gt;strtohex($message);
      $headers = $this-&gt;extractHeaders($message);
      $pongReply = false;
      $willClose = false;
      switch($headers['opcode']) {
        case 0:
        case 1:
        case 2:
          break;
        case 8:
          // todo: close the connection
          $user-&gt;hasSentClose = true;
          return "";
        case 9:
          $pongReply = true;
        case 10:
          break;
        default:
          //$this-&gt;disconnect($user); // todo: fail connection
          $willClose = true;
          break;
      }
      /* Deal by split_packet() as now deframe() do only one frame at a time.
      if ($user-&gt;handlingPartialPacket) {
        $message = $user-&gt;partialBuffer . $message;
        $user-&gt;handlingPartialPacket = false;
        return $this-&gt;deframe($message, $user);
      }
      */
  
      if ($this-&gt;checkRSVBits($headers,$user)) {
        return false;
      }
      if ($willClose) {
        // todo: fail the connection
        return false;
      }
      $payload = $user-&gt;partialMessage . $this-&gt;extractPayload($message,$headers);
      if ($pongReply) {
        $reply = $this-&gt;frame($payload,$user,'pong');
        socket_write($user-&gt;socket,$reply,strlen($reply));
        return false;
      }
      if ($headers['length'] &gt; strlen($this-&gt;applyMask($headers,$payload))) {
          $user-&gt;handlingPartialPacket = true;
          $user-&gt;partialBuffer = $message;
          return false;
      }
      $payload = $this-&gt;applyMask($headers,$payload);
      if ($headers['fin']) {
        $user-&gt;partialMessage = "";
        return $payload;
      }
      $user-&gt;partialMessage = $payload;
      return false;
    }
    protected function extractHeaders($message) {
      $header = array('fin'     =&gt; $message[0] &amp; chr(128),
              'rsv1'    =&gt; $message[0] &amp; chr(64),
              'rsv2'    =&gt; $message[0] &amp; chr(32),
              'rsv3'    =&gt; $message[0] &amp; chr(16),
              'opcode'  =&gt; ord($message[0]) &amp; 15,
              'hasmask' =&gt; $message[1] &amp; chr(128),
              'length'  =&gt; 0,
              'mask'    =&gt; "");
      $header['length'] = (ord($message[1]) &gt;= 128) ? ord($message[1]) - 128 : ord($message[1]);
      if ($header['length'] == 126) {
        if ($header['hasmask']) {
          $header['mask'] = $message[4] . $message[5] . $message[6] . $message[7];
        }
        $header['length'] = ord($message[2]) * 256 
                  + ord($message[3]);
      } 
      elseif ($header['length'] == 127) {
        if ($header['hasmask']) {
          $header['mask'] = $message[10] . $message[11] . $message[12] . $message[13];
        }
        $header['length'] = ord($message[2]) * 65536 * 65536 * 65536 * 256 
                  + ord($message[3]) * 65536 * 65536 * 65536
                  + ord($message[4]) * 65536 * 65536 * 256
                  + ord($message[5]) * 65536 * 65536
                  + ord($message[6]) * 65536 * 256
                  + ord($message[7]) * 65536 
                  + ord($message[8]) * 256
                  + ord($message[9]);
      } 
      elseif ($header['hasmask']) {
        $header['mask'] = $message[2] . $message[3] . $message[4] . $message[5];
      }
      //echo $this-&gt;strtohex($message);
      //$this-&gt;printHeaders($header);
      return $header;
    }
    protected function extractPayload($message,$headers) {
      $offset = 2;
      if ($headers['hasmask']) {
        $offset += 4;
      }
      if ($headers['length'] &gt; 65535) {
        $offset += 8;
      } 
      elseif ($headers['length'] &gt; 125) {
        $offset += 2;
      }
      return substr($message,$offset);
    }
    protected function applyMask($headers,$payload) {
      $effectiveMask = "";
      if ($headers['hasmask']) {
        $mask = $headers['mask'];
      } 
      else {
        return $payload;
      }
      while (strlen($effectiveMask) &lt; strlen($payload)) {
        $effectiveMask .= $mask;
      }
      while (strlen($effectiveMask) &gt; strlen($payload)) {
        $effectiveMask = substr($effectiveMask,0,-1);
      }
      return $effectiveMask ^ $payload;
    }
    protected function checkRSVBits($headers,$user) { // override this method if you are using an extension where the RSV bits are used.
      if (ord($headers['rsv1']) + ord($headers['rsv2']) + ord($headers['rsv3']) &gt; 0) {
        //$this-&gt;disconnect($user); // todo: fail connection
        return true;
      }
      return false;
    }
    protected function strtohex($str) {
      $strout = "";
      for ($i = 0; $i &lt; strlen($str); $i++) {
        $strout .= (ord($str[$i])&lt;16) ? "0" . dechex(ord($str[$i])) : dechex(ord($str[$i]));
        $strout .= " ";
        if ($i%32 == 7) {
          $strout .= ": ";
        }
        if ($i%32 == 15) {
          $strout .= ": ";
        }
        if ($i%32 == 23) {
          $strout .= ": ";
        }
        if ($i%32 == 31) {
          $strout .= "\n";
        }
      }
      return $strout . "\n";
    }
    protected function printHeaders($headers) {
      echo "Array\n(\n";
      foreach ($headers as $key =&gt; $value) {
        if ($key == 'length' || $key == 'opcode') {
          echo "\t[$key] =&gt; $value\n\n";
        } 
        else {
          echo "\t[$key] =&gt; ".$this-&gt;strtohex($value)."\n";
        }
      }
      echo ")\n";
    }
  </code></pre>
  
  <p>server.php:</p>
  
  <pre><code>&lt;?php
  
  require_once('websockets.php');
  
  class echo_server extends WebSocketServer 
  {
      //protected $maxBufferSize = 1048576; //1MB... overkill for an echo server, but potentially plausible for other applications.
  
      protected function process ($user, $message) 
      {
          if($message == 'help')
          {
              $reply = 'Following commands are available - date, hi';
          }
          else if($message == 'date')
          {
              $reply = "Current date is " . date('Y-m-d H:i:s');
          }
          else if($message == 'hi')
          {
              $reply = "Hello user. This is a websocket server.";
          }
          else
          {
              $reply = "Thank you for the message : $message";
          }
  
          $this-&gt;send($user, $reply);
  
          //The uri component say /a/b/c
          echo "Requested resource : " . $user-&gt;requestedResource . "n";
      }
  
      /**
          This is run when socket connection is established. Send a greeting message
      */
      protected function connected ($user) 
      {
          //Send welcome message to user
          $welcome_message = 'Hello. Welcome to the Websocket server. Type help to see what commands are available.';
          $this-&gt;send($user, $welcome_message);
      }
  
      /**
          This is where cleanup would go, in case the user had any sort of
          open files or other objects associated with them.  This runs after the socket 
          has been closed, so there is no need to clean up the socket itself here.
      */
      protected function closed ($user) 
      {
          echo "User closed connectionn";
      }
  }
  
  $host = '127.0.0.1';
  $port = 80;
  
  $server = new echo_server($host , $port );
  </code></pre>
  
  <p>client.html:</p>
  
  <pre><code>&lt;html&gt;&lt;head&gt;&lt;title&gt;WebSocket&lt;/title&gt;
  &lt;style type="text/css"&gt;
  html,body {
      font:normal 0.9em arial,helvetica;
  }
  #log {
      width:600px; 
      height:300px; 
      border:1px solid #7F9DB9; 
      overflow:auto;
  }
  #msg {
      width:400px;
  }
  &lt;/style&gt;
  &lt;script type="text/javascript"&gt;
  var socket;
  function init() {
      var host = "ws://localhost:80/IceEscape/server.php/websocket"; // SET THIS TO YOUR SERVER
      try {
          socket = new WebSocket(host);
          log('WebSocket - status '+socket.readyState);
          socket.onopen    = function(msg) { 
                                 log("Welcome - status "+this.readyState); 
                             };
          socket.onmessage = function(msg) { 
                                 log("Received: "+msg.data); 
                             };
          socket.onclose   = function(msg) { 
                                 log("Disconnected - status "+this.readyState); 
                             };
      }
      catch(ex){ 
          log(ex); 
      }
      $("msg").focus();
  }
  function send(){
      var txt,msg;
      txt = $("msg");
      msg = txt.value;
      if(!msg) { 
          alert("Message can not be empty"); 
          return; 
      }
      txt.value="";
      txt.focus();
      try { 
          socket.send(msg); 
          log('Sent: '+msg); 
      } catch(ex) { 
          log(ex); 
      }
  }
  function quit(){
      if (socket != null) {
          log("Goodbye!");
          socket.close();
          socket=null;
      }
  }
  function reconnect() {
      quit();
      init();
  }
  // Utilities
  function $(id){ return document.getElementById(id); }
  function log(msg){ $("log").innerHTML+="&lt;br&gt;"+msg; }
  function onkey(event){ if(event.keyCode==13){ send(); } }
  &lt;/script&gt;
  
  &lt;/head&gt;
  &lt;body onload="init()"&gt;
  &lt;h3&gt;WebSocket v2.00&lt;/h3&gt;
  &lt;div id="log"&gt;&lt;/div&gt;
  &lt;input id="msg" type="textbox" onkeypress="onkey(event)"/&gt;
  &lt;button onclick="send()"&gt;Send&lt;/button&gt;
  &lt;button onclick="quit()"&gt;Quit&lt;/button&gt;
  &lt;button onclick="reconnect()"&gt;Reconnect&lt;/button&gt;
  &lt;/body&gt;
  &lt;/html&gt;
  </code></pre>