├── .gitignore
├── .npmignore
├── COPYING
├── LICENSE.txt
├── README.md
└── pyxterm
    ├── _static
        ├── index.html
        ├── pyxterm.js
        └── term.js
    ├── pyxshell.py
    └── pyxterm.py


/.gitignore:
--------------------------------------------------------------------------------
 1 | .DS_Store
 2 | *~
 3 | *.pyc
 4 | *.prev
 5 | *.sav
 6 | *.old
 7 | *.pem
 8 | README.html
 9 | build/*
10 | dist/*
11 | pyxterm.egg-info/*
12 | BAK
13 | IGNORE
14 | ORIG
15 | SUBMIT
16 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
 1 | .git*
 2 | build/
 3 | .lock-wscript
 4 | out/
 5 | Makefile.gyp
 6 | *.Makefile
 7 | *.target.gyp.mk
 8 | node_modules/
 9 | img/
10 | test/
11 | *.node
12 | example/*.log
13 | 


--------------------------------------------------------------------------------
/COPYING:
--------------------------------------------------------------------------------
 1 | Unless otherwise indicated, pyxterm files are distributed
 2 | under the BSD License (see LICENSE.txt).
 3 | 
 4 | This package also includes other bundled open source
 5 | components which are governed by their own licenses,
 6 | as indicated in the respective files. These include:
 7 | 
 8 |   pyxshell.py: Public Domain
 9 |   index.html, term.js, pyxterm.js: MIT
10 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | # pyxterm: A python websocket server backend for term.js
 2 | #
 3 | #  BSD License
 4 | #
 5 | #  Copyright (c) 2014, Ramalingam Saravanan <sarava@sarava.net>
 6 | #  All rights reserved.
 7 | #  
 8 | #  Redistribution and use in source and binary forms, with or without
 9 | #  modification, are permitted provided that the following conditions are met:
10 | #  
11 | #  1. Redistributions of source code must retain the above copyright notice, this
12 | #     list of conditions and the following disclaimer. 
13 | #  2. Redistributions in binary form must reproduce the above copyright notice,
14 | #     this list of conditions and the following disclaimer in the documentation
15 | #     and/or other materials provided with the distribution. 
16 | #  
17 | #  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
18 | #  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19 | #  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20 | #  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
21 | #  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22 | #  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23 | #  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24 | #  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 | #  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 | #  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 | 
28 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ## pyxterm: Pure python websocket terminal server for term.js
  2 | 
  3 | Uses ``term.js`` from <https://github.com/chjj/term.js>
  4 | 
  5 | Requires the tornado web server from <http://www.tornadoweb.org>
  6 | 
  7 | *Note:* To be consistent with ``term.js``, this package should have been
  8 | named either ``term.py`` or ``tty.py``, but those names are already in
  9 | use. Hence the name ``pyxterm``.
 10 | 
 11 | 
 12 | ### Main files
 13 | 
 14 | * ``pyxterm.py``: Terminal server
 15 | 
 16 | * ``pyxshell.py``: Backend pseudo-tty shell manager
 17 | 
 18 | * ``_static/pyxterm.js``: Javascript wrappers for ``term.js``
 19 | 
 20 | * ``_static/index.html``: Example terminal template
 21 | 
 22 | ### Testing
 23 | 
 24 | To try it out, run:
 25 | 
 26 |     ./pyxterm.py --auth_type=none --terminal
 27 | 
 28 | to start the server with no authentication and open a ``bash`` shell terminal.
 29 | 
 30 | The default URL to a create a new terminal is
 31 | ``http://localhost:8700/new``. To create a named terminal, open
 32 | ``http://localhost:8700/terminal_name``
 33 | 
 34 | Other authentication/shell options are
 35 | 
 36 | * ``./pyxterm.py --auth_type=ssh`` for SSH login to localhost (default)
 37 | 
 38 | * ``sudo ./pyxterm.py --auth_type=login`` for standard Unix-style login
 39 | 
 40 | * ``./pyxterm.py --auth_type=google`` for Google authentication
 41 | 
 42 | * ``./pyxterm.py --auth_type=none /bin/shell_program `` to run a different "shell" program
 43 | 
 44 | * ``./pyxterm.py --auth_type=none ipython `` to run ipython as the "shell"
 45 | 
 46 | * ``./pyxterm.py --auth_type=none /usr/bin/env python /path/app.py `` to use a python script as the "shell"
 47 | 
 48 | 
 49 | For more help information, type
 50 | 
 51 |     ./pyxterm.py -h
 52 | 
 53 | ### Google authentication
 54 | 
 55 | To set up the ``pyxterm`` for Google authentication:
 56 | 
 57 |  * Go to the Google Dev Console at <https://console.developers.google.com>
 58 | 
 59 |  * Select a project, or create a new one.
 60 | 
 61 |  * In the sidebar on the left, select *APIs & Auth*.
 62 | 
 63 |  * In the sidebar on the left, select *Consent Screen* to customize the Product name etc.
 64 | 
 65 |  * In the sidebar on the left, select *Credentials*.
 66 | 
 67 |  * In the OAuth section of the page, select *Create New Client ID*.
 68 | 
 69 |  * Edit settings for the Authorized URIs, substituting ``localhost:8700`` if need be
 70 | 
 71 |     Authorized Javascript origins: ``http://localhost:8700``
 72 | 
 73 |     Authorized Redirect URI: ``http://localhost:8700/_gauth``
 74 | 
 75 |  * Copy the web application "Client ID key" and "Client secret" to the settings file (see below)
 76 | 
 77 | Start the server with the command:
 78 | 
 79 |     ./pyxterm.py --auth_type=google
 80 | 
 81 | and use the URLs ``http://localhost:8700/_gauth/_info`` and
 82 | ``http://localhost:8700/_gauth/_test`` to display setup
 83 | information and test Google authentication.
 84 | 
 85 | ### Settings file
 86 | 
 87 | Settings may be provided in JSON format in the file
 88 | ``.pyxterm.json`` in the home directory. If present, it contains
 89 | information of the form:
 90 | 
 91 |     {"google_oauth": {"key": "0123456789-code.apps.googleusercontent.com",
 92 |                       "secret": "ABCDEFABCDEF"},
 93 |      "auth_emails": ["user1@gmail.com", "user2@gmail.com"] }
 94 | 
 95 | ``auth_emails`` is the list of gmail accounts authorized to access the
 96 | server. An empty list implies all accounts are authorized.
 97 | 
 98 | ### History and goals
 99 | 
100 | The goal is to provide a simple Python terminal server for ``term.js`` using websockets, akin to ``tty.js``.
101 | 
102 | ``pyxterm`` contains code simplified and factored out of more complex ``GraphTerm`` code
103 | (<https://github.com/mitotic/graphterm>), which itself used some old code from
104 | ``AjaxTerm``
105 | 
106 | 
107 | Licenses: MIT, BSD
108 | 
109 | Version: 0.10 (alpha)
110 | 


--------------------------------------------------------------------------------
/pyxterm/_static/index.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <head>
  3 | <title>pyxterm</title>
  4 | <!--
  5 |   pyxterm: Basic Python socket implementation for term.js
  6 | 
  7 |   Example template
  8 |   Modified by: R. Saravanan <sarava@sarava.net> 2014
  9 |   Original Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
 10 | -->
 11 | <style>
 12 |   html {
 13 |     background: #555;
 14 |   }
 15 | 
 16 |   h1 {
 17 |     margin-bottom: 20px;
 18 |     font: 20px/1.5 sans-serif;
 19 |   }
 20 | 
 21 | /*
 22 |   .terminal {
 23 |     float: left;
 24 |     border: #000 solid 5px;
 25 |     font-family: "DejaVu Sans Mono", "Liberation Mono", monospace;
 26 |     font-size: 11px;
 27 |     color: #f0f0f0;
 28 |     background: #000;
 29 |   }
 30 | 
 31 |   .terminal-cursor {
 32 |     color: #000;
 33 |     background: #f0f0f0;
 34 |   }
 35 | */
 36 | </style>
 37 | <script src="/_static/term.js"></script>
 38 | <script src="/_static/pyxterm.js"></script>
 39 | <script>
 40 | ;(function() {
 41 |   var self = this;
 42 |   function resize() {
 43 |     var rows = Math.max(2, Math.floor(window.innerHeight/self.termRowHeight)-1);
 44 |     var cols = Math.max(3, Math.floor(window.innerWidth/self.termColWidth)-1);
 45 |     console.log("resize:", self.termRowHeight, self.termColWidth, window.innerHeight, window.innerWidth, rows, cols);
 46 |     return {rows: rows, cols: cols};
 47 |   }
 48 | 
 49 |   window.onload = function() {
 50 |     // Test size: 25x80
 51 |     self.termRowHeight = 0.0 + 1.00*document.getElementById("dummy-screen").offsetHeight / 25;
 52 |     self.termColWidth = 0.0 + (1.02*document.getElementById("dummy-screen-rows").offsetWidth / 80);
 53 |     document.getElementById("dummy-screen").setAttribute("style", "display: none");
 54 | 
 55 |     var socket = new WebSock();
 56 |     socket.on('setup', function(params) {
 57 | 
 58 |       var geom = resize();
 59 |       self.pyxTerminal = new Pyxterm(socket,  // Expose for testing
 60 |       params, {cols: geom.cols,
 61 |         rows: geom.rows,
 62 |         useStyle: true,
 63 |         screenKeys: true,
 64 |         cursorBlink: false
 65 |       });
 66 | 
 67 |     window.onresize = function() { 
 68 |       var geom = resize();
 69 |       self.pyxTerminal.resize(geom.cols, geom.rows);
 70 |       socket.emit("set_size", geom.rows, geom.cols, window.innerHeight, window.innerWidth);
 71 |     };
 72 |     self.pyxSocket = socket;    // Expose for testing
 73 |     });
 74 |   };
 75 | 
 76 | }).call(this);
 77 | </script>
 78 | </head>
 79 | <body>
 80 | <!-- test size: 25x80 -->
 81 | <pre id="dummy-screen" style="visibility:hidden; border: white solid 5px; font-family: &quot;DejaVu Sans Mono&quot;, &quot;Liberation Mono&quot;, monospace; font-size: 11px;">0
 82 | 1
 83 | 2
 84 | 3
 85 | 4
 86 | 5
 87 | 6
 88 | 7
 89 | 8
 90 | 9
 91 | 0
 92 | 1
 93 | 2
 94 | 3
 95 | 4
 96 | 5
 97 | 6
 98 | 7
 99 | 8
100 | 9
101 | 0
102 | 1
103 | 2
104 | 3
105 | <span id="dummy-screen-rows" style="visibility:hidden;">01234567890123456789012345678901234567890123456789012345678901234567890123456789</span>
106 | </body>


