2 /* ***** BEGIN LICENSE BLOCK *****
3 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
5 * The contents of this file are subject to the Mozilla Public License Version
6 * 1.1 (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 * http://www.mozilla.org/MPL/
10 * Software distributed under the License is distributed on an "AS IS" basis,
11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12 * for the specific language governing rights and limitations under the
15 * The Original Code is guacamole-common-js.
17 * The Initial Developer of the Original Code is
19 * Portions created by the Initial Developer are Copyright (C) 2010
20 * the Initial Developer. All Rights Reserved.
24 * Alternatively, the contents of this file may be used under the terms of
25 * either the GNU General Public License Version 2 or later (the "GPL"), or
26 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
27 * in which case the provisions of the GPL or the LGPL are applicable instead
28 * of those above. If you wish to allow use of your version of this file only
29 * under the terms of either the GPL or the LGPL, and not to allow others to
30 * use your version of this file under the terms of the MPL, indicate your
31 * decision by deleting the provisions above and replace them with the notice
32 * and other provisions required by the GPL or the LGPL. If you do not delete
33 * the provisions above, a recipient may use your version of this file under
34 * the terms of any one of the MPL, the GPL or the LGPL.
36 * ***** END LICENSE BLOCK ***** */
38 // Guacamole namespace
39 var Guacamole = Guacamole || {};
42 * Core object providing abstract communication for Guacamole. This object
43 * is a null implementation whose functions do nothing. Guacamole applications
44 * should use {@link Guacamole.HTTPTunnel} instead, or implement their own tunnel based
48 * @see Guacamole.HTTPTunnel
50 Guacamole.Tunnel = function() {
53 * Connect to the tunnel with the given optional data. This data is
54 * typically used for authentication. The format of data accepted is
55 * up to the tunnel implementation.
57 * @param {String} data The data to send to the tunnel when connecting.
59 this.connect = function(data) {};
62 * Disconnect from the tunnel.
64 this.disconnect = function() {};
67 * Send the given message through the tunnel to the service on the other
68 * side. All messages are guaranteed to be received in the order sent.
70 * @param {...} elements The elements of the message to send to the
71 * service on the other side of the tunnel.
73 this.sendMessage = function(elements) {};
76 * Fired whenever an error is encountered by the tunnel.
79 * @param {String} message A human-readable description of the error that
85 * Fired once for every complete Guacamole instruction received, in order.
88 * @param {String} opcode The Guacamole instruction opcode.
89 * @param {Array} parameters The parameters provided for the instruction,
92 this.oninstruction = null;
97 * Guacamole Tunnel implemented over HTTP via XMLHttpRequest.
100 * @augments Guacamole.Tunnel
101 * @param {String} tunnelURL The URL of the HTTP tunneling service.
103 Guacamole.HTTPTunnel = function(tunnelURL) {
106 * Reference to this HTTP tunnel.
112 var TUNNEL_CONNECT = tunnelURL + "?connect";
113 var TUNNEL_READ = tunnelURL + "?read:";
114 var TUNNEL_WRITE = tunnelURL + "?write:";
117 var STATE_CONNECTED = 1;
118 var STATE_DISCONNECTED = 2;
120 var currentState = STATE_IDLE;
122 var POLLING_ENABLED = 1;
123 var POLLING_DISABLED = 0;
125 // Default to polling - will be turned off automatically if not needed
126 var pollingMode = POLLING_ENABLED;
128 var sendingMessages = false;
129 var outputMessageBuffer = "";
131 this.sendMessage = function() {
133 // Do not attempt to send messages if not connected
134 if (currentState != STATE_CONNECTED)
137 // Do not attempt to send empty messages
138 if (arguments.length == 0)
142 * Converts the given value to a length/string pair for use as an
143 * element in a Guacamole instruction.
145 * @param value The value to convert.
146 * @return {String} The converted value.
148 function getElement(value) {
149 var string = new String(value);
150 return string.length + "." + string;
153 // Initialized message with first element
154 var message = getElement(arguments[0]);
156 // Append remaining elements
157 for (var i=1; i<arguments.length; i++)
158 message += "," + getElement(arguments[i]);
163 // Add message to buffer
164 outputMessageBuffer += message;
166 // Send if not currently sending
167 if (!sendingMessages)
168 sendPendingMessages();
172 function sendPendingMessages() {
174 if (outputMessageBuffer.length > 0) {
176 sendingMessages = true;
178 var message_xmlhttprequest = new XMLHttpRequest();
179 message_xmlhttprequest.open("POST", TUNNEL_WRITE + tunnel_uuid);
180 message_xmlhttprequest.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
182 // Once response received, send next queued event.
183 message_xmlhttprequest.onreadystatechange = function() {
184 if (message_xmlhttprequest.readyState == 4)
185 sendPendingMessages();
188 message_xmlhttprequest.send(outputMessageBuffer);
189 outputMessageBuffer = ""; // Clear buffer
193 sendingMessages = false;
198 function handleResponse(xmlhttprequest) {
201 var nextRequest = null;
203 var dataUpdateEvents = 0;
205 // The location of the last element's terminator
208 // Where to start the next length search or the next element
212 var elements = new Array();
214 function parseResponse() {
216 // Do not handle responses if not connected
217 if (currentState != STATE_CONNECTED) {
219 // Clean up interval if polling
220 if (interval != null)
221 clearInterval(interval);
226 // Start next request as soon as possible IF request was successful
227 if (xmlhttprequest.readyState >= 2 && nextRequest == null && xmlhttprequest.status == 200)
228 nextRequest = makeRequest();
230 // Parse stream when data is received and when complete.
231 if (xmlhttprequest.readyState == 3 ||
232 xmlhttprequest.readyState == 4) {
234 // Also poll every 30ms (some browsers don't repeatedly call onreadystatechange for new data)
235 if (pollingMode == POLLING_ENABLED) {
236 if (xmlhttprequest.readyState == 3 && interval == null)
237 interval = setInterval(parseResponse, 30);
238 else if (xmlhttprequest.readyState == 4 && interval != null)
239 clearInterval(interval);
242 // If canceled, stop transfer
243 if (xmlhttprequest.status == 0) {
248 // Halt on error during request
249 else if (xmlhttprequest.status != 200) {
251 // Get error message (if any)
252 var message = xmlhttprequest.getResponseHeader("X-Guacamole-Error-Message");
254 message = "Internal server error";
256 // Call error handler
257 if (tunnel.onerror) tunnel.onerror(message);
264 var current = xmlhttprequest.responseText;
266 // While search is within currently received data
267 while (elementEnd < current.length) {
269 // If we are waiting for element data
270 if (elementEnd >= startIndex) {
272 // We now have enough data for the element. Parse.
273 var element = current.substring(startIndex, elementEnd);
274 var terminator = current.substring(elementEnd, elementEnd+1);
276 // Add element to array
277 elements.push(element);
279 // If last element, handle instruction
280 if (terminator == ";") {
283 var opcode = elements.shift();
285 // Call instruction handler.
286 if (tunnel.oninstruction != null)
287 tunnel.oninstruction(opcode, elements);
294 // Start searching for length at character after
295 // element terminator
296 startIndex = elementEnd + 1;
300 // Search for end of length
301 var lengthEnd = current.indexOf(".", startIndex);
302 if (lengthEnd != -1) {
305 var length = parseInt(current.substring(elementEnd+1, lengthEnd));
307 // If we're done parsing, handle the next response.
310 // Clean up interval if polling
311 if (interval != null)
312 clearInterval(interval);
315 xmlhttprequest.onreadystatechange = null;
316 xmlhttprequest.abort();
318 // Start handling next request
320 handleResponse(nextRequest);
327 // Calculate start of element
328 startIndex = lengthEnd + 1;
330 // Calculate location of element terminator
331 elementEnd = startIndex + length;
335 // If no period yet, continue search when more data
338 startIndex = current.length;
348 // If response polling enabled, attempt to detect if still
349 // necessary (via wrapping parseResponse())
350 if (pollingMode == POLLING_ENABLED) {
351 xmlhttprequest.onreadystatechange = function() {
353 // If we receive two or more readyState==3 events,
354 // there is no need to poll.
355 if (xmlhttprequest.readyState == 3) {
357 if (dataUpdateEvents >= 2) {
358 pollingMode = POLLING_DISABLED;
359 xmlhttprequest.onreadystatechange = parseResponse;
367 // Otherwise, just parse
369 xmlhttprequest.onreadystatechange = parseResponse;
376 function makeRequest() {
379 var xmlhttprequest = new XMLHttpRequest();
380 xmlhttprequest.open("POST", TUNNEL_READ + tunnel_uuid);
381 xmlhttprequest.send(null);
383 return xmlhttprequest;
387 this.connect = function(data) {
389 // Start tunnel and connect synchronously
390 var connect_xmlhttprequest = new XMLHttpRequest();
391 connect_xmlhttprequest.open("POST", TUNNEL_CONNECT, false);
392 connect_xmlhttprequest.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
393 connect_xmlhttprequest.send(data);
395 // If failure, throw error
396 if (connect_xmlhttprequest.status != 200) {
398 var message = connect_xmlhttprequest.getResponseHeader("X-Guacamole-Error-Message");
400 message = "Internal error";
402 throw new Error(message);
406 // Get UUID from response
407 tunnel_uuid = connect_xmlhttprequest.responseText;
409 // Start reading data
410 currentState = STATE_CONNECTED;
411 handleResponse(makeRequest());
415 this.disconnect = function() {
416 currentState = STATE_DISCONNECTED;
421 Guacamole.HTTPTunnel.prototype = new Guacamole.Tunnel();
425 * Guacamole Tunnel implemented over WebSocket via XMLHttpRequest.
428 * @augments Guacamole.Tunnel
429 * @param {String} tunnelURL The URL of the WebSocket tunneling service.
431 Guacamole.WebSocketTunnel = function(tunnelURL) {
434 * Reference to this WebSocket tunnel.
439 * The WebSocket used by this tunnel.
444 * The WebSocket protocol corresponding to the protocol used for the current
453 var STATE_CONNECTED = 1;
454 var STATE_DISCONNECTED = 2;
456 var currentState = STATE_IDLE;
458 // Transform current URL to WebSocket URL
460 // If not already a websocket URL
461 if ( tunnelURL.substring(0, 3) != "ws:"
462 && tunnelURL.substring(0, 4) != "wss:") {
464 var protocol = ws_protocol[window.location.protocol];
466 // If absolute URL, convert to absolute WS URL
467 if (tunnelURL.substring(0, 1) == "/")
470 + "//" + window.location.host
473 // Otherwise, construct absolute from relative URL
476 // Get path from pathname
477 var slash = window.location.pathname.lastIndexOf("/");
478 var path = window.location.pathname.substring(0, slash + 1);
480 // Construct absolute URL
483 + "//" + window.location.host
491 this.sendMessage = function(message) {
493 // Do not attempt to send messages if not connected
494 if (currentState != STATE_CONNECTED)
497 socket.send(message);
501 this.connect = function(data) {
504 socket = new WebSocket(tunnelURL + "?" + data, "guacamole");
506 socket.onopen = function(event) {
507 currentState = STATE_CONNECTED;
510 socket.onmessage = function(event) {
512 var message = event.data;
514 var instructions = message.split(";");
515 for (var i=0; i<instructions.length; i++) {
517 var instruction = instructions[i];
519 var opcodeEnd = instruction.indexOf(":");
521 opcodeEnd = instruction.length;
523 var opcode = instruction.substring(0, opcodeEnd);
524 var parameters = instruction.substring(opcodeEnd+1).split(",");
526 if (tunnel.oninstruction)
527 tunnel.oninstruction(opcode, parameters);
535 this.disconnect = function() {
536 currentState = STATE_DISCONNECTED;
542 Guacamole.WebSocketTunnel.prototype = new Guacamole.Tunnel();