1143 lines
36 KiB
JavaScript
1143 lines
36 KiB
JavaScript
/*
|
|
* Copyright (C) 2013 Glyptodon LLC
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* Main Guacamole web service namespace.
|
|
* @namespace
|
|
*/
|
|
var GuacamoleService = GuacamoleService || {};
|
|
|
|
/**
|
|
* An arbitary Guacamole connection group, having the given type, ID and name.
|
|
*
|
|
* @constructor
|
|
* @param {Number} type The type of this connection group - either ORGANIZATIONAL
|
|
* or BALANCING.
|
|
* @param {String} id An arbitrary ID, likely assigned by the auth provider.
|
|
* @param {String} name The human-readable name of this group.
|
|
*/
|
|
GuacamoleService.ConnectionGroup = function(type, id, name) {
|
|
|
|
/**
|
|
* The type of this connection group.
|
|
* @type Number
|
|
*/
|
|
this.type = type;
|
|
|
|
/**
|
|
* The unique ID of this connection group.
|
|
* @type String
|
|
*/
|
|
this.id = id;
|
|
|
|
/**
|
|
* The human-readable name associated with this connection group.
|
|
* @type String
|
|
*/
|
|
this.name = name;
|
|
|
|
/**
|
|
* The parent connection group of this group. If this group is the root
|
|
* group, this will be null.
|
|
*
|
|
* @type GuacamoleService.ConnectionGroup
|
|
*/
|
|
this.parent = null;
|
|
|
|
/**
|
|
* All connection groups contained within this group.
|
|
* @type GuacamoleService.ConnectionGroup[]
|
|
*/
|
|
this.groups = [];
|
|
|
|
/**
|
|
* All connections contained within this group.
|
|
* @type GuacamoleService.Connection[]
|
|
*/
|
|
this.connections = [];
|
|
|
|
};
|
|
|
|
/**
|
|
* Set of all possible types for ConnectionGroups.
|
|
*/
|
|
GuacamoleService.ConnectionGroup.Type = {
|
|
|
|
/**
|
|
* Organizational groups exist solely to hold connections or other groups,
|
|
* and provide no other semantics.
|
|
*
|
|
* @type Number
|
|
*/
|
|
"ORGANIZATIONAL" : 0,
|
|
|
|
/**
|
|
* Balancing groups act as connections. Users that have READ permission on
|
|
* balancing groups can use the group as if it were a connection, and that
|
|
* group will choose an appropriate connection within itself for that user
|
|
* to use.
|
|
*
|
|
* @type Number
|
|
*/
|
|
"BALANCING" : 1
|
|
|
|
};
|
|
|
|
/**
|
|
* An arbitrary Guacamole connection, consisting of an ID/protocol pair.
|
|
*
|
|
* @constructor
|
|
* @param {String} protocol The protocol used by this connection.
|
|
* @param {String} id The ID associated with this connection.
|
|
* @param {String} name The human-readable name associated with this connection.
|
|
*/
|
|
GuacamoleService.Connection = function(protocol, id, name) {
|
|
|
|
/**
|
|
* Reference to this connection.
|
|
*/
|
|
var guac_connection = this;
|
|
|
|
/**
|
|
* The parent connection group of this connection.
|
|
* @type GuacamoleService.ConnectionGroup
|
|
*/
|
|
this.parent = null;
|
|
|
|
/**
|
|
* The protocol associated with this connection.
|
|
*/
|
|
this.protocol = protocol;
|
|
|
|
/**
|
|
* The ID associated with this connection.
|
|
*/
|
|
this.id = id;
|
|
|
|
/**
|
|
* All parameters associated with this connection, if available.
|
|
*/
|
|
this.parameters = {};
|
|
|
|
/**
|
|
* The name of this connection. This name is arbitrary and local to the
|
|
* group containing the connection.
|
|
*
|
|
* @type String
|
|
*/
|
|
this.name = name;
|
|
|
|
/**
|
|
* An array of GuacamoleService.Connection.Record listing the usage
|
|
* history of this connection.
|
|
*/
|
|
this.history = [];
|
|
|
|
/**
|
|
* Returns the number of active users of this connection (which may be
|
|
* multiple instances under the same user) by walking the history records.
|
|
*
|
|
* @return {Number} The number of active users of this connection.
|
|
*/
|
|
this.currentUsage = function() {
|
|
|
|
// Number of users of this connection
|
|
var usage = 0;
|
|
|
|
// Walk history counting active entries
|
|
for (var i=0; i<guac_connection.history.length; i++) {
|
|
if (guac_connection.history[i].active)
|
|
usage++;
|
|
}
|
|
|
|
return usage;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
/**
|
|
* Creates a new GuacamoleService.Connection.Record describing a single
|
|
* session for the given username and having the given start/end times.
|
|
*
|
|
* @constructor
|
|
* @param {String} username The username of the user who used the connection.
|
|
* @param {Number} start The time that the connection began (in UNIX epoch
|
|
* milliseconds).
|
|
* @param {Number} end The time that the connection ended (in UNIX epoch
|
|
* milliseconds). This parameter is optional.
|
|
* @param {Boolean} active Whether the connection is currently active.
|
|
*/
|
|
GuacamoleService.Connection.Record = function(username, start, end, active) {
|
|
|
|
/**
|
|
* The username of the user associated with this record.
|
|
* @type String
|
|
*/
|
|
this.username = username;
|
|
|
|
/**
|
|
* The time the corresponding connection began.
|
|
* @type Date
|
|
*/
|
|
this.start = new Date(start);
|
|
|
|
/**
|
|
* The time the corresponding connection terminated (if any).
|
|
* @type Date
|
|
*/
|
|
this.end = null;
|
|
|
|
/**
|
|
* Whether this connection is currently active.
|
|
*/
|
|
this.active = active;
|
|
|
|
/**
|
|
* The duration of this connection, in seconds. This value is only
|
|
* defined if the end time is available.
|
|
* @type Number
|
|
*/
|
|
this.duration = null;
|
|
|
|
// If end time given, intialize end time
|
|
if (end) {
|
|
this.end = new Date(end);
|
|
this.duration = (end - start) / 1000;
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* A basic set of permissions that can be assigned to a user, describing
|
|
* whether they can create other users/connections and describing which
|
|
* users/connections they have permission to read or modify.
|
|
*/
|
|
GuacamoleService.PermissionSet = function() {
|
|
|
|
/**
|
|
* Whether permission to create users is granted.
|
|
*/
|
|
this.create_user = false;
|
|
|
|
/**
|
|
* Whether permission to create connections is granted.
|
|
*/
|
|
this.create_connection = false;
|
|
|
|
/**
|
|
* Whether permission to create connection groups is granted.
|
|
*/
|
|
this.create_connection_group = false;
|
|
|
|
/**
|
|
* Whether permission to administer the system in general is granted.
|
|
*/
|
|
this.administer = false;
|
|
|
|
/**
|
|
* Object with a property entry for each readable user.
|
|
*/
|
|
this.read_user = {};
|
|
|
|
/**
|
|
* Object with a property entry for each updatable user.
|
|
*/
|
|
this.update_user = {};
|
|
|
|
/**
|
|
* Object with a property entry for each removable user.
|
|
*/
|
|
this.remove_user = {};
|
|
|
|
/**
|
|
* Object with a property entry for each administerable user.
|
|
*/
|
|
this.administer_user = {};
|
|
|
|
/**
|
|
* Object with a property entry for each readable connection.
|
|
*/
|
|
this.read_connection = {};
|
|
|
|
/**
|
|
* Object with a property entry for each updatable connection.
|
|
*/
|
|
this.update_connection = {};
|
|
|
|
/**
|
|
* Object with a property entry for each removable connection.
|
|
*/
|
|
this.remove_connection = {};
|
|
|
|
/**
|
|
* Object with a property entry for each administerable connection.
|
|
*/
|
|
this.administer_connection = {};
|
|
|
|
/**
|
|
* Object with a property entry for each readable connection group.
|
|
*/
|
|
this.read_connection_group = {};
|
|
|
|
/**
|
|
* Object with a property entry for each updatable connection group.
|
|
*/
|
|
this.update_connection_group = {};
|
|
|
|
/**
|
|
* Object with a property entry for each removable connection group.
|
|
*/
|
|
this.remove_connection_group = {};
|
|
|
|
/**
|
|
* Object with a property entry for each administerable connection group.
|
|
*/
|
|
this.administer_connection_group = {};
|
|
|
|
};
|
|
|
|
/**
|
|
* Handles the reponse from the given XMLHttpRequest object, throwing an error
|
|
* with a meaningful message if the request failed.
|
|
*
|
|
* @param {XMLHttpRequest} xhr The XMLHttpRequest to check the response of.
|
|
*/
|
|
GuacamoleService.handleResponse = function(xhr) {
|
|
|
|
// For HTTP Forbidden, just return permission denied
|
|
if (xhr.status === 403)
|
|
throw new Guacamole.Status(Guacamole.Status.Code.CLIENT_FORBIDDEN, "Permission denied.");
|
|
|
|
// Otherwise, if unsuccessful, throw error with message derived from
|
|
// response
|
|
if (xhr.status !== 200) {
|
|
|
|
// Retrieve error code
|
|
var code = parseInt(xhr.getResponseHeader("Guacamole-Status-Code"));
|
|
|
|
// Retrieve error message
|
|
var message = xhr.getResponseHeader("Guacamole-Error-Message")
|
|
|| xhr.statusText;
|
|
|
|
// Throw error with derived message
|
|
throw new Guacamole.Status(code, message);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Collection of service functions which deal with connections. Each function
|
|
* makes an explicit HTTP query to the server, and parses the response.
|
|
*/
|
|
GuacamoleService.Connections = {
|
|
|
|
/**
|
|
* Comparator which compares two arbitrary objects by their name property.
|
|
*/
|
|
"comparator" : function(a, b) {
|
|
return a.name.localeCompare(b.name);
|
|
},
|
|
|
|
/**
|
|
* Returns the root connection group, containing a hierarchy of all other
|
|
* groups and connections for which the current user has access.
|
|
*
|
|
* @return {GuacamoleService.ConnectionGroup} The root group, containing
|
|
* a hierarchy of all other
|
|
* groups and connections to
|
|
* which the current user has
|
|
* access.
|
|
*/
|
|
"list" : function() {
|
|
|
|
// Construct request URL
|
|
var list_url = "api/connection"
|
|
+ "?token=" + GuacamoleService.Auth.current().authToken;
|
|
|
|
// Get connection list
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("GET", list_url, false);
|
|
xhr.send(null);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
return JSON.parse(xhr.responseText);
|
|
|
|
},
|
|
|
|
/**
|
|
* Creates a new connection.
|
|
*
|
|
* @param {GuacamoleService.Connection} connection The connection to create.
|
|
* @param {String} parameters Any parameters which should be passed to the
|
|
* server for the sake of authentication
|
|
* (optional).
|
|
*/
|
|
"create" : function(connection, parameters) {
|
|
|
|
// Construct request URL
|
|
var users_url = "connections/create?name=" + encodeURIComponent(connection.name);
|
|
if (parameters) users_url += "&" + parameters;
|
|
|
|
// Init POST data
|
|
var data = "protocol=" + encodeURIComponent(connection.protocol);
|
|
|
|
// Add group if given
|
|
if (connection.parent)
|
|
data += "&parentID=" + encodeURIComponent(connection.parent.id);
|
|
|
|
// Add parameters
|
|
for (var name in connection.parameters)
|
|
data += "&_" + encodeURIComponent(name)
|
|
+ "=" + encodeURIComponent(connection.parameters[name]);
|
|
|
|
// Add user
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("POST", users_url, false);
|
|
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded; charset=UTF-8");
|
|
xhr.send(data);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
|
|
},
|
|
|
|
/**
|
|
* Updates an existing connection. All properties are updated except
|
|
* the location of the connection, which is ignored.
|
|
*
|
|
* @param {GuacamoleService.Connection} connection The connection to create.
|
|
* @param {String} parameters Any parameters which should be passed to the
|
|
* server for the sake of authentication
|
|
* (optional).
|
|
*/
|
|
"update" : function(connection, parameters) {
|
|
|
|
// Construct request URL
|
|
var users_url = "connections/update?id=" + encodeURIComponent(connection.id);
|
|
if (parameters) users_url += "&" + parameters;
|
|
|
|
// Init POST data
|
|
var data =
|
|
"name=" + encodeURIComponent(connection.name)
|
|
+ "&protocol=" + encodeURIComponent(connection.protocol);
|
|
|
|
// Add parameters
|
|
for (var name in connection.parameters)
|
|
data += "&_" + encodeURIComponent(name)
|
|
+ "=" + encodeURIComponent(connection.parameters[name]);
|
|
|
|
// Add user
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("POST", users_url, false);
|
|
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded; charset=UTF-8");
|
|
xhr.send(data);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
|
|
},
|
|
|
|
/**
|
|
* Updates the location of an existing connection. This does not result
|
|
* in any change to the connection provided as a parameter.
|
|
*
|
|
* @param {GuacamoleService.Connection} connection The connection to create.
|
|
* @param {GuacamoleService.ConnectionGroup} dest The destination group.
|
|
* @param {String} parameters Any parameters which should be passed to the
|
|
* server for the sake of authentication
|
|
* (optional).
|
|
*/
|
|
"move" : function(connection, dest, parameters) {
|
|
|
|
// Construct request URL
|
|
var connection_url = "connections/move?id=" + encodeURIComponent(connection.id);
|
|
if (parameters) connection_url += "&" + parameters;
|
|
|
|
// Init POST data
|
|
var data = "parentID=" + encodeURIComponent(dest.id);
|
|
|
|
// Move connection
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("POST", connection_url, false);
|
|
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded; charset=UTF-8");
|
|
xhr.send(data);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
|
|
},
|
|
|
|
/**
|
|
* Deletes the connection having the given identifier.
|
|
*
|
|
* @param {String} id The identifier of the connection to delete.
|
|
* @param {String} parameters Any parameters which should be passed to the
|
|
* server for the sake of authentication
|
|
* (optional).
|
|
*/
|
|
"remove" : function(id, parameters) {
|
|
|
|
// Construct request URL
|
|
var connections_url = "connections/delete?id=" + encodeURIComponent(id);
|
|
if (parameters) connections_url += "&" + parameters;
|
|
|
|
// Add user
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("GET", connections_url, false);
|
|
xhr.send(null);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Collection of service functions which deal with connections groups. Each
|
|
* function makes an explicit HTTP query to the server, and parses the response.
|
|
*/
|
|
GuacamoleService.ConnectionGroups = {
|
|
|
|
/**
|
|
* Creates a new connection group.
|
|
*
|
|
* @param {GuacamoleService.ConnectionGroup} group The group to create.
|
|
* @param {String} parameters Any parameters which should be passed to the
|
|
* server for the sake of authentication
|
|
* (optional).
|
|
*/
|
|
"create" : function(group, parameters) {
|
|
|
|
// Construct request URL
|
|
var groups_url = "connectiongroups/create?name=" + encodeURIComponent(group.name);
|
|
if (parameters) groups_url += "&" + parameters;
|
|
|
|
// Init POST data
|
|
var data;
|
|
if (group.type === GuacamoleService.ConnectionGroup.Type.ORGANIZATIONAL)
|
|
data = "type=organizational";
|
|
else if (group.type === GuacamoleService.ConnectionGroup.Type.BALANCING)
|
|
data = "type=balancing";
|
|
|
|
// Add parent group if given
|
|
if (group.parent)
|
|
data += "&parentID=" + encodeURIComponent(group.parent.id);
|
|
|
|
// Create group
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("POST", groups_url, false);
|
|
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded; charset=UTF-8");
|
|
xhr.send(data);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
|
|
},
|
|
|
|
/**
|
|
* Updates an existing connection group. All properties are updated except
|
|
* the location of the group, which is ignored.
|
|
*
|
|
* @param {GuacamoleService.ConnectionGroup} group The group to create.
|
|
* @param {String} parameters Any parameters which should be passed to the
|
|
* server for the sake of authentication
|
|
* (optional).
|
|
*/
|
|
"update" : function(group, parameters) {
|
|
|
|
// Construct request URL
|
|
var groups_url = "connectiongroups/update?id=" + encodeURIComponent(group.id);
|
|
if (parameters) groups_url += "&" + parameters;
|
|
|
|
// Init POST data
|
|
var data = "name=" + encodeURIComponent(group.name);
|
|
|
|
// Add type
|
|
if (group.type === GuacamoleService.ConnectionGroup.Type.ORGANIZATIONAL)
|
|
data += "&type=organizational";
|
|
else if (group.type === GuacamoleService.ConnectionGroup.Type.BALANCING)
|
|
data += "&type=balancing";
|
|
|
|
// Update group
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("POST", groups_url, false);
|
|
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded; charset=UTF-8");
|
|
xhr.send(data);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
|
|
},
|
|
|
|
/**
|
|
* Sets the location of an existing connection group. This does not result
|
|
* in any change to the group provided as a parameter.
|
|
*
|
|
* @param {GuacamoleService.ConnectionGroup} group The group to create.
|
|
* @param {GuacamoleService.ConnectionGroup} dest The destination group.
|
|
* @param {String} parameters Any parameters which should be passed to the
|
|
* server for the sake of authentication
|
|
* (optional).
|
|
*/
|
|
"move" : function(group, dest, parameters) {
|
|
|
|
// Construct request URL
|
|
var groups_url = "connectiongroups/move?id=" + encodeURIComponent(group.id);
|
|
if (parameters) groups_url += "&" + parameters;
|
|
|
|
// Init POST data
|
|
var data = "parentID=" + encodeURIComponent(dest.id);
|
|
|
|
// Move group
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("POST", groups_url, false);
|
|
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded; charset=UTF-8");
|
|
xhr.send(data);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
|
|
},
|
|
|
|
/**
|
|
* Deletes the connection group having the given identifier.
|
|
*
|
|
* @param {String} id The identifier of the group to delete.
|
|
* @param {String} parameters Any parameters which should be passed to the
|
|
* server for the sake of authentication
|
|
* (optional).
|
|
*/
|
|
"remove" : function(id, parameters) {
|
|
|
|
// Construct request URL
|
|
var groups_url = "connectiongroups/delete?id=" + encodeURIComponent(id);
|
|
if (parameters) groups_url += "&" + parameters;
|
|
|
|
// Delete group
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("GET", groups_url, false);
|
|
xhr.send(null);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Collection of service functions which deal with users. Each function
|
|
* makes an explicit HTTP query to the server, and parses the response.
|
|
*/
|
|
GuacamoleService.Users = {
|
|
|
|
/**
|
|
* Returns an array of usernames for which the current user has access.
|
|
*
|
|
* @param {String} parameters Any parameters which should be passed to the
|
|
* server for the sake of authentication
|
|
* (optional).
|
|
* @return {String[]} An array of usernames for which the current user has
|
|
* access.
|
|
*/
|
|
"list" : function(parameters) {
|
|
|
|
// Construct request URL
|
|
var users_url = "users";
|
|
if (parameters) users_url += "?" + parameters;
|
|
|
|
// Get user list
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("GET", users_url, false);
|
|
xhr.send(null);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
|
|
// Otherwise, get list
|
|
var users = new Array();
|
|
|
|
var userElements = xhr.responseXML.getElementsByTagName("user");
|
|
for (var i=0; i<userElements.length; i++)
|
|
users.push(userElements[i].getAttribute("name"));
|
|
|
|
// Sort by username
|
|
users.sort();
|
|
|
|
return users;
|
|
|
|
},
|
|
|
|
/**
|
|
* Updates the user having the given username.
|
|
*
|
|
* @param {String} username The username of the user to create.
|
|
* @param {String} password The password to assign to the user (optional).
|
|
* @param {GuacamoleService.PermissionSet} permissions_added All permissions that were added.
|
|
* @param {GuacamoleService.PermissionSet} permissions_removed All permissions that were removed.
|
|
* @param {String} parameters Any parameters which should be passed to the
|
|
* server for the sake of authentication
|
|
* (optional).
|
|
*/
|
|
"update" : function(username, password, permissions_added,
|
|
permissions_removed, parameters) {
|
|
|
|
// Construct request URL
|
|
var users_url = "users/update";
|
|
if (parameters) users_url += "?" + parameters;
|
|
|
|
// Init POST data
|
|
var data = "name=" + encodeURIComponent(username);
|
|
if (password) data += "&password=" + encodeURIComponent(password);
|
|
|
|
var name;
|
|
|
|
// System permissions
|
|
if (permissions_added.create_user) data += "&%2Bsys=create-user";
|
|
if (permissions_added.create_connection) data += "&%2Bsys=create-connection";
|
|
if (permissions_added.create_connection_group) data += "&%2Bsys=create-connection-group";
|
|
if (permissions_added.administer) data += "&%2Bsys=admin";
|
|
|
|
// User permissions
|
|
for (name in permissions_added.read_user)
|
|
data += "&%2Buser=read:" + encodeURIComponent(name);
|
|
for (name in permissions_added.administer_user)
|
|
data += "&%2Buser=admin:" + encodeURIComponent(name);
|
|
for (name in permissions_added.update_user)
|
|
data += "&%2Buser=update:" + encodeURIComponent(name);
|
|
for (name in permissions_added.remove_user)
|
|
data += "&%2Buser=delete:" + encodeURIComponent(name);
|
|
|
|
// Connection permissions
|
|
for (name in permissions_added.read_connection)
|
|
data += "&%2Bconnection=read:" + encodeURIComponent(name);
|
|
for (name in permissions_added.administer_connection)
|
|
data += "&%2Bconnection=admin:" + encodeURIComponent(name);
|
|
for (name in permissions_added.update_connection)
|
|
data += "&%2Bconnection=update:" + encodeURIComponent(name);
|
|
for (name in permissions_added.remove_connection)
|
|
data += "&%2Bconnection=delete:" + encodeURIComponent(name);
|
|
|
|
// Connection group permissions
|
|
for (name in permissions_added.read_connection_group)
|
|
data += "&%2Bconnection-group=read:" + encodeURIComponent(name);
|
|
for (name in permissions_added.administer_connection_group)
|
|
data += "&%2Bconnection-group=admin:" + encodeURIComponent(name);
|
|
for (name in permissions_added.update_connection_group)
|
|
data += "&%2Bconnection-group=update:" + encodeURIComponent(name);
|
|
for (name in permissions_added.remove_connection_group)
|
|
data += "&%2Bconnection-group=delete:" + encodeURIComponent(name);
|
|
|
|
// Creation permissions
|
|
if (permissions_removed.create_user) data += "&-sys=create-user";
|
|
if (permissions_removed.create_connection) data += "&-sys=create-connection";
|
|
if (permissions_removed.create_connection_group) data += "&-sys=create-connection-group";
|
|
if (permissions_removed.administer) data += "&-sys=admin";
|
|
|
|
// User permissions
|
|
for (name in permissions_removed.read_user)
|
|
data += "&-user=read:" + encodeURIComponent(name);
|
|
for (name in permissions_removed.administer_user)
|
|
data += "&-user=admin:" + encodeURIComponent(name);
|
|
for (name in permissions_removed.update_user)
|
|
data += "&-user=update:" + encodeURIComponent(name);
|
|
for (name in permissions_removed.remove_user)
|
|
data += "&-user=delete:" + encodeURIComponent(name);
|
|
|
|
// Connection permissions
|
|
for (name in permissions_removed.read_connection)
|
|
data += "&-connection=read:" + encodeURIComponent(name);
|
|
for (name in permissions_removed.administer_connection)
|
|
data += "&-connection=admin:" + encodeURIComponent(name);
|
|
for (name in permissions_removed.update_connection)
|
|
data += "&-connection=update:" + encodeURIComponent(name);
|
|
for (name in permissions_removed.remove_connection)
|
|
data += "&-connection=delete:" + encodeURIComponent(name);
|
|
|
|
// Connection group permissions
|
|
for (name in permissions_removed.read_connection_group)
|
|
data += "&-connection-group=read:" + encodeURIComponent(name);
|
|
for (name in permissions_removed.administer_connection_group)
|
|
data += "&-connection-group=admin:" + encodeURIComponent(name);
|
|
for (name in permissions_removed.update_connection_group)
|
|
data += "&-connection-group=update:" + encodeURIComponent(name);
|
|
for (name in permissions_removed.remove_connection_group)
|
|
data += "&-connection-group=delete:" + encodeURIComponent(name);
|
|
|
|
// Update user
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("POST", users_url, false);
|
|
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded; charset=UTF-8");
|
|
xhr.send(data);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
|
|
},
|
|
|
|
/**
|
|
* Creates a new user having the given username.
|
|
*
|
|
* @param {String} username The username of the user to create.
|
|
* @param {String} parameters Any parameters which should be passed to the
|
|
* server for the sake of authentication
|
|
* (optional).
|
|
*/
|
|
"create" : function(username, parameters) {
|
|
|
|
// Construct request URL
|
|
var users_url = "users/create?name=" + encodeURIComponent(username);
|
|
if (parameters) users_url += "&" + parameters;
|
|
|
|
// Add user
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("GET", users_url, false);
|
|
xhr.send(null);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
|
|
},
|
|
|
|
/**
|
|
* Deletes the user having the given user ID.
|
|
*
|
|
* @param {String} userID The ID of the user to delete.
|
|
*/
|
|
"remove" : function(userID) {
|
|
|
|
// Construct request URL
|
|
var users_url = "api/user/" + encodeURIComponent(userID)
|
|
+ "?token=" + GuacamoleService.Auth.current().authToken;
|
|
|
|
// Add user
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("DELETE", users_url, false);
|
|
xhr.send(null);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Collection of service functions which deal with permissions. Each function
|
|
* makes an explicit HTTP query to the server, and parses the response.
|
|
*/
|
|
GuacamoleService.Permissions = {
|
|
|
|
/**
|
|
* Returns a PermissionSet describing the permissions given to a
|
|
* specified user.
|
|
*
|
|
* @param {String} userID The user ID of the user whose permissions should
|
|
* be retrieved. If no user ID is provided, the
|
|
* user ID of the current user will be used.
|
|
* @return {GuacamoleService.PermissionSet} A PermissionSet describing the
|
|
* permissions given to the
|
|
* specified user.
|
|
*/
|
|
"list" : function(userID) {
|
|
|
|
// Use current user ID if none provided
|
|
userID = userID || GuacamoleService.Auth.current().userID;
|
|
|
|
// Construct request URL
|
|
var list_url = "api/permission"
|
|
+ "/" + encodeURIComponent(userID)
|
|
+ "?token=" + GuacamoleService.Auth.current().authToken;
|
|
|
|
// Get permission list
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("GET", list_url, false);
|
|
xhr.send(null);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
return JSON.parse(xhr.responseText);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Representation of a protocol supported by Guacamole, having a given name,
|
|
* title, and set of parameters.
|
|
*/
|
|
GuacamoleService.Protocol = function(name, title, parameters) {
|
|
|
|
/**
|
|
* The unique name associated with this protocol. This is the name that is
|
|
* used to identify the protocol to Guacamole.
|
|
*/
|
|
this.name = name;
|
|
|
|
/**
|
|
* A human-readable title describing this protocol. This is what the user
|
|
* will use to identify the protocol.
|
|
*/
|
|
this.title = title;
|
|
|
|
/**
|
|
* Array of all available parameters, in desired order of presentation.
|
|
* @type GuacamoleService.Protocol.Parameter[]
|
|
*/
|
|
this.parameters = parameters || [];
|
|
|
|
};
|
|
|
|
/**
|
|
* A parameter belonging to a protocol. Each parameter has a name which
|
|
* identifies the parameter to the protocol, a human-readable title,
|
|
* a value for boolean parameters, and a type which dictates
|
|
* its presentation to the user.
|
|
*/
|
|
GuacamoleService.Protocol.Parameter = function(name, title, type, value, options) {
|
|
|
|
/**
|
|
* The name of this parameter.
|
|
*/
|
|
this.name = name;
|
|
|
|
/**
|
|
* A human-readable title describing this parameter.
|
|
*/
|
|
this.title = title;
|
|
|
|
/**
|
|
* The type of this parameter.
|
|
*/
|
|
this.type = type;
|
|
|
|
/**
|
|
* The value of this parameter.
|
|
*/
|
|
this.value = value;
|
|
|
|
/**
|
|
* All available options, if applicable, in desired order of presentation.
|
|
* @type GuacamoleService.Protocol.Parameter.Option[]
|
|
*/
|
|
this.options = options || [];
|
|
|
|
};
|
|
|
|
/**
|
|
* An option for a parameter. A parameter has options if it only has a specified
|
|
* and enumerated legal set of values.
|
|
*/
|
|
GuacamoleService.Protocol.Parameter.Option = function(value, title) {
|
|
|
|
/**
|
|
* The value of this option. This is the value that will be assigned to the
|
|
* parameter if this option is chosen.
|
|
*/
|
|
this.value = value;
|
|
|
|
/**
|
|
* The title of this option. This is the value that will be presented to the
|
|
* user for selection.
|
|
*/
|
|
this.title = title;
|
|
|
|
};
|
|
|
|
/**
|
|
* A free-form text field.
|
|
*/
|
|
GuacamoleService.Protocol.Parameter.TEXT = "TEXT";
|
|
|
|
/**
|
|
* A password field.
|
|
*/
|
|
GuacamoleService.Protocol.Parameter.PASSWORD = "PASSWORD";
|
|
|
|
/**
|
|
* A numeric field.
|
|
*/
|
|
GuacamoleService.Protocol.Parameter.NUMERIC = "NUMERIC";
|
|
|
|
/**
|
|
* A boolean (checkbox) field.
|
|
*/
|
|
GuacamoleService.Protocol.Parameter.BOOLEAN = "BOOLEAN";
|
|
|
|
/**
|
|
* An enumerated (select) field.
|
|
*/
|
|
GuacamoleService.Protocol.Parameter.ENUM = "ENUM";
|
|
|
|
/**
|
|
* A free-form, multi-line text field.
|
|
*/
|
|
GuacamoleService.Protocol.Parameter.MULTILINE = "MULTILINE";
|
|
|
|
/**
|
|
* Collection of service functions which deal with protocols. Each function
|
|
* makes an explicit HTTP query to the server, and parses the response.
|
|
*/
|
|
GuacamoleService.Protocols = {
|
|
|
|
/**
|
|
* Returns an object containing all available protocols and all
|
|
* corresponding parameters, as well as hints regarding expected datatype
|
|
* and allowed/default values.
|
|
*
|
|
* @return {Object.<String, GuacamoleService.Protocol>}
|
|
* An object mapping the names of all available protocols to
|
|
* their corresponding details.
|
|
*/
|
|
"list" : function() {
|
|
|
|
// Construct request URL
|
|
var list_url = "api/protocol"
|
|
+ "?token=" + GuacamoleService.Auth.current().authToken;
|
|
|
|
// Get permission list
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("GET", list_url, false);
|
|
xhr.send(null);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
return JSON.parse(xhr.responseText);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Collection of service functions which deal with the clipboard state. Each
|
|
* function makes an explicit HTTP query to the server, and parses the response.
|
|
*/
|
|
GuacamoleService.Clipboard = {
|
|
|
|
"get" : function() {
|
|
|
|
// Construct request URL
|
|
var list_url = "api/clipboard"
|
|
+ "?token=" + GuacamoleService.Auth.current().authToken;
|
|
|
|
// Get permission list
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("GET", list_url, false);
|
|
xhr.send(null);
|
|
|
|
// Handle response
|
|
GuacamoleService.handleResponse(xhr);
|
|
return xhr.responseText;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Collection of service functions which deal with the session keep-alive. Each
|
|
* function makes an explicit HTTP query to the server. In the case of the
|
|
* keep-alive ping, no response is expected, and any received response is
|
|
* ignored.
|
|
*/
|
|
GuacamoleService.KeepAlive = {
|
|
|
|
"ping" : function() {
|
|
|
|
// Construct request URL
|
|
var ping_url = "api/keep-alive"
|
|
+ "?token=" + GuacamoleService.Auth.current().authToken;
|
|
|
|
// Send keep-alive "ping"
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("GET", ping_url, true);
|
|
xhr.send(null);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Collection of service functions which deal with authentication. Note that,
|
|
* unlike everything else here, not all functions in GuacamoleService.Auth
|
|
* make explicit HTTP queries.
|
|
*/
|
|
GuacamoleService.Auth = {
|
|
|
|
/**
|
|
* Attempts to login the given user using the given password, throwing an
|
|
* error if the process fails. The resulting token, if successful, is
|
|
* automatically stored locally within a cookie called "GUAC_TOKEN". This
|
|
* token can be later retrieved via GuacamoleService.current().authToken.
|
|
*
|
|
* @param {String} username The name of the user to login as.
|
|
* @param {String} password The password to use to authenticate the user.
|
|
*/
|
|
"login" : function(username, password) {
|
|
|
|
// Populate data with username and password
|
|
var data =
|
|
"username=" + encodeURIComponent(username)
|
|
+ "&password=" + encodeURIComponent(password)
|
|
|
|
// Include query parameters in submission data
|
|
if (GuacamoleRootUI.parameters)
|
|
data += "&" + GuacamoleRootUI.parameters;
|
|
|
|
// Log in
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("POST", "api/login", false);
|
|
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
|
|
xhr.send(data);
|
|
|
|
// Handle failures
|
|
if (xhr.status !== 200)
|
|
throw new Error("Invalid login");
|
|
|
|
// Store auth token in cookie
|
|
var response = JSON.parse(xhr.responseText);
|
|
document.cookie = "GUAC_AUTH=" + encodeURIComponent(JSON.stringify(response));
|
|
|
|
},
|
|
|
|
/**
|
|
* Returns the current auth result received via login. This result will
|
|
* contain, among other things, the authToken.
|
|
*
|
|
* @returns {Object} The result of the most recent login, if any. If no such
|
|
* result exists, an empty object is returned.
|
|
*/
|
|
"current" : function() {
|
|
|
|
var guacAuth = document.cookie.replace(/(?:(?:^|.*;\s*)GUAC_AUTH\s*\=\s*([^;]*).*$)|^.*$/, "$1");
|
|
if (!guacAuth)
|
|
return {};
|
|
|
|
return JSON.parse(decodeURIComponent(guacAuth));
|
|
|
|
}
|
|
|
|
};
|