--------------------------------------------------------------------------------
/pyxterm/_static/pyxterm.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * pyxterm: Basic Python socket implementation for term.js
  3 |  *          https://github.com/chjj/term.js/
  4 |  *
  5 |  * Requires term.js, pyxserver.py, pyxterm.py
  6 |  *
  7 |  * To test, run:
  8 |  *
  9 |  *    ./pyxserver.py --terminal
 10 |  *
 11 |  * Distributed under the MIT License, like term.js
 12 |  *
 13 |  * Modified by: R. Saravanan <sarava@sarava.net> 2014
 14 |  * Original Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
 15 |  */
 16 | 
 17 | ;(function() {
 18 | 
 19 | var document = this.document
 20 |   , window = this;
 21 | 
 22 | var EventEmitter = Terminal.EventEmitter
 23 |   , inherits = Terminal.inherits
 24 |   , on = Terminal.on
 25 |   , off = Terminal.off
 26 |   , cancel = Terminal.cancel;
 27 | 
 28 | function Pyxterm(socket, remoteParams, options) {
 29 |     // Wrapper class for Terminal to interface with WebSock
 30 |     var self = this;
 31 | 
 32 |     this.socket = socket;
 33 |     this.remoteParams = remoteParams;
 34 | 
 35 |     if (remoteParams.state_id)
 36 | 	setAuth(remoteParams.state_id);
 37 | 
 38 |     Terminal.call(this, options)
 39 | 
 40 |     this.on('data', function(data) {
 41 |         self.socket.emit('stdin', data);
 42 |     });
 43 | 
 44 |     this.on('title', function(title) {
 45 |         document.title = title;
 46 |     });
 47 | 
 48 |     this.emit('title', remoteParams.term_path);
 49 |     this.open(document.body);
 50 | 
 51 |     self.socket.on('stdout', function(data) {
 52 |         self.write(data);
 53 |     });
 54 | 
 55 |     self.socket.on('disconnect', function(code) {
 56 |         self.write("\r\n\r\n[CLOSED]\r\n");
 57 |         //self.destroy();
 58 |     });
 59 | 
 60 |     this.socket.remote_emit("set_size", options.rows, options.cols, window.innerHeight, window.innerWidth);
 61 | 
 62 | }
 63 | 
 64 | inherits(Pyxterm, Terminal);
 65 | 
 66 | 
 67 | /**
 68 |  * WebSocket
 69 |  */
 70 | 
 71 | function WebSock(term_path) {
 72 |     var self = this;
 73 | 
 74 |     EventEmitter.call(this);
 75 | 
 76 |     this.failed = false;
 77 |     this.opened = false;
 78 |     this.closed = false;
 79 | 
 80 |     if (!term_path) {
 81 | 	var comps = window.location.pathname.split("/").slice(1);
 82 | 	term_path = comps.length ? comps[0] : "new";
 83 |     }
 84 |     this.term_path = term_path;
 85 | 
 86 |     var protocol = (window.location.protocol.indexOf("https") === 0) ? "wss" : "ws";
 87 |     this.ws_url = protocol+":/"+"/"+window.location.host+"/_websocket/"+this.term_path
 88 |     if (window.location.search)
 89 | 	this.ws_url += window.location.search;
 90 |     this.ws = new WebSocket(this.ws_url);
 91 |     this.ws.binaryType = "arraybuffer";
 92 |     this.ws.onopen = bind_method(this, this.onopen);
 93 |     this.ws.onmessage = bind_method(this, this.onmessage);
 94 |     this.ws.onclose = bind_method(this, this.onclose);
 95 |     console.log("WebSock.__init__: ", this._events);
 96 | 
 97 |     this.on("abort", function() {
 98 | 	console.log("WebSock.abort: ");
 99 | 	self.close();
100 |     });
101 | 
102 |     this.on("stdin", function(text, type_ahead) {
103 | 	// Send stdin text to terminal
104 | 	self.remote_emit("stdin", text);
105 |     });
106 | 
107 |     this.on("kill_term", function(text) {
108 | 	self.remote_emit("kill_term");
109 |     });
110 | }
111 | 
112 | inherits(WebSock, EventEmitter);
113 | 
114 | WebSock.prototype.close = function() {
115 |   console.log("WebSock.close: ");
116 |   if (this.closed)
117 |     return;
118 | 
119 |   this.closed = true;
120 |   this.emit("close");
121 |   try {
122 |     this.ws.close();
123 |   } catch(err) {
124 |   }
125 | }
126 | 
127 | WebSock.prototype.write = function(msg) {
128 | // Write object as JSON (but send ArrayBuffers directly)
129 |     try {
130 | 	if (this.ws.readyState > WebSocket.OPEN)
131 | 	    throw "Websocket closed";
132 | 	this.ws.send( (msg instanceof ArrayBuffer) ? msg : JSON.stringify(msg) );
133 |     } catch(err) {
134 | 	if (window.confirm("Error in websocket ("+err+"). Reload page?")) {
135 | 	    window.location.reload();
136 | 	}
137 |     }
138 | }
139 | 
140 | WebSock.prototype.remote_emit = function() {
141 |     this.write([].slice.call(arguments));
142 | }
143 | 
144 | WebSock.prototype.onopen = function(evt) {
145 |   console.log("WebSock.onopen: ");
146 |   this.emit("open");
147 | }
148 | 
149 | WebSock.prototype.onclose = function(evt) {
150 |   console.log("WebSock.onclose: ");
151 |   if (!this.opened && !this.closed && !this.failed) {
152 |       this.failed = true;
153 |       alert("pyxterm: Failed to open websocket: "+this.ws_url);
154 |   } else {
155 |       //PopAlert("Terminal closed");
156 |   }
157 | 
158 |   if (!this.closed) {
159 |     this.closed = true;
160 |     this.emit("close");
161 |   }
162 | }
163 | 
164 | WebSock.prototype.onmessage = function(evt) {
165 |     if (this.closed)
166 | 	return;
167 | 
168 |     if (!this.opened) {
169 | 	// Validate
170 | 	this.opened = true;
171 | 	this.emit("connect");
172 |     }
173 | 
174 |     var payload = evt.data;
175 |     //console.log("WebSock.onmessage: "+payload);
176 | 
177 |     try {
178 | 	var command;
179 | 	var content = null;
180 | 	if (payload instanceof ArrayBuffer) {
181 | 	    console.log("WebSock.onmessage: ArrayBuffer: "+payload.byteLength);
182 | 	    var delim = "\n\n";
183 | 	    var offset = abIndexOf(delim, payload);
184 | 	    if (offset < 0)
185 | 		throw("Delimiter not found in binary message");
186 | 	    content = payload.slice(2*(offset+delim.length));
187 | 	    var bufView = new Uint16Array(buf);
188 | 	    var msg_str = String.fromCharCode.apply(null, bufView.slice(0,offset));
189 | 	    command = JSON.parse(msg_str);
190 | 	} else {
191 | 	    command = JSON.parse(payload);
192 | 	}
193 | 	var action = command[0];
194 | 
195 | 	var method = "on_" + action;
196 | 	if (!(method in this) && !(action in this._events)) {
197 | 	    console.log("WebSock.onmessage: Invalid remote method "+action);
198 | 	    this.remote_emit("errmsg", "Invalid remote action "+action);
199 | 	} else {
200 | 	    try {
201 | 		if (method in this)
202 | 		    this[method].apply(this, command[1]);
203 | 
204 | 		if (action in this._events)
205 | 		    this.emit.apply(this, [action].concat(command[1]));
206 | 	    } catch(err) {
207 | 		console.log("WebSock.onmessage: Error in remote method "+action+" execution:", err, err.stack);
208 | 		this.remote_emit("errmsg", "Error in action "+action+": "+err);
209 | 	    }
210 | 	}
211 |     } catch(err) {
212 | 	console.log("WebSock.onmessage", err, err.stack);
213 | 	this.remote_emit("errmsg", ""+err);
214 | 	this.close();
215 |     }
216 | }
217 | 
218 | WebSock.prototype.on_eval_js = function(command) {
219 |     // Evaluate Javascript
220 |     var stdout = "";
221 |     var stderr = "";
222 |     try {
223 | 	console.log("pyxterm.eval_js:", command);
224 | 	var evalout = eval(command);
225 | 	stdout = evalout ? evalout+"" : "";
226 | 	console.log("pyxterm.eval_js:", stdout);
227 |     } catch (err) {
228 | 	stderr = err+"";
229 | 	console.log("pyxterm.eval_js:", stderr);
230 |     }
231 | 
232 |     this.remote_emit("eval_output", stdout, stderr);
233 | }
234 | 
235 | WebSock.prototype.on_errmsg = function(msg) {
236 |     // Display console error message
237 |     console.log("ERROR ", msg);
238 | }
239 | 
240 | WebSock.prototype.on_alert = function(msg) {
241 |     // Display browser alert
242 |     console.log("ALERT ", msg);
243 |     alert(msg);
244 | }
245 | 
246 | WebSock.prototype.on_document = function(html) {
247 |     // Overwrite document HTML
248 |     document.documentElement.innerHTML = html;
249 | }
250 | 
251 | WebSock.prototype.on_redirect = function(url, state_id) {
252 |     // Redirect to URL
253 |     if (state_id)
254 | 	setAuth(state_id);
255 |     window.location = url;
256 | }
257 | 
258 | 
259 | /**
260 |  * Helpers
261 |  */
262 | 
263 | function bind_method(obj, method) {
264 |   return function() {
265 |     return method.apply(obj, arguments);
266 |   }
267 | }
268 | 
269 | // Cookies - http://www.quirksmode.org/js/cookies.html
270 | function createCookie(name,value,days) {
271 | 	if (days) {
272 | 		var date = new Date();
273 | 		date.setTime(date.getTime()+(days*24*60*60*1000));
274 | 		var expires = "; expires="+date.toGMTString();
275 | 	}
276 | 	else var expires = "";
277 | 	document.cookie = name+"="+value+expires+"; path=/";
278 | }
279 | 
280 | function readCookie(name) {
281 | 	var nameEQ = name + "=";
282 | 	var ca = document.cookie.split(';');
283 | 	for(var i=0;i < ca.length;i++) {
284 | 		var c = ca[i];
285 | 		while (c.charAt(0)==' ') c = c.substring(1,c.length);
286 | 		if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length);
287 | 	}
288 | 	return null;
289 | }
290 | 
291 | function eraseCookie(name) {
292 | 	createCookie(name,"",-1);
293 | }
294 | 
295 | var AUTH_COOKIE = "PYXTERM_AUTH";
296 | var AUTH_DIGITS = 12;      // Hex digits for form authentication
297 | 
298 | function setAuth(value) {
299 |     return createCookie(AUTH_COOKIE, value);
300 | }
301 | 
302 | function getQueryAuth() {
303 |     return readCookie(AUTH_COOKIE).substr(0,AUTH_DIGITS);
304 | }
305 | 
306 | // ArrayBuffer to String conversion (using UTF-16 encoding)
307 | // http://updates.html5rocks.com/2012/06/How-to-convert-ArrayBuffer-to-and-from-String
308 | function ab2str(buf) {
309 |     return String.fromCharCode.apply(null, new Uint16Array(buf));
310 | }
311 | 
312 | function str2ab(str) {
313 |     var buf = new ArrayBuffer(str.length*2); // 2 bytes for each char
314 |     var bufView = new Uint16Array(buf);
315 |     for (var i=0, strLen=str.length; i<strLen; i++) {
316 |         bufView[i] = str.charCodeAt(i);
317 |     }
318 |     return buf;
319 | }
320 | 
321 | function abIndexOf(s, buf) {
322 | // Return indexOf string s in Uint16 ArrayBuffer
323 |     var bufView = new Uint16Array(buf);
324 |     var firstCode = s.charCodeAt(0);
325 |     var j = -1;
326 |     var offset = -1;
327 |     while (offset < 0 && j < bufView.length-1) {
328 | 	j = bufView.indexOf(firstCode, j+1);
329 | 	if (j < 0)
330 | 	    break;
331 | 	offset = j;
332 | 	for (var k=1; k<s.length; k++) {
333 | 	    if (bufView[j+k] != s.charCodeAt(k)) {
334 | 		offset = -1;
335 | 		break;
336 | 	    }
337 | 	}
338 |     }
339 |     return offset;
340 | }
341 | 
342 | /**
343 |  * Expose
344 |  */
345 | 
346 | Pyxterm.getQueryAuth = getQueryAuth;
347 | 
348 | this.WebSock = WebSock;
349 | this.Pyxterm = Pyxterm;
350 | 
351 | }).call(function() {
352 |   return this || (typeof window !== 'undefined' ? window : global);
353 | }());
354 | 


--------------------------------------------------------------------------------
/pyxterm/pyxshell.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | 
  3 | """ pyxshell.py: pseudo-tty shell wrapper for terminals
  4 | 
  5 | Derived from the public-domain Ajaxterm code, v0.11 (2008-11-13).
  6 |   https://github.com/antonylesuisse/qweb
  7 |   http://antony.lesuisse.org/software/ajaxterm/
  8 | and susequently modified for GraphTerm as lineterm.py, v0.57.0 (2014-07-18)
  9 |   https://github.com/mitotic/graphterm
 10 | 
 11 | The contents of this file remain in the public-domain.
 12 | 
 13 | To test, run:
 14 | 
 15 |   ./pyxshell.py
 16 | 
 17 | Type exactly two Control-D's to exit the shell
 18 | 
 19 | """
 20 | 
 21 | from __future__ import absolute_import, print_function, with_statement
 22 | 
 23 | 
 24 | # Python3-friendly imports
 25 | try:
 26 |     import queue
 27 | except ImportError:
 28 |     import Queue as queue
 29 | 
 30 | import sys
 31 | if sys.version_info[0] < 3:
 32 |     byte_code = ord
 33 | else:
 34 |     byte_code = lambda x: x
 35 |     unicode = str
 36 | 
 37 | import errno
 38 | import fcntl
 39 | import logging
 40 | import os
 41 | import pty
 42 | import re
 43 | import select
 44 | import shlex
 45 | import signal
 46 | import struct
 47 | import subprocess
 48 | import traceback
 49 | import threading
 50 | import time
 51 | import termios
 52 | import tty
 53 | 
 54 | import random
 55 | try:
 56 |     random = random.SystemRandom()
 57 | except NotImplementedError:
 58 |     import random
 59 | 
 60 | 
 61 | ENV_PREFIX = "PYXTERM_"       # Environment variable prefix
 62 | NO_COPY_ENV = set([])         # Do not copy these environment variables
 63 | 
 64 | EXEC_DIR = ""                 # If specified, this subdirectory will be prepended to the PATH
 65 | File_dir = os.path.dirname(__file__)
 66 | Exec_path = os.path.join(File_dir, EXEC_DIR) if EXEC_DIR else ""
 67 | 
 68 | DEFAULT_TERM_TYPE = "xterm"
 69 | 
 70 | IDLE_TIMEOUT = 300            # Idle timeout in seconds
 71 | UPDATE_INTERVAL = 0.05        # Terminal output update time interval
 72 | CHUNK_BYTES = 4096            # Chunk size for receiving data in stdin
 73 | 
 74 | TERM_NAME_RE = re.compile(r"^[a-z][a-z0-9_]*$")   # Allowed terminal names
 75 | 
 76 | # Helper functions
 77 | def make_term_cookie():
 78 |     return "%016d" % random.randrange(10**15, 10**16)
 79 | 
 80 | def command_output(command_args, **kwargs):
 81 |     """ Executes a command and returns the string tuple (stdout, stderr)
 82 |     keyword argument timeout can be specified to time out command (defaults to 15 sec)
 83 |     """
 84 |     timeout = kwargs.pop("timeout", 15)
 85 |     def command_output_aux():
 86 |         try:
 87 |             proc = subprocess.Popen(command_args, stdout=subprocess.PIPE,
 88 |                                     stderr=subprocess.PIPE)
 89 |             return proc.communicate()
 90 |         except Exception as excp:
 91 |             return "", str(excp)
 92 |     if not timeout:
 93 |         return command_output_aux()
 94 | 
 95 |     exec_queue = queue.Queue()
 96 |     def execute_in_thread():
 97 |         exec_queue.put(command_output_aux())
 98 |     thrd = threading.Thread(target=execute_in_thread)
 99 |     thrd.start()
100 |     try:
101 |         return exec_queue.get(block=True, timeout=timeout)
102 |     except queue.Empty:
103 |         return "", "Timed out after %s seconds" % timeout
104 | 
105 | def set_tty_speed(fd, baudrate=termios.B230400):
106 |     tem_settings = termios.tcgetattr(fd)
107 |     tem_settings[4:6] = (baudrate, baudrate)
108 |     termios.tcsetattr(fd, termios.TCSADRAIN, tem_settings)
109 | 
110 | def set_tty_echo(fd, enabled):
111 |     tem_settings = termios.tcgetattr(fd)
112 |     if enabled:
113 |         tem_settings[3] |= termios.ECHO
114 |     else:
115 |         tem_settings[3] &= ~termios.ECHO
116 |     termios.tcsetattr(fd, termios.TCSADRAIN, tem_settings)
117 | 
118 | def is_executable(filepath):
119 |     return os.path.isfile(filepath) and os.access(filepath, os.X_OK)
120 | 
121 | def which(filepath, add_path=[]):
122 |     filedir, filename = os.path.split(filepath)
123 |     if filedir:
124 |         if is_executable(filepath):
125 |             return filepath
126 |     else:
127 |         for path in os.environ["PATH"].split(os.pathsep) + add_path:
128 |             whichpath = os.path.join(path, filepath)
129 |             if is_executable(whichpath):
130 |                 return whichpath
131 |     return None
132 | 
133 | def match_program_name(name):
134 |     """ Return full path to command name, if running. else null string"""
135 |     std_out, std_err = command_output(["ps", "aux"], timeout=1)
136 |     for line in std_out.split('\n'):
137 |         comps = line.split(None, 10)
138 |         if not comps or not comps[-1].strip():
139 |             continue
140 |         cmd_comps = comps[-1].split()
141 |         if cmd_comps[0].endswith("/"+name):
142 |             return cmd_comps[0]
143 |     return ""
144 | 
145 | def getcwd(pid):
146 |     """Return working directory of running process
147 |     Note: This will return os.path.realpath of current directory (eliminating symbolic links),
148 |     which may differ from the $PWD value
149 |     """
150 |     if sys.platform.startswith("linux"):
151 |         command_args = ["pwdx", str(pid)]
152 |     else:
153 |         command_args = ["lsof", "-a", "-p", str(pid), "-d", "cwd", "-Fn"]
154 |     std_out, std_err = command_output(command_args, timeout=1)
155 |     if std_err:
156 |         logging.warning("getcwd: ERROR %s", std_err)
157 |         return ""
158 |     try:
159 |         if sys.platform.startswith("linux"):
160 |             return std_out.split()[1]
161 |         else:
162 |             return std_out.split("\n")[1][1:]
163 |     except Exception as excp:
164 |         logging.warning("getcwd: ERROR %s", excp)
165 |         return ""
166 | 
167 | def shlex_split_str(line):
168 |     # Avoid NULs introduced by shlex.split when splitting unicode
169 |     return shlex.split(line if isinstance(line, str) else line.encode("utf-8", "replace"))
170 | 
171 | def setup_logging(log_level=logging.ERROR, filename="", file_level=None):
172 |     file_level = file_level or log_level
173 |     logger = logging.getLogger()
174 |     logger.setLevel(min(log_level, file_level))
175 | 
176 |     formatter = logging.Formatter("%(levelname).1s%(asctime)s %(module).8s.%(lineno).04d %(message)s",
177 |                                   "%y%m%d/%H:%M")
178 | 
179 |     if logger.handlers:
180 |         for handler in logger.handlers:
181 |             handler.setLevel(log_level)
182 |             handler.setFormatter(formatter)
183 |     else:
184 |         # Console handler
185 |         chandler = logging.StreamHandler()
186 |         chandler.setLevel(log_level)
187 |         chandler.setFormatter(formatter)
188 |         logger.addHandler(chandler)
189 | 
190 |     if filename:
191 |         # File handler
192 |         fhandler = logging.FileHandler(filename)
193 |         fhandler.setLevel(file_level)
194 |         fhandler.setFormatter(formatter)
195 |         logger.addHandler(fhandler)
196 | 
197 | 
198 | class Terminal(object):
199 |     """Single pseudo-tty"""
200 |     def __init__(self, term_name, fd, pid, manager, height=25, width=80, winheight=0, winwidth=0,
201 |                  cookie=0, access_code="", log=False):
202 |         self.term_name = term_name
203 |         self.fd = fd
204 |         self.pid = pid
205 |         self.manager = manager
206 |         self.width = width
207 |         self.height = height
208 |         self.winwidth = winwidth
209 |         self.winheight = winheight
210 |         self.cookie = cookie
211 |         self.access_code = access_code
212 |         self.term_encoding = manager.term_settings.get("encoding", "utf-8")
213 |         self.log = log
214 | 
215 |         self.current_dir = ""
216 |         self.update_buf = ""
217 | 
218 |         self.init()
219 |         self.reset()
220 |         self.rpc_set_size(height, width, winheight, winwidth)
221 | 
222 |         self.output_time = time.time()
223 | 
224 |     def init(self):
225 |         pass
226 | 
227 |     def reset(self):
228 |         self.update_time = 0
229 |         self.update_needed = True
230 |         self.reply_buf = ""
231 | 
232 |     def resize_buffer(self, height, width, winheight=0, winwidth=0, force=False):
233 |         reset_flag = force or (self.width != width or self.height != height)
234 |         self.winwidth = winwidth
235 |         self.winheight = winheight
236 |         if reset_flag:
237 |             self.width = width
238 |             self.height = height
239 |             self.reset()
240 | 
241 |     def rpc_set_size(self, height, width, winheight=0, winwidth=0):
242 |         # python bug http://python.org/sf/1112949 on amd64
243 |         self.resize_buffer(height, width, winheight=winheight, winwidth=winwidth)
244 |         # Hack for buggy TIOCSWINSZ handling: treat large unsigned positive int32 values as negative (same bits)
245 |         winsz = termios.TIOCSWINSZ if termios.TIOCSWINSZ < 0 else struct.unpack('i',struct.pack('I',termios.TIOCSWINSZ))[0]
246 |         fcntl.ioctl(self.fd, winsz, struct.pack("HHHH",height,width,0,0))
247 | 
248 |     def needs_updating(self, cur_time):
249 |         return (self.update_needed or self.output_time > self.update_time) \
250 |                 and cur_time-self.update_time > UPDATE_INTERVAL
251 | 
252 |     def update(self):
253 |         """ Updates terminal output display """
254 |         self.update_time = time.time()
255 |         self.update_needed = False
256 |         self.update_callback()
257 | 
258 |     def update_callback(self, response_id=""):
259 |         if not self.update_buf:
260 |             return
261 |         self.manager.client_callback(self.term_name, response_id, "stdout", self.update_buf)
262 |         self.update_buf = ""
263 | 
264 |     def clear(self):
265 |         self.update_buf = ""
266 |         self.update_needed = True
267 | 
268 |     def reconnect(self, response_id=""):
269 |         self.update_callback(response_id=response_id)
270 | 
271 |     def write(self, data):
272 |         """ Displays byte-encoded output data on terminal screen (every update interval) """
273 |         self.output_time = time.time()
274 |         self.update_needed = True
275 |         self.update_buf += data
276 | 
277 |     def read(self):
278 |         """ Returns any reply text in response to terminal query sequences """
279 |         b = self.reply_buf
280 |         self.reply_buf = ""
281 |         return b
282 | 
283 |     def pty_write(self, data):
284 |         """ Writes to stdin of process running within terminal """
285 |         assert isinstance(data, unicode), "Must write unicode data"
286 |         raw_data = data.encode(self.term_encoding)
287 |         nbytes = len(raw_data)
288 |         offset = 0
289 |         while offset < nbytes:
290 |             # Need to break data up into chunks; otherwise it hangs the pty
291 |             count = min(CHUNK_BYTES, nbytes-offset)
292 |             retry = 50
293 |             while count > 0:
294 |                 try:
295 |                     sent = os.write(self.fd, raw_data[offset:offset+count])
296 |                     if not sent:
297 |                         raise Exception("Failed to write to terminal")
298 |                     offset += sent
299 |                     count -= sent
300 |                 except OSError as excp:
301 |                     if excp.errno != errno.EAGAIN:
302 |                         raise excp
303 |                     retry -= 1
304 |                     if retry > 0:
305 |                         time.sleep(0.01)
306 |                     else:
307 |                         raise excp
308 | 
309 |     def pty_read(self, data):
310 |         """ Reads from stdout/stderr of process running within terminal """
311 |         assert isinstance(data, bytes), "Must read byte-encoded data"
312 | 
313 |         # Decode data (raw binary data transmitted via terminal must use base64 encoding)
314 |         self.write(data.decode(self.term_encoding))
315 | 
316 |         reply = self.read()   # Read any immediate reply to escape-sequence terminal queries
317 |         if reply:
318 |             # Send terminal response
319 |             assert isinstance(reply, unicode), "Must write unicode data"
320 |             os.write(self.fd, reply.encode(self.term_encoding))
321 | 
322 | 
323 | class TermManager(object):
324 |     def __init__(self, client_callback, shell_command=[], ssh_host="", server_url="",
325 |                  term_settings={}, log_file="", log_level=logging.ERROR):
326 |         """ Manages multiple terminals (create, communicate, destroy)
327 |         """
328 |         ##signal.signal(signal.SIGCHLD, signal.SIG_IGN)
329 |         self.client_callback = client_callback  # Signature client_callback(term_name, client_id, method, *args)
330 |         self.shell_command = shell_command
331 |         self.ssh_host = ssh_host
332 |         self.server_url = server_url
333 |         self.term_settings = term_settings
334 |         self.log_file = log_file
335 | 
336 |         self.term_options = term_settings.get("options", {})
337 | 
338 |         if log_file:
339 |             setup_logging(logging.WARNING, log_file, logging.INFO)
340 |             print("Logging to file", log_file, file=sys.stderr)
341 |     
342 |         self.terminals = {}
343 |         self.lock = threading.RLock()
344 |         self.thread = threading.Thread(target=self.loop)
345 |         self.alive = 1
346 |         self.check_kill_idle = False
347 |         self.name_count = 0
348 |         self.thread.start()
349 | 
350 |     def terminal(self, term_name=None, height=25, width=80, winheight=0, winwidth=0, parent="",
351 |                  access_code="", shell_command=[], ssh_host=""):
352 |         """Return (tty_name, cookie, alert_msg) for existing or newly created terminal"""
353 |         shell_command = shell_command or self.shell_command
354 |         ssh_host = ssh_host or self.ssh_host
355 |         with self.lock:
356 |             if term_name:
357 |                 term = self.terminals.get(term_name)
358 |                 if term:
359 |                     # Existing terminal; resize and return it
360 |                     if term.access_code and term.access_code != access_code:
361 |                         return (term_name, "", "Invalid terminal access code")
362 |                     term.rpc_set_size(height, width, winheight, winwidth)
363 |                     return (term_name, term.cookie, "")
364 | 
365 |             else:
366 |                 # New default terminal name
367 |                 while True:
368 |                     self.name_count += 1
369 |                     term_name = "tty%s" % self.name_count
370 |                     if term_name not in self.terminals:
371 |                         break
372 | 
373 |             # Create new terminal
374 |             max_terminals = self.term_settings.get("max_terminals",0)
375 |             if max_terminals and len(self.terminals) >= max_terminals:
376 |                 return ("", "", "Cannot create more than %d terminals" % max_terminals)
377 |             cookie = make_term_cookie()
378 |             logging.info("New terminal %s: %s", term_name, shell_command)
379 | 
380 |             term_dir = ""
381 |             if parent:
382 |                 parent_term = self.terminals.get(parent)
383 |                 if parent_term:
384 |                     term_dir = parent_term.current_dir or ""
385 | 
386 |             pid, fd = pty.fork()
387 |             if pid == 0:
388 |                 # Slave pty
389 |                 ##logging.info("Forked pid=0 %s: %s", term_name, shell_command)
390 |                 env = {}
391 |                 for var in os.environ.keys():
392 |                     if var not in NO_COPY_ENV:
393 |                         val = os.getenv(var)
394 |                         env[var] = val
395 |                         if var == "PATH" and Exec_path and Exec_path not in env[var]:
396 |                             # Prepend app bin directory to path
397 |                             env[var] = Exec_path + ":" + env[var]
398 |                 env["COLUMNS"] = str(width)
399 |                 env["LINES"] = str(height)
400 |                 env.update( dict(self.term_env(term_name, cookie, height, width, winheight, winwidth)) )
401 |                 self.start_shell(shell_command, env, term_dir=term_dir)
402 |             else:
403 |                 # Master pty
404 |                 logging.info("Forked pid=%d %s", pid, term_name)
405 |                 fcntl.fcntl(fd, fcntl.F_SETFL, fcntl.fcntl(fd,fcntl.F_GETFL)|os.O_NONBLOCK)
406 |                 self.terminals[term_name] = Terminal(term_name, fd, pid, self,
407 |                                                      height=height, width=width,
408 |                                                      winheight=winheight, winwidth=winwidth,
409 |                                                      cookie=cookie, access_code=access_code,
410 |                                                      log=bool(self.log_file))
411 |                 return term_name, cookie, ""
412 | 
413 |     def start_shell(self, shell_command, env, term_dir=""):
414 |         """ Start shell command for terminal """
415 |         if len(shell_command) == 1 and not os.path.isabs(shell_command[0]):
416 |             # Relative path shell command with no arguments
417 |             if shell_command[0] in ("bash", "csh", "ksh", "sh", "tcsh", "zsh"):
418 |                 # Standard shell
419 |                 cmd_args = shell_command[:]
420 |             elif shell_command[0] == "login":
421 |                 # Login access
422 |                 time.sleep(0.3)      # Needed for PTY output to appear
423 |                 if os.getuid() != 0:
424 |                     logging.error("Must be root to run login")
425 |                     os._exit(1)
426 |                 if os.path.exists("/bin/login"):
427 |                     cmd_args = ['/bin/login']
428 |                 elif os.path.exists("/usr/bin/login"):
429 |                     cmd_args = ['/usr/bin/login']
430 |                 else:
431 |                     logging.error("/bin/login or /usr/bin/login not found")
432 |                     os._exit(1)
433 |             elif shell_command[0] == "ssh":
434 |                 # SSH access
435 |                 time.sleep(0.3)      # Needed for PTY output to appear
436 |                 sys.stderr.write("SSH Authentication\n")
437 |                 hostname = ssh_host or "localhost"
438 |                 if hostname != "localhost":
439 |                     sys.stdout.write("Hostname: %s\n" % hostname)
440 |                 sys.stdout.write("Username: ")
441 |                 username = sys.stdin.readline().strip()
442 |                 if re.match('^[0-9A-Za-z-_. ]+$', username):
443 |                     cmd_args = ['ssh']
444 |                     cmd_args += ['-oPreferredAuthentications=keyboard-interactive,password']
445 |                     cmd_args += ['-oNoHostAuthenticationForLocalhost=yes']
446 |                     cmd_args += ['-oLogLevel=FATAL']
447 |                     cmd_args += ['-F/dev/null', '-l', username, ssh_host]
448 |                 else:
449 |                     logging.error("Invalid username %s", username)
450 |                     os._exit(1)
451 |             else:
452 |                 # Non-standard program; run via shell
453 |                 cmd_args = ['/bin/sh', '-c', shell_command[0]]
454 |         elif shell_command and os.path.isabs(shell_command[0]):
455 |             # Absolute path shell command
456 |             cmd_args = shell_command[:]
457 |         else:
458 |             logging.error("Invalid shell command: %s", shell_command)
459 |             os._exit(1)
460 | 
461 |         if term_dir:
462 |             try:
463 |                 os.chdir(term_dir)
464 |             except Exception:
465 |                 term_dir = ""
466 | 
467 |         if not term_dir:
468 |             # cd to HOME
469 |             os.chdir(os.path.expanduser("~"))
470 | 
471 |         ##logging.info("start_shell %s: %s", cmd_args, env)
472 | 
473 |         # Close all open fd (except stdin, stdout, stderr)
474 |         try:
475 |             fdl = [int(i) for i in os.listdir('/proc/self/fd')]
476 |         except OSError:
477 |             fdl = range(256)
478 |         for i in [i for i in fdl if i>2]:
479 |             try:
480 |                 os.close(i)
481 |             except OSError:
482 |                 pass
483 | 
484 |         # Exec shell
485 |         os.execvpe(cmd_args[0], cmd_args, env)
486 | 
487 |     def term_env(self, term_name, cookie, height, width, winheight, winwidth, export=False):
488 |         """ Returns environment variables for terminal """
489 |         env = []
490 |         env.append( ("TERM", self.term_settings.get("type",DEFAULT_TERM_TYPE)) )
491 |         env.append( (ENV_PREFIX+"COOKIE", str(cookie)) )
492 |         dimensions = "%dx%d" % (width, height)
493 |         if winwidth and winheight:
494 |             dimensions += ";%dx%d" % (winwidth, winheight)
495 |         env.append( (ENV_PREFIX+"DIMENSIONS", dimensions) )
496 | 
497 |         if self.server_url:
498 |             env.append( (ENV_PREFIX+"URL", self.server_url) )
499 | 
500 |         env.append( (ENV_PREFIX+"DIR", File_dir) )
501 | 
502 |         return env
503 | 
504 |     def get_terminal(self, term_name):
505 |         return self.terminals.get(term_name)
506 | 
507 |     def remote_term_call(self, term_name, method, *args, **kwargs):
508 |         terminal = self.get_terminal(term_name)
509 |         if not terminal:
510 |             raise Exception("Invalid terminal name "+term_name)
511 | 
512 |         bound_method = getattr(terminal, "rpc_"+method, None)
513 |         if not bound_method:
514 |             raise Exception("Invalid remote method "+method)
515 |         logging.info("Remote term call %s", method)
516 |         with self.lock:
517 |             return bound_method(*args, **kwargs)
518 | 
519 |     def term_names(self):
520 |         with self.lock:
521 |             return list(self.terminals.keys())
522 | 
523 |     def running(self):
524 |         with self.lock:
525 |             return self.alive
526 | 
527 |     def shutdown(self):
528 |         with self.lock:
529 |             if not self.alive:
530 |                 return
531 |             self.alive = 0
532 |             self.kill_all()
533 | 
534 |     def kill_term(self, term_name):
535 |         with self.lock:
536 |             term = self.terminals.get(term_name)
537 |             if term:
538 |                 # "Idle" terminal
539 |                 term.output_time = 0
540 |             self.check_kill_idle = True
541 | 
542 |     def kill_all(self):
543 |         with self.lock:
544 |             for term in self.terminals.values():
545 |                 # "Idle" terminal
546 |                 term.output_time = 0
547 |             self.check_kill_idle = True
548 | 
549 |     def kill_idle(self):
550 |         # Kill all "idle" terminals
551 |         with self.lock:
552 |             cur_time = time.time()
553 |             for term_name in self.term_names():
554 |                 term = self.terminals.get(term_name)
555 |                 if term:
556 |                     if (cur_time-term.output_time) > IDLE_TIMEOUT:
557 |                         logging.warning("kill_idle: %s", term_name)
558 |                         try:
559 |                             os.close(term.fd)
560 |                             os.kill(term.pid, signal.SIGTERM)
561 |                         except (IOError, OSError):
562 |                             pass
563 |                         try:
564 |                             del self.terminals[term_name]
565 |                         except Exception:
566 |                             pass
567 |                         self.client_callback(term_name, "", "disconnect", 1)
568 | 
569 |     def term_read(self, term_name):
570 |         with self.lock:
571 |             term = self.terminals.get(term_name)
572 |             if not term:
573 |                 return
574 |             try:
575 |                 data = os.read(term.fd, 65536)
576 |                 if not data:
577 |                     logging.error("pyxshell: EOF in reading from %s; closing it" % term_name)
578 |                     self.term_update(term_name)
579 |                     self.kill_term(term_name)
580 |                     return
581 |                 term.pty_read(data)
582 |             except (KeyError, IOError, OSError):
583 |                 logging.err("pyxshell: Error in reading from %s; closing it" % term_name)
584 |                 self.kill_term(term_name)
585 | 
586 |     def term_write(self, term_name, data):
587 |         ##logging.info("term_write: %s '%s'", term_name, data[:80])
588 |         with self.lock:
589 |             term = self.terminals.get(term_name)
590 |             if not term:
591 |                 return
592 |             try:
593 |                 term.pty_write(data)
594 |             except (IOError, OSError) as excp:
595 |                 logging.error("pyxshell: Error in writing to %s (%s %s); closing it", term_name, excp.__class__, excp)
596 |                 self.kill_term(term_name)
597 | 
598 |     def term_update(self, term_name):
599 |         with self.lock:
600 |             term = self.terminals.get(term_name)
601 |             if term:
602 |                 term.update()
603 | 
604 |     def reconnect(self, term_name, response_id=""):
605 |         with self.lock:
606 |             term = self.terminals.get(term_name)
607 |             if not term:
608 |                 return
609 |             term.reconnect(response_id=response_id)
610 | 
611 |     def loop(self):
612 |         """ Multi-terminal I/O loop"""
613 |         while self.running():
614 |             try:
615 |                 fd_dict = dict((term.fd, name) for name, term in self.terminals.items())
616 |                 if not fd_dict:
617 |                     time.sleep(0.02)
618 |                     continue
619 |                 inputs, outputs, errors = select.select(fd_dict.keys(), [], [], 0.02)
620 |                 for fd in inputs:
621 |                     try:
622 |                         self.term_read(fd_dict[fd])
623 |                     except Exception as excp:
624 |                         traceback.print_exc()
625 |                         term_name = fd_dict[fd]
626 |                         logging.warning("TermManager.loop: INTERNAL READ ERROR (%s) %s", term_name, excp)
627 |                         self.kill_term(term_name)
628 |                 cur_time = time.time()
629 |                 for term_name in fd_dict.values():
630 |                     term = self.terminals.get(term_name)
631 |                     if term:
632 |                         if term.needs_updating(cur_time):
633 |                             try:
634 |                                 self.term_update(term_name)
635 |                             except Exception as excp:
636 |                                 traceback.print_exc()
637 |                                 logging.warning("TermManager.loop: INTERNAL UPDATE ERROR (%s) %s", term_name, excp)
638 |                                 self.kill_term(term_name)
639 |                 if self.check_kill_idle:
640 |                     self.check_kill_idle = False
641 |                     self.kill_idle()
642 | 
643 |                 if len(inputs):
644 |                     time.sleep(0.002)
645 |             except Exception as excp:
646 |                 traceback.print_exc()
647 |                 logging.warning("TermManager.loop: ERROR %s", excp)
648 |                 break
649 |         self.kill_all()
650 | 
651 | 
652 | if __name__ == "__main__":
653 |     ## Code to test shell wrapper
654 | 
655 |     from optparse import OptionParser
656 |     usage = "usage: %prog [<shell_command>]"
657 |     parser = OptionParser(usage=usage)
658 |     parser.add_option("-l", "--logging",
659 |                   action="store_true", dest="logging", default=False,
660 |                   help="Enable logging")
661 | 
662 |     (options, args) = parser.parse_args()
663 | 
664 |     shell_cmd = args[:] if args else ["bash"]
665 | 
666 |     # Determine terminal width, height
667 |     height, width = struct.unpack("hh", fcntl.ioctl(pty.STDOUT_FILENO, termios.TIOCGWINSZ, "1234"))
668 |     if not width or not height:
669 |         try:
670 |             height, width = [int(os.getenv(var)) for var in ("LINES", "COLUMNS")]
671 |         except Exception:
672 |             height, width = 25, 80
673 | 
674 |     Prompt = "> "
675 |     Log_file = "pyxshell.log" if options.logging else ""
676 |     def client_callback(term_name, response_id, command, *args):
677 |         if command == "stdout":
678 |             output = args[0]
679 |             sys.stdout.write(output)
680 |             sys.stdout.flush()
681 | 
682 |     Term_manager = TermManager(client_callback, shell_cmd, log_file=Log_file, log_level=logging.INFO)
683 |     Term_name, term_cookie, alert_msg = Term_manager.terminal(height=height, width=width)
684 | 
685 |     if alert_msg:
686 |         print(alert_msg, file=sys.stderr)
687 |     print("**Type Control-D Control-D to exit**", file=sys.stderr)
688 | 
689 |     test_str = b'\xe2\x94\x80 \xe2\x94\x82 \xe2\x94\x8c \xe2\x94\x98 \xe2\x94\x90 \xe2\x94\x94 \xe2\x94\x9c \xe2\x94\xa4 \xe2\x94\xac \xe2\x94\xb4 \xe2\x94\xbc \xe2\x95\x90 \xe2\x95\x91 \xe2\x95\x94 \xe2\x95\x9d \xe2\x95\x97 \xe2\x95\x9a \xe2\x95\xa0 \xe2\x95\xa3 \xe2\x95\xa6 \xe2\x95\xa9 \xe2\x95\xac'.decode("utf-8")
690 | 
691 |     Term_attr = termios.tcgetattr(pty.STDIN_FILENO)
692 |     try:
693 |         tty.setraw(pty.STDIN_FILENO)
694 |         expectEOF = False
695 |         Term_manager.term_write(Term_name, "echo '%s'\n" % test_str)
696 |         while True:
697 |             ##data = raw_input(Prompt)
698 |             ##Term_manager.write(data+"\n")
699 |             data = os.read(pty.STDIN_FILENO, 1024)
700 |             if byte_code(data[0]) == 4:
701 |                 if expectEOF: raise EOFError
702 |                 expectEOF = True
703 |             else:
704 |                 expectEOF = False
705 |             if not data:
706 |                 raise EOFError
707 |             str_data = data.decode("utf-8") if isinstance(data, bytes) else data
708 |             Term_manager.term_write(Term_name, str_data)
709 |     except EOFError:
710 |         Term_manager.shutdown()
711 |     finally:
712 |         # Restore terminal attributes
713 |         termios.tcsetattr(pty.STDIN_FILENO, termios.TCSANOW, Term_attr)
714 | 


--------------------------------------------------------------------------------
/pyxterm/pyxterm.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | 
  3 | """pyxterm.py: Python websocket terminal server for term.js, using pyxshell.py as the backend
  4 | 
  5 | Requires term.js, pyxterm.js pyxshell.py
  6 | 
  7 | To test, run:
  8 | 
  9 |   ./pyxterm.py --terminal
 10 | 
 11 | to start the server an open a terminal. For help, type
 12 | 
 13 |   ./pyxterm.py -h
 14 | 
 15 | Default URL to a create a new terminal is http://localhost:8700/new
 16 | 
 17 | To create a named terminal, open http://localhost:8700/terminal_name
 18 | 
 19 | BSD License
 20 | 
 21 | """
 22 | 
 23 | #
 24 | #  BSD License
 25 | #
 26 | #  Copyright (c) 2014, Ramalingam Saravanan <sarava@sarava.net>
 27 | #  All rights reserved.
 28 | #  
 29 | #  Redistribution and use in source and binary forms, with or without
 30 | #  modification, are permitted provided that the following conditions are met:
 31 | #  
 32 | #  1. Redistributions of source code must retain the above copyright notice, this
 33 | #     list of conditions and the following disclaimer. 
 34 | #  2. Redistributions in binary form must reproduce the above copyright notice,
 35 | #     this list of conditions and the following disclaimer in the documentation
 36 | #     and/or other materials provided with the distribution. 
 37 | #  
 38 | #  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 39 | #  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 40 | #  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 41 | #  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 42 | #  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 43 | #  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 44 | #  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 45 | #  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 46 | #  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 47 | #  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 48 | 
 49 | from __future__ import absolute_import, print_function, with_statement
 50 | 
 51 | 
 52 | # Python3-friendly imports
 53 | try:
 54 |     from urllib.parse import urlparse, parse_qs, urlencode
 55 | except ImportError:
 56 |     from urlparse import urlparse, parse_qs
 57 |     from urllib import urlencode
 58 | 
 59 | import base64
 60 | import cgi
 61 | import collections
 62 | import logging
 63 | import os
 64 | import ssl
 65 | import sys
 66 | import threading
 67 | import time
 68 | import uuid
 69 | 
 70 | try:
 71 |     import ujson as json
 72 | except ImportError:
 73 |     import json
 74 | 
 75 | import pyxshell
 76 | 
 77 | import tornado.auth
 78 | import tornado.httpserver
 79 | import tornado.ioloop
 80 | import tornado.options
 81 | import tornado.web
 82 | import tornado.websocket
 83 | 
 84 | try:
 85 |     from collections import OrderedDict
 86 | except ImportError:
 87 |     from ordereddict import OrderedDict
 88 | 
 89 | File_dir = os.path.dirname(__file__)
 90 | if File_dir == ".":
 91 |     File_dir = os.getcwd()    # Need this for daemonizing to work?
 92 | Doc_rootdir = os.path.join(File_dir, "_static")
 93 | 
 94 | BANNER_HTML = '<center><h2>pyxterm</h2></center>'
 95 | 
 96 | STATIC_PATH = "_static"
 97 | STATIC_PREFIX = "/"+STATIC_PATH+"/"
 98 | 
 99 | MAX_COOKIE_STATES = 300
100 | COOKIE_NAME = "PYXTERM_AUTH"
101 | COOKIE_TIMEOUT = 86400
102 | 
103 | AUTH_DIGITS = 12    # Form authentication code hex-digits
104 |                     # Note: Less than half of the 32 hex-digit state id should be used for form authentication
105 | 
106 | AUTH_TYPES = ("none", "ssh", "login", "google")
107 | 
108 | def cgi_escape(s):
109 |     return cgi.escape(s) if s else ""
110 | 
111 | def get_query_auth(state_id):
112 |     return state_id[:AUTH_DIGITS]
113 | 
114 | def get_first_arg(query_data, argname, default=""):
115 |     return query_data.get(argname, [default])[0]
116 | 
117 | def open_browser(url, browser=""):
118 |     if sys.platform.startswith("linux"):
119 |         command_args = ["xdg-open"]
120 |     else:
121 |         command_args = ["open"]
122 |         if browser:
123 |             command_args += ["-a", browser]
124 | 
125 |     command_args.append(url)
126 | 
127 |     return pyxshell.command_output(command_args, timeout=5)
128 | 
129 | class ErrorMessage(Exception):
130 |     def __init__(self, value):
131 |         self.value = value
132 | 
133 |     def __str__(self):
134 |         return str(self.value)
135 | 
136 | server_cert_gen_cmds = [
137 |     'openssl req -x509 -nodes -days %(expdays)d -newkey rsa:%(keysize)d -batch -subj /O=pyxterm/CN=%(hostname)s -keyout %(keyfile)s -out %(certfile)s',
138 |     'openssl x509 -noout -fingerprint -in %(certfile)s',
139 |     ]
140 | server_cert_gen_cmds_long = [
141 |     'openssl genrsa -out %(hostname)s.key %(keysize)d',
142 |     'openssl req -new -key %(hostname)s.key -out %(hostname)s.csr -batch -subj "/O=pyxterm/CN=%(hostname)s"',
143 |     'openssl x509 -req -days %(expdays)d -in %(hostname)s.csr -signkey %(hostname)s.key -out %(hostname)s.crt',
144 |     'openssl x509 -noout -fingerprint -in %(hostname)s.crt',
145 |     ]
146 | 
147 | client_cert_gen_cmds = [
148 |     'openssl genrsa -out %(clientprefix)s.key %(keysize)d',
149 |     'openssl req -new -key %(clientprefix)s.key -out %(clientprefix)s.csr -batch -subj "/O=pyxterm/CN=%(clientname)s"',
150 |     'openssl x509 -req -days %(expdays)d -in %(clientprefix)s.csr -CA %(certfile)s -CAkey %(keyfile)s -set_serial 01 -out %(clientprefix)s.crt',
151 |     "openssl pkcs12 -export -in %(clientprefix)s.crt -inkey %(clientprefix)s.key -out %(clientprefix)s.p12 -passout pass:%(clientpassword)s"
152 |     ]
153 | 
154 | def ssl_cert_gen(certfile, keyfile="", hostname="localhost", cwd=None, new=False, clientname=""):
155 |     """Return fingerprint of self-signed server certficate, creating a new one, if need be"""
156 |     params = {"certfile": certfile, "keyfile": keyfile or certfile,
157 |               "hostname": hostname, "keysize": 1024, "expdays": 1024,
158 |               "clientname": clientname, "clientprefix":"%s-%s" % (hostname, clientname),
159 |               "clientpassword": "password",}
160 |     cmd_list = server_cert_gen_cmds if new else server_cert_gen_cmds[-1:]
161 |     for cmd in cmd_list:
162 |         cmd_args = pyxshell.shlex_split_str(cmd % params)
163 |         std_out, std_err = pyxshell.command_output(cmd_args, cwd=cwd, timeout=15)
164 |         if std_err:
165 |             logging.warning("pyxterm: SSL keygen %s %s", std_out, std_err)
166 |     fingerprint = std_out
167 |     if new and clientname:
168 |         for cmd in client_cert_gen_cmds:
169 |             cmd_args = pyxshell.shlex_split_str(cmd % params)
170 |             std_out, std_err = pyxshell.command_output(cmd_args, cwd=cwd, timeout=15)
171 |             if std_err:
172 |                 logging.warning("pyxterm: SSL client keygen %s %s", std_out, std_err)
173 |     return fingerprint
174 | 
175 | 
176 | class TermSocket(tornado.websocket.WebSocketHandler):
177 |     _all_term_sockets = {}
178 |     _all_term_paths = collections.defaultdict(set)
179 |     _term_counter = [0]
180 |     _term_states = OrderedDict()
181 |     _term_connect_cookies = OrderedDict()
182 | 
183 |     @classmethod
184 |     def get_connect_cookie(cls):
185 |         while len(cls._term_connect_cookies) > 100:
186 |             cls._term_connect_cookies.popitem(last=False)
187 |         new_cookie = uuid.uuid4().hex[:12]
188 |         cls._term_connect_cookies[new_cookie] = {}  # connect_data (from form submission)
189 |         return new_cookie
190 | 
191 |     @classmethod
192 |     def check_connect_cookie(cls, cookie):
193 |         return cls._term_connect_cookies.pop(cookie, None)            
194 | 
195 |     @classmethod
196 |     def update_connect_cookie(cls, cookie, connect_data):
197 |         if cookie not in cls._term_connect_cookies:
198 |             return False
199 |         cls._term_connect_cookies[cookie] = connect_data
200 |         return True
201 | 
202 |     @classmethod
203 |     def get_state(cls, state_id):
204 |         if state_id not in cls._term_states:
205 |             return None
206 |         state_value = cls._term_states[state_id]
207 |         return state_value
208 | 
209 |     @classmethod
210 |     def get_request_state(cls, request):
211 |         if COOKIE_NAME not in request.cookies:
212 |             return None
213 |         cookie_value = request.cookies[COOKIE_NAME].value
214 |         state_value = cls.get_state(cookie_value)
215 |         if state_value:
216 |             return state_value
217 |         # Note: webcast auth will always be dropped
218 |         cls.drop_state(cookie_value)
219 |         return None
220 | 
221 |     @classmethod
222 |     def drop_state(cls, state_id):
223 |         cls._term_states.pop(state_id, None)
224 | 
225 |     @classmethod
226 |     def add_state(cls, user="", email=""):
227 |         state_id = uuid.uuid4().hex
228 |         authstate = {"state_id": state_id,
229 |                      "user": user,
230 |                      "email": email,
231 |                      "time": time.time()}
232 |         if len(cls._term_states) >= MAX_COOKIE_STATES:
233 |             cls._term_states.popitem(last=False)
234 |         cls._term_states[state_id] = authstate
235 |         return authstate
236 | 
237 |     def __init__(self, *args, **kwargs):
238 |         self.term_request = args[1]
239 |         self.check_client_cert()
240 |         logging.info("TermSocket.__init__: %s", self.term_request.uri)
241 | 
242 |         self.term_query = self.term_request.query
243 |         self.term_reqpath = "/".join(self.term_request.path.split("/")[2:])  # Strip out /_websocket from path
244 |         if self.term_reqpath.endswith("/"):
245 |             self.term_reqpath = self.term_reqpath[:-1]
246 | 
247 |         super(TermSocket, self).__init__(*args, **kwargs)
248 | 
249 |         self.term_authstate = None
250 |         self.term_path = ""
251 |         self.term_cookie = ""
252 |         self.term_client_id = None
253 | 
254 |     def check_client_cert(self):
255 |         try:
256 |             self.client_cert = self.term_request.get_ssl_certificate()
257 |         except Exception:
258 |             self.client_cert = ""
259 | 
260 |         self.common_name = ""
261 |         if self.client_cert:
262 |             try:
263 |                 subject = dict([x[0] for x in self.client_cert["subject"]])
264 |                 self.common_name = subject.get("commonName")
265 |             except Exception as excp:
266 |                 logging.warning("pyxterm: client_cert ERROR %s", excp)
267 |         if self.client_cert:
268 |             logging.warning("pyxterm: client_cert=%s, name=%s", self.client_cert, self.common_name)
269 | 
270 |     def origin_check(self):
271 |         if "Origin" in self.term_request.headers:
272 |             origin = self.term_request.headers.get("Origin")
273 |         else:
274 |             origin = self.term_request.headers.get("Sec-Websocket-Origin", None)
275 | 
276 |         if not origin:
277 |             return False
278 | 
279 |         host = self.term_request.headers.get("Host").lower()
280 |         ws_host = urlparse(origin).netloc.lower()
281 |         if host == ws_host:
282 |             return True
283 |         else:
284 |             logging.error("pyxterm.origin_check: ERROR %s != %s", host, ws_host)
285 |             return False
286 | 
287 |     def term_authenticate(self):
288 |         authstate = self.get_request_state(self.request)
289 |         if authstate:
290 |             return authstate
291 |         if Term_settings["auth_type"] == "google":
292 |             # State must be added by Google auth
293 |             return None
294 |         return self.add_state()
295 | 
296 |     def open(self):
297 |         if not self.origin_check():
298 |             raise tornado.web.HTTPError(404, "Websocket origin mismatch")
299 | 
300 |         logging.info("TermSocket.open:")
301 |         query_data = {}
302 |         if self.term_query:
303 |             try:
304 |                 query_data = parse_qs(self.term_query)
305 |             except Exception:
306 |                 pass
307 | 
308 |         connect_auth = get_first_arg(query_data, "cauth")
309 |         connect_data = self.check_connect_cookie(connect_auth)
310 |         if connect_data is None:
311 |             # Invalid connect cookie
312 |             connect_auth = None
313 | 
314 |         authstate = self.term_authenticate()
315 |         if not authstate:
316 |             if Term_settings["auth_type"] == "google":
317 |                 gauth_url = "/_gauth/%s?cauth=%s" % (self.term_reqpath, self.get_connect_cookie())
318 |                 self.term_remote_call("document", BANNER_HTML+'<p><h3><a href="%s">Click here</a> to initiate Google authentication </h3>' % gauth_url)
319 |             else:
320 |                 logging.error("TermSocket.open: ERROR authentication failed")
321 |             self.close()
322 |             return
323 | 
324 |         self.term_authstate = authstate
325 | 
326 |         query_auth = get_first_arg(query_data, "qauth")
327 |         if not connect_auth and (not query_auth or query_auth != get_query_auth(self.term_authstate["state_id"])):
328 |             # Invalid query auth; clear any form data
329 |             query_data = {}
330 | 
331 |         if not query_data:
332 |             # Confirm request, if no form data
333 |             if self.term_reqpath:
334 |                 ##logging.info("TermSocket.open: Confirm request %s", self.term_reqpath)
335 |                 confirm_url = "/%s/?cauth=%s" % (self.term_reqpath, self.get_connect_cookie())
336 |                 self.term_remote_call("document", BANNER_HTML+'<p><h3>Click to open terminal <a href="%s">%s</a></h3>' % (confirm_url, "/"+self.term_reqpath))
337 |                 self.close()
338 |                 return
339 |             else:
340 |                 # Forget path
341 |                 path_comps = []
342 |         else:
343 |             path_comps = self.term_reqpath.split("/")
344 | 
345 |         path_name = path_comps[0] if path_comps else "new"
346 | 
347 |         if pyxshell.TERM_NAME_RE.match(path_name):
348 |             term_name = None if path_name == "new" else path_name
349 |             # Require access for ssh/login auth types (because there is no user authentication)
350 |             access_code = "" if Term_settings["auth_type"] in ("none", "google") else self.term_authstate["state_id"]
351 |             self.term_path, self.term_cookie, alert_msg = Term_manager.terminal(term_name=term_name, access_code=access_code)
352 |         else:
353 |             alert_msg = "Invalid terminal name '%s'; follow identifier rules" % path_name
354 | 
355 |         if alert_msg:
356 |             logging.error(alert_msg)
357 |             self.term_remote_call("alert", alert_msg)
358 |             self.close()
359 |             return
360 | 
361 |         if path_name == "new" or not query_auth:
362 |             redirect_url = "/%s/?qauth=%s" % (self.term_path, get_query_auth(self.term_authstate["state_id"]))
363 |             self.term_remote_call("redirect", redirect_url, self.term_authstate["state_id"])
364 |             self.close()
365 |             return
366 | 
367 |         self.add_termsocket()
368 | 
369 |         self.term_remote_call("setup", {"state_id": self.term_authstate["state_id"],
370 |                                         "client_id": self.term_client_id,
371 |                                         "term_path": self.term_path})
372 |         logging.info("TermSocket.open: Opened %s", self.term_path)
373 | 
374 |     @classmethod
375 |     def get_path_termsockets(cls, path):
376 |         return cls._all_term_paths.get(path, set())
377 | 
378 |     @classmethod
379 |     def get_termsocket(cls, client_id):
380 |         return cls._all_term_sockets.get(client_id)            
381 | 
382 |     def add_termsocket(self):
383 |         self._term_counter[0] += 1
384 |         self.term_client_id = str(self._term_counter[0])
385 | 
386 |         self._all_term_sockets[self.term_client_id] = self     
387 |         self._all_term_paths[self.term_path].add(self.term_client_id)
388 |         return self.term_client_id
389 | 
390 |     def on_close(self):
391 |         logging.info("TermSocket.on_close: Closing %s", self.term_path)
392 |         self._all_term_sockets.pop(self.term_client_id, None)
393 |         if self.term_path in self._all_term_paths:
394 |             self._all_term_paths[self.term_path].discard(self.term_client_id)
395 | 
396 |     @classmethod
397 |     def term_remote_callback(cls, term_path, client_id, method, *args):
398 |         client_ids = [client_id] if client_id else cls.get_path_termsockets(term_path)
399 |         try:
400 |             json_msg = json.dumps([method, args])
401 |             ##logging.info("term_remote_callback: %s, %s, %s", args, json.loads(json.dumps(args[0])) if args else "NONE", json_msg)
402 |             for client_id in client_ids:
403 |                 termsocket = cls.get_termsocket(client_id)
404 |                 if termsocket:
405 |                     termsocket.term_write(json_msg)
406 |         except Exception as excp:
407 |             logging.error("term_remote_callback: ERROR %s", excp)
408 | 
409 |     def term_remote_call(self, method, *args, **kwargs):
410 |         """
411 |         kwargs: content=None, content_type="", content_encoding=""
412 |         """
413 |         logging.error("term_remote_call: %s", method)
414 |         try:
415 |             if not kwargs:
416 |                 # Text message
417 |                 json_msg = json.dumps([method, args])
418 |                 self.term_write(json_msg)
419 |             else:
420 |                 # Binary message with UTF-16 JSON prefix
421 |                 content = kwargs.get("content")
422 |                 assert isinstance(content, bytes), "Content must be of bytes type"
423 |                 
424 |                 json_prefix = json.dumps([method, args, {"content_type": kwargs.get("content_type",""),
425 |                                                              "content_encoding": kwargs.get("content_encoding",""),
426 |                                                              "content_length": len(content)} ]) + "\n\n"
427 |                 content_prefix = json_prefix.encode("utf-16")
428 |                 self.term_write(content_prefix+content, binary=True)
429 |         except Exception as excp:
430 |             logging.error("term_remote_call: ERROR %s", excp)
431 | 
432 |     def term_write(self, data, binary=False):
433 |         try:
434 |             self.write_message(data, binary=binary)
435 |         except Exception as excp:
436 |             logging.error("term_write: ERROR %s", excp)
437 |             closed_excp = getattr(tornado.websocket, "WebSocketClosedError", None)
438 |             if not closed_excp or not isinstance(excp, closed_excp):
439 |                 import traceback
440 |                 logging.info("Error in websocket: %s\n%s", excp, traceback.format_exc())
441 |             try:
442 |                 # Close websocket on write error
443 |                 self.close()
444 |             except Exception:
445 |                 pass
446 | 
447 |     def on_message(self, message):
448 |         ##logging.info("TermSocket.on_message: %s - (%s) %s", self.term_path, type(message), len(message) if isinstance(message, bytes) else message[:250])
449 |         if not self.term_path:
450 |             return
451 | 
452 |         if isinstance(message, bytes):
453 |             # Binary message with UTF-16 JSON prefix
454 |             enc_delim = "\n\n".encode("utf-16")
455 |             offset = message.find(enc_delim)
456 |             if offset < 0:
457 |                 raise Exception("Delimiter not found in binary message")
458 |             command = json.loads(message[:offset]).decode("utf-16")
459 |             content = message[offset+len(enc_delim):]
460 |         else:
461 |             command = json.loads(message if isinstance(message,str) else message.encode("UTF-8", "replace"))
462 |             content = None
463 |             
464 |         kill_term = False
465 |         try:
466 |             send_cmd = True
467 |             if command[0] == "kill_term":
468 |                 kill_term = True
469 |             elif command[0] == "errmsg":
470 |                 logging.error("Terminal %s: %s", self.term_path, command[1])
471 |                 send_cmd = False
472 | 
473 |             if send_cmd:
474 |                 matchpaths = [self.term_path]
475 | 
476 |                 for matchpath in matchpaths:
477 |                     if command[0] == "stdin":
478 |                         text = command[1].replace("\r\n","\n").replace("\r","\n")
479 |                         Term_manager.term_write(matchpath, text)
480 |                     else:
481 |                         Term_manager.remote_term_call(matchpath, *command)
482 |                     if kill_term:
483 |                         kill_remote(matchpath, from_user)
484 | 
485 |         except Exception as excp:
486 |             logging.error("TermSocket.on_message: ERROR %s", excp)
487 |             self.term_remote_call("errmsg", str(excp))
488 |             return
489 | 
490 | def kill_remote(term_path, user):
491 |     for client_id in TermSocket.get_path_termsockets(term_path):
492 |         tsocket = TermSocket.get_termsocket(client_id)
493 |         if tsocket:
494 |             tsocket.term_remote_call("document", BANNER_HTML+'<p>CLOSED TERMINAL<p><a href="/">Home</a>')
495 |             tsocket.on_close()
496 |             tsocket.close()
497 |     try:
498 |         Term_manager.kill_term(term_path)
499 |     except Exception:
500 |         pass
501 | 
502 | class GoogleOAuth2LoginHandler(tornado.web.RequestHandler, tornado.auth.GoogleOAuth2Mixin):
503 |     @tornado.gen.coroutine
504 |     def get(self):
505 |         if self._OAUTH_SETTINGS_KEY not in self.settings or not self.settings[self._OAUTH_SETTINGS_KEY]["key"]:
506 |             self.setup_msg("Google Authentication has not yet been set up for this server.")
507 |             return
508 |         ##logging.error("GoogleOAuth2LoginHandler: req=%s", self.request.uri)
509 |         auth_uri = Term_settings["server_url"]+"/_gauth"
510 |         if not self.get_argument('code', False):
511 |             term_cauth = self.get_argument("term_cauth", "")
512 |             term_path = "/".join(self.request.path.split("/")[2:]) # Strip out /_gauth from path
513 |             if term_path == "_info":
514 |                 self.setup_msg("Google Authentication Setup Instructions")
515 |                 return
516 | 
517 |             state_param = ",".join([term_path, term_cauth])
518 |             yield self.authorize_redirect(
519 |                 redirect_uri=auth_uri,
520 |                 client_id=self.settings['google_oauth']['key'],
521 |                 scope=['profile', 'email'],
522 |                 response_type='code',
523 |                 extra_params={'approval_prompt': 'auto', 'state': state_param})
524 |         else:
525 |             try:
526 |                 state_value = self.get_argument('state', "")
527 |                 user = yield self.get_authenticated_user(
528 |                     redirect_uri=auth_uri,
529 |                     code=self.get_argument('code'))
530 |                 
531 |                 comps = user['id_token'].split('.')
532 |                 if len(comps) != 3:
533 |                     raise ErrorMessage('Wrong number of comps in Google id token: %s' % (user,)) 
534 | 
535 |                 b64string = comps[1].encode('ascii') 
536 |                 padded = b64string + '=' * (4 - len(b64string) % 4) 
537 |                 user_info = json.loads(base64.urlsafe_b64decode(padded))
538 | 
539 |                 vals = state_value.split(",")
540 |                 if len(vals) != 2: 
541 |                     raise ErrorMessage('Invalid state values: %s' % state_value)
542 |                 term_path, term_cauth = vals
543 | 
544 |                 term_email = user_info.get("email", "").lower()
545 |                 if not term_email or not user_info.get("email_verified", False):
546 |                     raise ErrorMessage("GoogleOAuth2LoginHandler: No valid email in user info")
547 |                 if term_path == "_test":
548 |                     self.write(BANNER_HTML+'<p>Google authentication test succeeded for '+term_email)
549 |                     self.finish()
550 |                     return
551 | 
552 |                 if Term_settings["auth_emails"] and term_email not in Term_settings["auth_emails"]:
553 |                     self.write(BANNER_HTML+'<p>Account <em>%s</em> not authorized for access.<p><a href="https://accounts.google.com/AccountChooser?hl=en">Click here</a> to sign in with a different Google account' % term_email)
554 |                     self.finish()
555 |                     return
556 | 
557 |                 email_name, email_domain = term_email.split("@")
558 |                 term_user = email_name.replace(".","")
559 | 
560 |                 authstate = None
561 |                 state_id = self.get_cookie(COOKIE_NAME)
562 |                 if state_id:
563 |                     authstate = TermSocket.get_state(state_id)
564 |                     if authstate and (authstate.get("email","") != term_email or authstate.get("user","") != term_user):
565 |                         TermSocket.drop_state(state_id)
566 |                         authstate = None
567 |                 if not authstate:
568 |                     authstate = TermSocket.add_state(user=term_user, email=term_email)
569 |                     self.set_cookie(COOKIE_NAME, authstate["state_id"])
570 | 
571 |                 query = {}
572 |                 if term_cauth:
573 |                     query["cauth"] = term_cauth
574 |                 url = "/"+term_path
575 |                 if query:
576 |                     url += "?"+urlencode(query)
577 |                 logging.info("GoogleOAuth2LoginHandler: email=%s, url=%s, %s", term_email, url, user_info)
578 |                 self.redirect(url)
579 |             except Exception as excp:
580 |                 logging.error("Error in Google Authentication: "+str(excp))
581 |                 self.write(BANNER_HTML+'<p>Error in Google Authentication: '+(str(excp) if isinstance(excp, ErrorMessage) else ""))
582 |                 self.finish()
583 | 
584 |     def setup_msg(self, header):
585 |         msg = """<pre><em>%s</em>
586 | <p>
587 | If you are the administrator, please create the file
588 | <b>~/.pyxterm.json</b> for the user account running <b>pyxterm</b>.
589 | The file should contain the following Google OAuth info:<br>
590 |     <b>{"google_oauth": {"key": "...", "secret": "..."},
591 |         "auth_emails": ["user1@gmail.com", "user2@gmail.com"] }}</b>
592 | 
593 | Ensure that your web application has the following URI settings:
594 | 
595 |  <em>Authorized Javascript origins:</em> <b>%s</b>
596 | 
597 |  <em>Authorized Redirect URI:</em> <b>%s/_gauth</b>
598 | 
599 | If you have not set up the pyxterm web app for Google authentication, here is how to do it:
600 |     * Go to the Google Dev Console at <a href="https://console.developers.google.com" target="_blank">https://console.developers.google.com</a>
601 |     * Select a project, or create a new one.
602 |     * In the sidebar on the left, select <em>APIs & Auth</em>.
603 |     * In the sidebar on the left, select <em>Consent Screen</em> to customize the Product name etc.
604 |     * In the sidebar on the left, select <em>Credentials</em>.
605 |     * In the OAuth section of the page, select <em>Create New Client ID</em>.
606 |     * Edit settings to set the Authorized URIs to the values shown above.
607 |     * Copy the web application "Client ID key" and "Client secret" to the settings file
608 |     * Restart the server
609 | </pre>
610 | """
611 |         self.write(msg % (header, Term_settings["server_url"], Term_settings["server_url"]))
612 |         self.finish()
613 |         return
614 | 
615 | def run_server(options, args):
616 |     global IO_loop, Http_server, Term_settings, Term_manager
617 |     import signal
618 | 
619 |     http_port = options.port
620 |     http_host = options.host
621 |     external_host = options.external_host or http_host
622 |     external_port = options.external_port or http_port
623 |     if options.https:
624 |         server_url = "https://"+external_host+("" if external_port == 443 else ":%d" % external_port)
625 |     else:
626 |         server_url = "http://"+external_host+("" if external_port == 80 else ":%d" % external_port)
627 |     new_url = server_url + "/new"
628 | 
629 |     if args:
630 |         if options.auth_type in ("login", "ssh"):
631 |             sys.exit("--auth_type=login/ssh cannot be combined with specified shell command")
632 |         shell_command = args[:]
633 |     elif options.auth_type == "login":
634 |         if os.geteuid():
635 |             sys.exit("Error: Must run server as root for --auth_type=login")
636 |         if not options.https and external_host != "localhost":
637 |             sys.exit("Error: At this time --auth_type=login is permitted only with https or localhost (for security reasons)")
638 |         shell_command = ["login"]
639 |     elif options.auth_type == "ssh":
640 |         if not pyxshell.match_program_name("sshd"):
641 |             sys.exit("Error: sshd must be running for --auth_type=ssh")
642 |         shell_command = ["ssh"]
643 |     else:
644 |         shell_command = ["bash"]
645 | 
646 |     tem_str = options.term_options.strip().replace(" ","")
647 |     term_options = set(tem_str.split(",") if tem_str else [])
648 |     Term_settings = {"type": options.term_type, "max_terminals": options.max_terminals,
649 |                      "https": options.https, "logging": options.logging,
650 |                      "options": term_options, "server_url": server_url, "auth_type": options.auth_type}
651 | 
652 |     pyx_settings_file = os.path.join(os.path.expanduser("~"), ".pyxterm.json")
653 |     pyx_settings = {}
654 |     if os.path.isfile(pyx_settings_file):
655 |         try:
656 |             with open(pyx_settings_file) as f:
657 |                 pyx_settings = json.loads(f.read().strip())
658 |                 print("***** Read settings from", pyx_settings_file, file=sys.stderr)
659 |         except Exception as excp:
660 |             sys.exit("Error in reading settings file %s: %s" % (pyx_settings_file, excp))
661 | 
662 |     app_settings = {"log_function": lambda x:None}
663 | 
664 |     if options.auth_type == "google":
665 |         if "google_oauth" not in pyx_settings:
666 |             sys.exit("'google_oauth' client ID and secret should be provided in settings file %s" % pyx_settings_file)
667 |         app_settings["google_oauth"] = pyx_settings["google_oauth"]
668 | 
669 |         if "auth_emails" not in pyx_settings:
670 |             sys.exit("'auth_emails' list should be provided in settings file %s" % pyx_settings_file)
671 |         auth_emails = [x.strip().lower() for x in pyx_settings["auth_emails"]]
672 |         Term_settings["auth_emails"] = set(auth_emails)
673 |         print("Authorized email addresses: %s" % (",".join(auth_emails) if auth_emails else "ALL"))
674 | 
675 |     Term_manager = pyxshell.TermManager(TermSocket.term_remote_callback, shell_command=shell_command, server_url="", term_settings=Term_settings)
676 | 
677 |     handlers = [(r"/_gauth.*", GoogleOAuth2LoginHandler),   # Does not work with trailing slash!
678 |                 (r"/_websocket/.*", TermSocket),
679 |                 (STATIC_PREFIX+r"(.*)", tornado.web.StaticFileHandler, {"path": Doc_rootdir}),
680 |                 (r"/().*", tornado.web.StaticFileHandler, {"path": Doc_rootdir, "default_filename": "index.html"}),
681 |                 ]
682 | 
683 |     application = tornado.web.Application(handlers, **app_settings)
684 | 
685 |     ##logging.warning("DocRoot: "+Doc_rootdir);
686 | 
687 |     IO_loop = tornado.ioloop.IOLoop.instance()
688 | 
689 |     ssl_options = None
690 |     if options.https or options.client_cert:
691 |         if options.client_cert:
692 |             certfile = options.client_cert
693 |             cert_dir = os.path.dirname(certfile) or os.getcwd()
694 |             if certfile.endswith(".crt"):
695 |                 keyfile = certfile[:-4] + ".key"
696 |             else:
697 |                 keyfile = ""
698 |         else:
699 |             cert_dir = "."
700 |             server_name = "localhost"
701 |             certfile = os.path.join(cert_dir, server_name+".pem")
702 |             keyfile = ""
703 | 
704 |         new = not os.path.exists(certfile) and (not keyfile or not os.path.exists(keyfile))
705 |         print("Generating" if new else "Using", "SSL cert", certfile, file=sys.stderr)
706 |         fingerprint = ssl_cert_gen(certfile, keyfile, server_name, cwd=cert_dir, new=new, clientname="term-local" if options.client_cert else "")
707 |         if not fingerprint:
708 |             print("pyxterm: Failed to generate server SSL certificate", file=sys.stderr)
709 |             sys.exit(1)
710 |         print(fingerprint, file=sys.stderr)
711 | 
712 |         ssl_options = {"certfile": certfile}
713 |         if keyfile:
714 |             ssl_options["keyfile"] = keyfile
715 | 
716 |         if options.client_cert:
717 |             if options.client_cert == ".":
718 |                 ssl_options["ca_certs"] = certfile
719 |             elif not os.path.exists(options.client_cert):
720 |                 print("Client cert file %s not found" % options.client_cert, file=sys.stderr)
721 |                 sys.exit(1)
722 |             else:
723 |                 ssl_options["ca_certs"] = options.client_cert
724 |             ssl_options["cert_reqs"] = ssl.CERT_REQUIRED
725 | 
726 |     Http_server = tornado.httpserver.HTTPServer(application, ssl_options=ssl_options)
727 |     Http_server.listen(http_port, address=http_host)
728 |     if options.logging:
729 |         Log_filename = "pyxterm.log"
730 |         pyxshell.setup_logging(logging.INFO, Log_filename, logging.INFO)
731 |         logging.error("**************************Logging to %s", Log_filename)
732 |     else:
733 |         pyxshell.setup_logging(logging.WARNING)
734 |         logging.error("**************************Logging to console")
735 | 
736 |     if options.terminal:
737 |         try:
738 |             open_browser(new_url)
739 |         except Exception as excp:
740 |             print("Error in creating terminal; please open URL %s in browser (%s)" % (new_url, excp), file=sys.stderr)
741 | 
742 |     def stop_server():
743 |         global Http_server
744 |         print("\nStopping server", file=sys.stderr)
745 |         if Http_server:
746 |             Http_server.stop()
747 |             Http_server = None
748 |         def stop_server_aux():
749 |             IO_loop.stop()
750 | 
751 |         # Need to stop IO_loop only after all other scheduled shutdowns have completed
752 |         IO_loop.add_callback(stop_server_aux)
753 | 
754 |     def sigterm(signal, frame):
755 |         logging.warning("SIGTERM signal received")
756 |         IO_loop.add_callback(stop_server)
757 |     signal.signal(signal.SIGTERM, sigterm)
758 | 
759 |     try:
760 |         ioloop_thread = threading.Thread(target=IO_loop.start)
761 |         ioloop_thread.start()
762 |         time.sleep(1)   # Time to start thread
763 |         print("Pyxterm server started", file=sys.stderr)
764 |         print("Open URL %s in browser to connect" % new_url, file=sys.stderr)
765 |         print("Type ^C to stop", file=sys.stderr)
766 |         while Http_server:
767 |             time.sleep(1)
768 |     except KeyboardInterrupt:
769 |         print("Interrupted", file=sys.stderr)
770 | 
771 |     finally:
772 |         if Term_manager:
773 |             Term_manager.shutdown()
774 |     IO_loop.add_callback(stop_server)
775 | 
776 | def main():
777 |     from optparse import OptionParser
778 |     usage = "usage: %prog [<shell_command>]"
779 |     parser = OptionParser(usage=usage)
780 |     parser.add_option("", "--host", dest="host", default="localhost",
781 |                       help="Host (default: localhost)")
782 |     parser.add_option("", "--port", dest="port", default=8700, type="int",
783 |                       help="Port to listen on (default: 8700)")
784 |     parser.add_option("", "--external_host", dest="external_host", default="",
785 |                       help="External host (default: same as host)")
786 |     parser.add_option("", "--external_port", dest="external_port", default=0, type="int",
787 |                       help="External port (default: same as port)")
788 |     parser.add_option("", "--https", dest="https", default=False, action="store_true",
789 |                       help="Enable https")
790 |     parser.add_option("", "--auth_type", dest="auth_type", default="ssh",
791 |                       help="Authentication type: %s (default: ssh)" % "/".join(AUTH_TYPES))
792 |     parser.add_option("", "--client_cert", dest="client_cert", default="",
793 |                       help="Path to client CA cert (or '.')")
794 |     parser.add_option("", "--term_type", dest="term_type", default="xterm",
795 |                       help="Terminal type (default: xterm)")
796 |     parser.add_option("", "--term_options", dest="term_options", default="",
797 |                       help="Terminal options (comma-separated, no spaces)")
798 |     parser.add_option("", "--max_terminals", dest="max_terminals", default=100, type="int",
799 |                       help="Maximum number of terminals")
800 |     parser.add_option("-t", "--terminal", dest="terminal", default=False, action="store_true",
801 |                       help="Open new terminal window at start")
802 |     parser.add_option("-l", "--logging", dest="logging", default=False, action="store_true",
803 |                       help="Enable logging")
804 | 
805 |     (options, args) = parser.parse_args()
806 | 
807 |     if options.auth_type not in AUTH_TYPES:
808 |         sys.exit("--auth_type must be one of %s" % (AUTH_TYPES,))
809 | 
810 |     tornado.options.options.logging = "none"    # Disable tornado logging
811 |     tornado.options.parse_command_line([])      # Parse "dummy" command line
812 | 
813 |     run_server(options, args)
814 | 
815 | if __name__ == "__main__":
816 |     main()
817 | 


--------------------------------------------------------------------------------