├── tests
    ├── stage17
    │   └── plugin17.js
    ├── stage11
    │   ├── plugin11_1.js
    │   └── plugin11.js
    ├── stage01
    │   └── plugin1.js
    ├── stage30
    │   └── plugin30.js
    ├── stage06
    │   ├── plugin6_1.js
    │   └── plugin6_2.js
    ├── tests_node.js
    ├── stage02
    │   └── plugin2.js
    ├── stage07
    │   └── plugin7.js
    ├── stage09
    │   └── plugin9.js
    ├── stage12
    │   └── plugin12.js
    ├── stage03
    │   └── plugin3.js
    ├── stage15
    │   ├── plugin15_good.js
    │   └── plugin15_bad.js
    ├── stage10
    │   └── plugin10.js
    ├── stage23
    │   └── plugin23.js
    ├── stage04
    │   └── plugin4.js
    ├── stage26
    │   └── plugin26.js
    ├── stage27
    │   └── plugin27.js
    ├── tests_web.html
    ├── stage21
    │   └── plugin21.js
    ├── stage19
    │   └── plugin19.js
    ├── stage31
    │   └── plugin31.js
    ├── stage16
    │   └── plugin16.js
    ├── stage05
    │   └── plugin5.js
    ├── stage28
    │   └── plugin28.js
    ├── stage25
    │   └── plugin25.js
    ├── stage08
    │   └── plugin8.js
    ├── stage29
    │   └── plugin29.js
    ├── stage13
    │   └── plugin13.js
    ├── stage24
    │   └── plugin24.js
    ├── stage22
    │   └── plugin22.js
    ├── stage20
    │   └── plugin20.js
    ├── stage32
    │   └── plugin32.js
    ├── lighttest.js
    └── tests.js
├── lib
    ├── _frame.html
    ├── _pluginWebIframe.js
    ├── _pluginCore.js
    ├── _pluginWebWorker.js
    ├── _frame.js
    ├── _pluginNode.js
    ├── _JailedSite.js
    └── jailed.js
├── demos
    ├── web
    │   ├── banner
    │   │   ├── bad.png
    │   │   ├── good.png
    │   │   ├── empty.png
    │   │   ├── readme.md
    │   │   ├── banner.js
    │   │   ├── application.js
    │   │   ├── index.html
    │   │   └── style.css
    │   ├── console
    │   │   ├── bg.png
    │   │   ├── readme.md
    │   │   ├── index.html
    │   │   ├── plugin.js
    │   │   ├── style.css
    │   │   └── application.js
    │   ├── process
    │   │   ├── bg.png
    │   │   ├── scroll.png
    │   │   ├── plugin.js
    │   │   ├── index.html
    │   │   ├── style.css
    │   │   ├── refresh.svg
    │   │   └── application.js
    │   └── circle
    │   │   ├── readme.md
    │   │   ├── plugin.js
    │   │   ├── index.html
    │   │   ├── application.js
    │   │   └── style.css
    └── node
    │   ├── fs
    │       ├── log.txt
    │       ├── readme.md
    │       ├── start.js
    │       └── plugin.js
    │   └── timeout
    │       ├── plugin.js
    │       ├── readme.md
    │       └── start.js
├── bower.json
├── package.json
├── LICENSE
└── README.md


/tests/stage17/plugin17.js:
--------------------------------------------------------------------------------
1 | auaa } u((uu&


--------------------------------------------------------------------------------
/lib/_frame.html:
--------------------------------------------------------------------------------
1 | <script src="_frame.js"></script>
2 | 


--------------------------------------------------------------------------------
/tests/stage11/plugin11_1.js:
--------------------------------------------------------------------------------
1 | application.disconnect();


--------------------------------------------------------------------------------
/tests/stage01/plugin1.js:
--------------------------------------------------------------------------------
1 | 
2 | application.remote.callMe();
3 | 


--------------------------------------------------------------------------------
/tests/stage30/plugin30.js:
--------------------------------------------------------------------------------
1 | 
2 | application.whenConnected('something');


--------------------------------------------------------------------------------
/demos/web/banner/bad.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asvd/jailed/HEAD/demos/web/banner/bad.png


--------------------------------------------------------------------------------
/demos/web/banner/good.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asvd/jailed/HEAD/demos/web/banner/good.png


--------------------------------------------------------------------------------
/demos/web/console/bg.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asvd/jailed/HEAD/demos/web/console/bg.png


--------------------------------------------------------------------------------
/demos/web/process/bg.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asvd/jailed/HEAD/demos/web/process/bg.png


--------------------------------------------------------------------------------
/tests/stage06/plugin6_1.js:
--------------------------------------------------------------------------------
1 | application.setInterface({square: function(val, cb){ cb(val*val); } });


--------------------------------------------------------------------------------
/demos/web/banner/empty.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asvd/jailed/HEAD/demos/web/banner/empty.png


--------------------------------------------------------------------------------
/demos/web/process/scroll.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/asvd/jailed/HEAD/demos/web/process/scroll.png


--------------------------------------------------------------------------------
/tests/stage06/plugin6_2.js:
--------------------------------------------------------------------------------
1 | application.setInterface({square: function(val, cb){ cb(val*val); } });
2 | 


--------------------------------------------------------------------------------
/tests/tests_node.js:
--------------------------------------------------------------------------------
1 | require('./lighttest.js');
2 | jailed = require('../lib/jailed.js');
3 | require('./tests.js');
4 | 


--------------------------------------------------------------------------------
/tests/stage02/plugin2.js:
--------------------------------------------------------------------------------
1 | var cb = function(result) {
2 |     application.remote.report(result);
3 | }
4 | 
5 | application.remote.square(2, cb);


--------------------------------------------------------------------------------
/tests/stage07/plugin7.js:
--------------------------------------------------------------------------------
1 | var api = {
2 |     square : function(val, cb) {cb(val*val);}
3 | };
4 | 
5 | 
6 | application.setInterface(api);
7 | 


--------------------------------------------------------------------------------
/tests/stage09/plugin9.js:
--------------------------------------------------------------------------------
1 | var finalize = function() {
2 |     application.remote.done();
3 | }
4 | 
5 | application.remote.checkAttempt(finalize);


--------------------------------------------------------------------------------
/tests/stage12/plugin12.js:
--------------------------------------------------------------------------------
1 | var api = {
2 |     square: function(val, cb) {
3 |         cb(val*val);
4 |     }
5 | }
6 | 
7 | application.setInterface(api);


--------------------------------------------------------------------------------
/tests/stage03/plugin3.js:
--------------------------------------------------------------------------------
1 | 
2 | var api = {
3 |     square : function(val, cb) {
4 |         cb(val*val);
5 |     }
6 | };
7 | 
8 | application.setInterface(api);
9 | 


--------------------------------------------------------------------------------
/tests/stage15/plugin15_good.js:
--------------------------------------------------------------------------------
1 | 
2 | var api = {
3 |     square : function(val, cb) {
4 |         cb(val*val);
5 |     }
6 | }
7 | 
8 | application.setInterface(api);


--------------------------------------------------------------------------------
/demos/node/fs/log.txt:
--------------------------------------------------------------------------------
1 | New message added by the plugin on Wed Aug 27 2014 01:51:07 GMT+0200 (CEST)
2 | New message added by the plugin on Sun Sep 21 2014 14:16:24 GMT+0200 (CEST)
3 | 


--------------------------------------------------------------------------------
/tests/stage15/plugin15_bad.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var api = {
 3 |     infinite: function(cb) {
 4 |         while (true) {};
 5 |         cb();
 6 |     }
 7 | }
 8 | 
 9 | application.setInterface(api);
10 | 


--------------------------------------------------------------------------------
/tests/stage11/plugin11.js:
--------------------------------------------------------------------------------
1 | var api = {
2 |     square : function(val, cb) { cb(val*val); },
3 |     killYourself : function() { application.disconnect(); }
4 | }
5 | 
6 | application.setInterface(api);
7 | 
8 | 


--------------------------------------------------------------------------------
/tests/stage10/plugin10.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var cb1 = function(result) {
 3 |     var cb2 = function() {
 4 |         application.remote.done();
 5 |     }
 6 | 
 7 |     application.remote.report(result, cb2);
 8 | }
 9 | 
10 | 
11 | application.remote.getNum(cb1);


--------------------------------------------------------------------------------
/tests/stage23/plugin23.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var api = {
 3 |     callback: function(num, cb0, cb1) {
 4 |         if (num == 0) {
 5 |             cb0();
 6 |         } else {
 7 |             cb1();
 8 |         }
 9 |     }
10 | }
11 | 
12 | application.setInterface(api);


--------------------------------------------------------------------------------
/tests/stage04/plugin4.js:
--------------------------------------------------------------------------------
 1 | var api = {
 2 |     squareDelayed : function(val, cb) {
 3 |         var cb1 = function() {
 4 |              cb(val*val);
 5 |          }
 6 | 
 7 |         application.remote.wait(cb1);
 8 |     }
 9 | };
10 | 
11 | application.setInterface(api);
12 | 


--------------------------------------------------------------------------------
/tests/stage26/plugin26.js:
--------------------------------------------------------------------------------
 1 | var api = {
 2 |     squareDelayed: function(val, cb) {
 3 |         application.remote.wait(
 4 |             function() {
 5 |                 cb(val*val);
 6 |             }
 7 |         );
 8 |     }
 9 | };
10 | 
11 | application.setInterface(api);


--------------------------------------------------------------------------------
/demos/web/circle/readme.md:
--------------------------------------------------------------------------------
1 | # Dangling Circle demo
2 | 
3 | This example demonstrates how to use a plugin to easily perform a
4 | heavy calculation in a separate therad.
5 | 
6 | Watch this demo online:
7 | 
8 | [https://asvd.github.io/jailed/demos/web/circle/](https://asvd.github.io/jailed/demos/web/circle/)
9 | 


--------------------------------------------------------------------------------
/demos/web/console/readme.md:
--------------------------------------------------------------------------------
1 | # Console demo
2 | 
3 | This example demonstrates the usage of a plugin for evaluating a
4 | potentially untrusted code submitted by the user
5 | 
6 | Watch this demo online:
7 | 
8 | [https://asvd.github.io/jailed/demos/web/console/](https://asvd.github.io/jailed/demos/web/console/)
9 | 


--------------------------------------------------------------------------------
/tests/stage27/plugin27.js:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | var init = function() {
 4 |     var notYetCalled = true;
 5 |     var cb = function() {
 6 |         application.remote.check(notYetCalled);
 7 |         notYetCalled = false;
 8 |     }
 9 | 
10 |     application.remote.callme(cb, cb);
11 | }
12 | 
13 | application.whenConnected(init);
14 | 


--------------------------------------------------------------------------------
/demos/web/banner/readme.md:
--------------------------------------------------------------------------------
 1 | # Banner demo
 2 | 
 3 | This example demonstrates how a third-party partner's library
 4 | (`banner.js`) may be used to safely manipulate on the part of an
 5 | application.
 6 | 
 7 | Watch this demo online:
 8 | 
 9 | [https://asvd.github.io/jailed/demos/web/banner/](https://asvd.github.io/jailed/demos/web/banner/)
10 | 


--------------------------------------------------------------------------------
/tests/tests_web.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 |   <head>
 3 |     <title>API-Sandbox test</title>
 4 |     <script type="text/javascript" src="lighttest.js"></script>
 5 |     <script type="text/javascript" src="../lib/jailed.js"></script>
 6 |   </head>
 7 |   <body>
 8 |     <script type="text/javascript" src="tests.js"></script>
 9 |   </body>
10 | </html>
11 | 


--------------------------------------------------------------------------------
/tests/stage21/plugin21.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var api = {
 3 |     square : function(val, cb) {
 4 |         cb(val*val);
 5 |     },
 6 |     cubeDelayed : function(val, cb) {
 7 |         setTimeout(
 8 |             function() {
 9 |                 cb(val*val*val);
10 |             }, 1000
11 |         );
12 |     }
13 | }
14 | 
15 | application.setInterface(api);


--------------------------------------------------------------------------------
/tests/stage19/plugin19.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var api = {
 3 |     square : function(val, cb) {
 4 |         cb(val*val);
 5 |     },
 6 |     broken : function(cb) {
 7 |         somethingWrong();
 8 |         cb();
 9 |     },
10 |     brokenDelayed : function(cb) {
11 |         setTimeout(cb, 500);
12 |         somethingWrong();
13 |     }
14 | }
15 | 
16 | application.setInterface(api);
17 | 


--------------------------------------------------------------------------------
/demos/node/timeout/plugin.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var fib = function(num) {
 3 |     var result = 0;
 4 |     if (num < 2) {
 5 |         result = num;
 6 |     } else {
 7 |         result = fib(num-1) + fib(num-2);
 8 |     }
 9 | 
10 |     return result;
11 | }
12 | 
13 | 
14 | 
15 | var api = {
16 |     fib: function(num, cb) {
17 |         cb(fib(num));
18 |     }
19 | };
20 | 
21 | application.setInterface(api);
22 | 
23 | 


--------------------------------------------------------------------------------
/tests/stage31/plugin31.js:
--------------------------------------------------------------------------------
 1 | var connected = false;
 2 | 
 3 | var tryConnect = function() {
 4 |     application.whenConnected(connect);
 5 | }
 6 | 
 7 | var connect = function() {
 8 |     connected = true;
 9 | }
10 | 
11 | var checkConnect = function() {
12 |     application.remote.check(connected, finalize);
13 | }
14 | 
15 | var finalize = function() {
16 |     application.remote.done();
17 | }
18 | 
19 | setTimeout(tryConnect, 300);
20 | setTimeout(checkConnect, 600);
21 | 


--------------------------------------------------------------------------------
/demos/web/circle/plugin.js:
--------------------------------------------------------------------------------
 1 | 
 2 | // slowly calculates the fibonacci number
 3 | var fib = function(num) {
 4 |     var result = 0;
 5 |     if (num < 2) {
 6 |         result = num;
 7 |     } else {
 8 |         result = fib(num-1) + fib(num-2);
 9 |     }
10 | 
11 |     return result;
12 | }
13 | 
14 | 
15 | // provided to the application
16 | var api = {
17 |     fib: function(num, cb) {
18 |         cb(fib(num));
19 |     }
20 | };
21 | 
22 | application.setInterface(api);
23 | 


--------------------------------------------------------------------------------
/demos/web/process/plugin.js:
--------------------------------------------------------------------------------
 1 | application.setInterface({
 2 |     process : function(input, code, cb) {
 3 |         var result = {
 4 |             output: null,
 5 |             error: null
 6 |         };
 7 | 
 8 |         try {
 9 |             eval('method = '+code);
10 |             eval('data = '+ input);
11 |             result.output = method(data);
12 |         } catch(e) {
13 |             result.error = e.message;
14 |         }
15 | 
16 |         cb(result);
17 |     }
18 | });
19 | 


--------------------------------------------------------------------------------
/tests/stage16/plugin16.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var step1 =  function() {
 3 |     var _proc = (typeof process != 'undefined' &&
 4 |                  process &&
 5 |                  typeof process.version != 'undefined');
 6 | 
 7 |     var _require = (typeof require != 'undefined' && !!require);
 8 | 
 9 |     application.remote.check(!_proc && !_require, step2);
10 | }
11 | 
12 | var step2 = function() {
13 |     application.remote.done();
14 | }
15 | 
16 | 
17 | 
18 | application.whenConnected(step1);
19 | 


--------------------------------------------------------------------------------
/tests/stage05/plugin5.js:
--------------------------------------------------------------------------------
 1 | var waitCalled = false;
 2 | 
 3 | var api = {
 4 |     wait : function(cb) {
 5 |         waitCalled = true;
 6 |         setTimeout(cb,1000);
 7 |     }
 8 | };
 9 | 
10 | 
11 | application.setInterface(api);
12 | 
13 | var init = function() {
14 |     var val = 2;
15 |     var cb = function(result) {
16 |         application.remote.report(result, waitCalled);
17 |     }
18 | 
19 |     application.remote.squareDelayed(val, cb)
20 | }
21 | 
22 | application.whenConnected(init);


--------------------------------------------------------------------------------
/tests/stage28/plugin28.js:
--------------------------------------------------------------------------------
 1 | var api = {
 2 |     callme : function(cb0, cb1) {
 3 |         var finalize = function() {
 4 |             application.remote.done();
 5 |         }
 6 | 
 7 |         setTimeout(finalize, 1000);
 8 | 
 9 |         cb0();
10 | 
11 |         try {
12 |             cb1();
13 |             application.remote.check(false);
14 |         } catch(e) {
15 |             application.remote.check(true);
16 |             throw e;
17 |         }
18 |     }
19 | };
20 | 
21 | application.setInterface(api);


--------------------------------------------------------------------------------
/tests/stage25/plugin25.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var api = {
 3 |     wait: function(cb) {
 4 |         setTimeout(cb, 1000);
 5 |     }
 6 | }
 7 | 
 8 | application.setInterface(api);
 9 | 
10 | 
11 | var step1 = function() {
12 |     var val = 21;
13 |     var cb = function(result) {
14 |         application.remote.check(result == val*val, finalize);
15 |     }
16 |     application.remote.squareDelayed(val, cb);
17 | }
18 | 
19 | var finalize = function() {
20 |     application.remote.done();
21 | }
22 | 
23 | application.whenConnected(step1);
24 | 
25 | 


--------------------------------------------------------------------------------
/tests/stage08/plugin8.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var val1 = 2;
 3 | 
 4 | var cb1 = function(result) {
 5 |     application.remote.check(result == val1*val1);
 6 | 
 7 |     setTimeout(step2, 1000);
 8 | }
 9 | 
10 | var step2 = function() {
11 |     var val2 = 5;
12 |     
13 |     var cb2 = function(result) {
14 |         application.remote.check(result == val2*val2);
15 | 
16 |         setTimeout(function() { application.remote.done(); }, 1000);
17 |     }
18 | 
19 |     application.remote.square(val2, cb2);
20 | }
21 | 
22 | application.remote.square(val1, cb1);


--------------------------------------------------------------------------------
/demos/web/banner/banner.js:
--------------------------------------------------------------------------------
 1 | 
 2 | // potentially insecure 3rd-party partner code which may only
 3 | // perform what is permitted by the application
 4 | 
 5 | var bad = false;
 6 | 
 7 | // updates banner image and link
 8 | var update = function() {
 9 |     var image = bad ? 'bad.png' : 'good.png';
10 |     var link = bad ? 'http://facebook.com/' : 'http://google.com';
11 | 
12 |     application.remote.setImage(image);
13 |     application.remote.setLink(link);
14 | 
15 |     bad = !bad;
16 | }
17 | 
18 | update();
19 | setInterval(update, 2000);
20 | 
21 | 


--------------------------------------------------------------------------------
/tests/stage29/plugin29.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var api = {
 3 |     brokenDelayed : function(cb) {
 4 |         setTimeout(
 5 |             function() {
 6 |                 somethingWrong();
 7 |             }, 1000
 8 |         );
 9 | 
10 |         setTimeout(
11 |             function() {
12 |                 cb();
13 |             }, 2000
14 |         );
15 | 
16 |         
17 |     }
18 | };
19 | 
20 | application.setInterface(api);
21 | 
22 | 
23 | /*
24 | 
25 | setTimeout(
26 |     function() {
27 |         somethingWrongHere();
28 |     },
29 |     1000
30 | );
31 | 
32 | */
33 | 
34 | 


--------------------------------------------------------------------------------
/tests/stage13/plugin13.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var step1 = function() {
 3 |     var sCb = function() {
 4 |         application.remote.report(true, step2);
 5 |     }
 6 | 
 7 |     var fCb = function() {
 8 |         application.remote.report(false, step2);
 9 |     }
10 | 
11 |     application.remote.callMeBack(true, sCb, fCb);
12 | }
13 | 
14 | 
15 | var step2 = function() {
16 |     var sCb = function() {
17 |         application.remote.report(false, step3);
18 |     }
19 | 
20 |     var fCb = function() {
21 |         application.remote.report(true, step3);
22 |     }
23 | 
24 |     application.remote.callMeBack(false, sCb, fCb);
25 | }
26 | 
27 | 
28 | var step3 = function() {
29 |     application.remote.done();
30 | }
31 | 
32 | 
33 | application.whenConnected(step1);


--------------------------------------------------------------------------------
/tests/stage24/plugin24.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var step1 = function() {
 3 |     var cb0 = function() {
 4 |         application.remote.check(false, step2);
 5 |     }
 6 | 
 7 |     var cb1 = function() {
 8 |         application.remote.check(true, step2);
 9 |     }
10 | 
11 |     application.remote.callback(1, cb0, cb1);
12 | }
13 | 
14 | var step2 = function() {
15 |     var cb0 = function() {
16 |         application.remote.check(true, finalize);
17 |     }
18 | 
19 | 
20 |     var cb1 = function() {
21 |         application.remote.check(false, finalize);
22 |     }
23 | 
24 |     application.remote.callback(0, cb0, cb1);
25 | }
26 | 
27 | var finalize = function() {
28 |     application.remote.done();
29 | }
30 | 
31 | 
32 | application.whenConnected(step1);
33 | 
34 | 


--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "jailed",
 3 |   "version": "0.3.1",
 4 |   "homepage": "https://github.com/asvd/jailed",
 5 |   "authors": [
 6 |     "Dmitry Prokashev <heliosframework@gmail.com>"
 7 |   ],
 8 |   "description": "execute untrusted code in a sandbox with custom permissions",
 9 |   "main": "jailed.js",
10 |   "moduleType": [
11 |     "amd",
12 |     "globals",
13 |     "node"
14 |   ],
15 |   "keywords": [
16 |     "jailed",
17 |     "subprocess",
18 |     "untrusted",
19 |     "sandbox",
20 |     "user-submitted-code",
21 |     "web-worker",
22 |     "iframe",
23 |     "restricted",
24 |     "subprocess"
25 |   ],
26 |   "license": "MIT",
27 |   "ignore": [
28 |     "**/.*",
29 |     "node_modules",
30 |     "bower_components",
31 |     "test",
32 |     "tests",
33 |     "demos"
34 |   ]
35 | }
36 | 


--------------------------------------------------------------------------------
/tests/stage22/plugin22.js:
--------------------------------------------------------------------------------
 1 | var squareFinished = false;
 2 | var cubeFinished = false;
 3 | 
 4 | 
 5 | var valCube = 6;
 6 | 
 7 | 
 8 | var cbCube = function(result) {
 9 |     cubeFinished = true;
10 |     application.remote.check(result == valCube*valCube*valCube, finalize);
11 | }
12 | 
13 | application.remote.cubeDelayed(valCube, cbCube);
14 | 
15 | var valSquare = 8;
16 | var cbSquare = function(result) {
17 |     squareFinished = true;
18 |     application.remote.check(result == valSquare*valSquare, finalize);
19 | }
20 | 
21 | application.remote.square(valSquare, cbSquare);
22 | 
23 | 
24 | var finalize = function() {
25 |     if (squareFinished && cubeFinished) {
26 |         application.remote.check(
27 |             true,
28 |             function() {
29 |                 application.remote.done();
30 |             }
31 |         );
32 |     }
33 | }
34 | 
35 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "author": "Dmitry Prokashev <heliosframework@gmail.com>",
 3 |   "name": "jailed",
 4 |   "description": "execute untrusted code with custom permissions",
 5 |   "version": "0.3.1",
 6 |   "keywords": [
 7 |     "jailed",
 8 |     "isomorphic",
 9 |     "sandbox",
10 |     "export",
11 |     "eval",
12 |     "plugin",
13 |     "untrusted",
14 |     "restricted",
15 |     "privilliges",
16 |     "access",
17 |     "security",
18 |     "thread",
19 |     "worker",
20 |     "process",
21 |     "messaging"
22 |   ],
23 |   "repository": {
24 |     "type": "git",
25 |     "url": "git://github.com/asvd/jailed.git"
26 |   },
27 |   "browser":
28 |     {
29 |       "fs": false,
30 |       "child_process": false
31 |     },
32 |   "main": "lib/jailed.js",
33 |   "dependencies": {},
34 |   "devDependencies": {},
35 |   "optionalDependencies": {},
36 |   "engines": {
37 |     "node": "*"
38 |   }
39 | }
40 | 


--------------------------------------------------------------------------------
/demos/node/timeout/readme.md:
--------------------------------------------------------------------------------
 1 | # Timeout demo
 2 |  
 3 | Performs a heavy calculation within a plugin, controls the execution
 4 | time. The Plugin runs in a separate and restricted process which has
 5 | no access to the external environment, it only provides a method to
 6 | perform the calculation. If the calculation is not completed within a
 7 | timeout, the Plugin process is terminated. This approach may be used
 8 | for the untrusted code which may become too slow or even fall into an
 9 | infinite loop.
10 | 
11 | To launch this demo, first clone the repo:
12 | 
13 | ```sh
14 | $ git clone https://github.com/asvd/jailed
15 | ```
16 | 
17 | and then run with Node.js:
18 | 
19 | ```sh
20 | $ node jailed/demos/node/timeout/start.js
21 | ```
22 | 
23 | The plugin calculates the Fibonacci number (40th by default), you may
24 | provide a custom argument:
25 | 
26 | ```sh
27 | $ node jailed/demos/node/timeout/start.js 50
28 | ```
29 | 
30 | (The number of 50 probably will not be calculated on time)
31 | 
32 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2013 asvd
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/demos/web/banner/application.js:
--------------------------------------------------------------------------------
 1 | 
 2 | // interface provided to the plugin
 3 | var image = document.getElementById('image');
 4 | var setImage = function(src) {
 5 |     image.style.backgroundImage = 'url('+src+')';
 6 | }
 7 | 
 8 | var link = document.getElementById('link');
 9 | var setLink = function(src) {
10 |     link.href = src;
11 | }
12 | 
13 | var api = {
14 |     setImage: setImage,
15 |     setLink: setLink
16 | }
17 | 
18 | 
19 | // clears the banner
20 | var reset = function() {
21 |     plugin = null;
22 |     setImage('empty.png');
23 |     setLink('#');
24 | }
25 | 
26 | 
27 | // initalize everything
28 | var plugin;
29 | var scripts = document.getElementsByTagName('script');
30 | var path = scripts[scripts.length-1].src
31 |     .split('/')
32 |     .slice(0, -1)
33 |     .join('/')+'/';
34 | 
35 | 
36 | // creates the plugin, provides the interface
37 | document.getElementById('connect').onclick = function() {
38 |     plugin = plugin || new jailed.Plugin(path+'banner.js', api);
39 | }
40 | 
41 | 
42 | // disconnects the plugin, resets the banner
43 | document.getElementById('disconnect').onclick = function() {
44 |     if (plugin) {
45 |         plugin.disconnect();
46 |         reset();
47 |     }
48 | }
49 | 
50 | reset();
51 | 
52 | 


--------------------------------------------------------------------------------
/demos/node/fs/readme.md:
--------------------------------------------------------------------------------
 1 | # Filesystem demo
 2 | 
 3 | This example demonstrates a plugin provided with a restricted access
 4 | to the filesystem. The plugin may only create, read, update and delete
 5 | a single file (`log.txt`). A method for printing a message is
 6 | additionally exported for the demonstration purposes.
 7 | 
 8 | 
 9 | To launch this demo, first clone the repo:
10 | 
11 | ```sh
12 | $ git clone https://github.com/asvd/jailed
13 | ```
14 | 
15 | and then run with Node.js:
16 | 
17 | ```sh
18 | $ node jailed/demos/node/fs/start.js
19 | ```
20 | 
21 | You will then get an output produced by a plugin explaining in details
22 | what is going on:
23 | 
24 | ```sh
25 | $ nodejs node/fs/start.js
26 | 
27 | === Logfile content start: ===
28 | 
29 | New message added by the plugin on Wed Aug 27 2014 01:50:49 GMT+0200 (CEST)
30 | New message added by the plugin on Wed Aug 27 2014 01:51:07 GMT+0200 (CEST)
31 | 
32 | === Logfile content end ===
33 | 
34 | Logfile will be removed in 3 seconds
35 | Removing logfile...
36 | Logfile removed! Will be recreated in 3 seconds
37 | Creating an empty log file
38 | Empty logfile created, will be filled with content in 3 seconds
39 | Writing the old content into the log file along with a new message added
40 | Logfile updated
41 | Plugin finished
42 | ```
43 | 


--------------------------------------------------------------------------------
/tests/stage20/plugin20.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var step1 = function() {
 3 |     application.remote.check(true, step1_1);
 4 | }
 5 | 
 6 | var step1_1 = function() {
 7 |     var val = 6;
 8 |     var cb = function(result) {
 9 |         application.remote.check(result == val*val, step2);
10 |     }
11 | 
12 |     application.remote.square(val, cb);
13 | }
14 | 
15 | 
16 | var step2 = function() {
17 |     var cb = function() {
18 |         clearTimeout(timeout);
19 |         application.remote.check(true, step3);
20 |     }
21 | 
22 |     var fCb = function() {
23 |         var finalize = function() {
24 |             application.remote.done();
25 |         }
26 | 
27 |         application.remote.check(false, finalize);
28 |     }
29 | 
30 | 
31 |     application.remote.brokenDelayed(cb);
32 | 
33 |     timeout = setTimeout(fCb, 1000);
34 | }
35 | 
36 | 
37 | var step3 = function() {
38 |     var finalize = function() {
39 |         application.remote.done();
40 |     }
41 | 
42 |     application.remote.check(true, finalize);
43 | }
44 | 
45 | 
46 | var fail = function() {
47 |     clearTimeout(timeout);
48 |     var finalize = function() {
49 |         application.remote.done();
50 |     }
51 | 
52 |     application.remote.check(false, finalize);
53 | }
54 | 
55 | application.remote.broken(fail);
56 | 
57 | var timeout = setTimeout(step1, 1000);
58 | 
59 | 


--------------------------------------------------------------------------------
/demos/web/console/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 |   <head>
 3 |     <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 4 |     <title>JS console demo</title>
 5 |     <script type="text/javascript" src="../../../lib/jailed.js"></script>
 6 |     <link rel="stylesheet" type="text/css" href="style.css" />
 7 |   </head>
 8 |   <body>
 9 |     <div class=centered>
10 |       <div class=rel>
11 |         <div class=inv>❱</div>
12 | 
13 |         <div class=border id=border>
14 |           <div class=terminalWrap id=terminalWrap>
15 |             <div class=rel>
16 |               <div class=terminal id=terminal></div>
17 |             </div>
18 |           </div>
19 |           <div class=indicator id=indicator></div>
20 |           <div class=command id=command>
21 |             <input type=text class=commandText id=line></input>
22 |           </div>
23 |           <div class=shadow></div>
24 |         </div>
25 | 
26 |         <div class=text>
27 |           <h3>console</h3>
28 | 
29 |           User-submitted code is evaluated in a&nbsp;Plugin created
30 |           with the <a href="https://github.com/asvd/jailed">Jailed</a>
31 |           library. The code is executed in a sandboxed iframe in order
32 |           to prevent accessing the main application.
33 |         </div>
34 | 
35 |         <div class=links>
36 |           <a href='https://github.com/asvd/jailed/tree/master/demos/web/console'>
37 |             http://github.com/asvd/jailed/tree/master/demos/web/console
38 |           </a>
39 |         </div>
40 | 
41 |       </div>
42 |     </div>
43 | 
44 |     <script type="text/javascript" src="application.js"></script>
45 |   </body>
46 | </html>
47 | 
48 | 


--------------------------------------------------------------------------------
/tests/stage32/plugin32.js:
--------------------------------------------------------------------------------
 1 | var beforeConnect1Finished = 0;
 2 | var beforeConnect1 = function() {
 3 |     beforeConnect1Finished++;
 4 |     finalize();
 5 | }
 6 | 
 7 | var beforeConnect2Finished = 0;
 8 | var beforeConnect2 = function() {
 9 |     beforeConnect2Finished++;
10 |     finalize();
11 | }
12 | 
13 | 
14 | var afterConnect1Finished = 0;
15 | var afterConnect1 = function() {
16 |     afterConnect1Finished++;
17 |     finalize();
18 | }
19 | 
20 | var afterConnect2Finished = 0;
21 | var afterConnect2 = function() {
22 |     afterConnect2Finished++;
23 |     finalize();
24 | }
25 | 
26 | 
27 | var finalize = function() {
28 |     /*
29 |     console.log('HAAA');
30 |                     console.log(beforeConnect1Finished );
31 |                     console.log(beforeConnect2Finished );
32 |                     console.log(afterConnect1Finished );
33 |                     console.log(afterConnect2Finished );
34 |      */
35 |     if (
36 |         beforeConnect1Finished == 1 &&
37 |         beforeConnect2Finished == 1 &&
38 |         afterConnect1Finished == 1 &&
39 |         afterConnect2Finished == 1
40 |     ) {
41 |         application.remote.check(
42 |             beforeConnect1Finished == 1 &&
43 |                 beforeConnect2Finished == 1 &&
44 |                 afterConnect1Finished == 1 &&
45 |                 afterConnect2Finished == 1,
46 |             function() {
47 |                 application.remote.finished();
48 |             }
49 |         );
50 |     }
51 | }
52 | 
53 | var connect = function() {
54 |     setTimeout(afterConnect, 300);
55 | }
56 | 
57 | var afterConnect = function() {
58 |     application.whenConnected(afterConnect1);
59 |     application.whenConnected(afterConnect2);
60 | }
61 | 
62 | application.whenConnected(beforeConnect1);
63 | application.whenConnected(beforeConnect2);
64 | application.whenConnected(connect);
65 | 


--------------------------------------------------------------------------------
/demos/web/banner/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 |   <head>
 3 |     <title>Secured banner example</title>
 4 |     <script type="text/javascript" src="../../../lib/jailed.js"></script>
 5 |     <link rel="stylesheet" type="text/css" href="style.css" />
 6 |   </head>
 7 |   <body>
 8 |     <div class=centered>
 9 |       <div class=rel>
10 | 
11 |         <h3>banner</h3>
12 |         <a href=# id=link>
13 |           <div class=image id=image></div>
14 |         </a>
15 | 
16 |         <div class='button first' id=connect>Connect</div>
17 |         <div class='button second' id=disconnect>Disconnect</div>
18 |         <div class=text>
19 |           The squared area above is a place for a partner's
20 |           advertising banner managed by a "3rd party code" loaded as a
21 |           secure Plugin created with
22 |           the <a href="https://github.com/asvd/jailed">Jailed</a>
23 |           library. The Plugin runs in a sandboxed Worker and cannot
24 |           access the main document, with except for the two methods
25 |           explicitily exported by the application: for changing the
26 |           url the banner is pointing to, and for changing the banner
27 |           image. Even if the Plugin performs an attempt to set too big
28 |           image, it will be cropped by the application. The Plugin is
29 |           fully controlled by the application and may be connected or
30 |           disconnected anytime (operated with the two buttons in this
31 |           demo).
32 |         </div>
33 | 
34 | 
35 |         <div class=links>
36 |           <a href='https://github.com/asvd/jailed/tree/master/demos/web/banner'>
37 |             https://github.com/asvd/jailed/tree/master/demos/web/banner
38 |           </a>
39 |         </div>
40 | 
41 |       </div>
42 |     </div>
43 | 
44 |     <script type="text/javascript" src="application.js"></script>
45 |   </body>
46 | </html>
47 | 
48 | 


--------------------------------------------------------------------------------
/demos/web/console/plugin.js:
--------------------------------------------------------------------------------
 1 | 
 2 | // executes the given code and handles the result
 3 | var run = function(code) {
 4 |     var result = {
 5 |         input: code,
 6 |         output: null,
 7 |         error: null
 8 |     };
 9 | 
10 |     try {
11 |         result.output = stringify(runHidden(code));
12 |     } catch(e) {
13 |         result.error = e.message;
14 |     }
15 | 
16 |     application.remote.output(result);
17 | }
18 | 
19 | 
20 | // protects even the worker scope from being accessed
21 | var runHidden = function(code) {
22 |     var indexedDB = null;
23 |     var location = null;
24 |     var navigator = null;
25 |     var onerror = null;
26 |     var onmessage = null;
27 |     var performance = null;
28 |     var self = null;
29 |     var webkitIndexedDB = null;
30 |     var postMessage = null;
31 |     var close = null;
32 |     var openDatabase = null;
33 |     var openDatabaseSync = null;
34 |     var webkitRequestFileSystem = null;
35 |     var webkitRequestFileSystemSync = null;
36 |     var webkitResolveLocalFileSystemSyncURL = null;
37 |     var webkitResolveLocalFileSystemURL = null;
38 |     var addEventListener = null;
39 |     var dispatchEvent = null;
40 |     var removeEventListener = null;
41 |     var dump = null;
42 |     var onoffline = null;
43 |     var ononline = null;
44 |     var importScripts = null;
45 |     var console = null;
46 |     var application = null;
47 |     
48 |     return eval(code);
49 | }
50 | 
51 | 
52 | // converts the output into a string
53 | var stringify = function(output) {
54 |     var result;
55 | 
56 |     if (typeof output == 'undefined') {
57 |         result = 'undefined';
58 |     } else if (output === null) {
59 |         result = 'null';
60 |     } else {
61 |         result = JSON.stringify(output) || output.toString();
62 |     }
63 | 
64 |     return result;
65 | }
66 | 
67 | 
68 | application.setInterface({run:run});
69 | 
70 | 


--------------------------------------------------------------------------------
/demos/web/circle/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 |   <head>
 3 |     <title>Heavy calculations example</title>
 4 |     <script type="text/javascript" src="../../../lib/jailed.js"></script>
 5 |     <link rel="stylesheet" type="text/css" href="style.css" />
 6 |   </head>
 7 |   <body>
 8 |     <div class=centered>
 9 |       <div class=rel>
10 |         <h3>the dangling circle</h3>
11 | 
12 |         <div class=circle id=circle></div>
13 | 
14 |         <div class=left>
15 |             <div class=button id=btnLocal>Calculate locally</div>
16 |             <div class=output id=outputLocal></div>
17 |             <div class=text>
18 |               Starts a heavy calculation simply as a function call
19 |               within the main page. This will interrupt the animation
20 |               (which is performed with JavaScript) until the
21 |               calculation is completed, the page will hang up for
22 |               some time.
23 |             </div>
24 |         </div>
25 | 
26 |         <div class=separator></div>
27 | 
28 |         <div class=right>
29 |             <div class=button id=btnPlugin>Calculate in the plugin</div>
30 |             <div class=output id=outputPlugin></div>
31 |             <div class=text>
32 |               Performs exactly the same calculation, but uses a method
33 |               provided by the Plugin created with
34 |               the <a href="https://github.com/asvd/jailed">Jailed</a>
35 |               library instead. The Plugin runs in a separate thread of
36 |               a Worker, so the page will not freeze during the
37 |               calculation.
38 |             </div>
39 |         </div>
40 | 
41 | 
42 |         <div class=links>
43 |           <a href='https://github.com/asvd/jailed/tree/master/demos/web/circle'>
44 |             https://github.com/asvd/jailed/tree/master/demos/web/circle
45 |           </a>
46 |         </div>
47 | 
48 |       </div>
49 |     </div>
50 | 
51 |     <script type="text/javascript" src="application.js"></script>
52 |   </body>
53 | </html>
54 | 
55 | 


--------------------------------------------------------------------------------
/demos/node/fs/start.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /**
 3 |  * Filesystem demo
 4 |  * 
 5 |  * A code loaded as a Plugin is provided with a restricted access to
 6 |  * the filesystem: it can only create, read, update and delete the
 7 |  * particular file (log.txt). A method for printing a message is
 8 |  * additionally exported for the demonstration purposes.
 9 |  */
10 | 
11 | var jailed = require('../../../lib/jailed.js');
12 | var fs = require('fs');
13 | 
14 | 
15 | // building plugin interface
16 | var log = __dirname + '/log.txt';
17 | 
18 | // creates the empty log file
19 | var createLog = function(sCb, fCb) {
20 |     var cb = function(err) {
21 |         if (err) {
22 |             fCb();
23 |         } else {
24 |             sCb();
25 |         }
26 |     }
27 | 
28 |     fs.writeFile(log, '', cb);
29 | }
30 | 
31 | 
32 | // reads the log file
33 | var readLog = function(sCb, fCb) {
34 |     var cb = function(err, data) {
35 |         if (err) {
36 |             fCb();
37 |         } else {
38 |             sCb(data.toString());
39 |         }
40 |     }
41 | 
42 |     fs.readFile(log, cb);
43 | }
44 | 
45 | 
46 | // puts the given content into the log file
47 | var updateLog = function(data, sCb, fCb) {
48 |     var cb = function(err) {
49 |         if (err) {
50 |             fCb();
51 |         } else {
52 |             sCb();
53 |         }
54 |     }
55 | 
56 |     fs.writeFile(log, data, cb);
57 | }
58 | 
59 | 
60 | // removes the log file
61 | var deleteLog = function(sCb, fCb) {
62 |     var cb = function(err) {
63 |         if (err) {
64 |             fCb();
65 |         } else {
66 |             sCb();
67 |         }
68 |     }
69 | 
70 |     fs.unlink(log, cb);
71 | }
72 | 
73 | 
74 | // prints the given message on the console
75 | var print = function(msg) {
76 |     console.log(msg);
77 | }
78 | 
79 | 
80 | var api = {
81 |     print: print,
82 |     createLog: createLog,
83 |     readLog: readLog,
84 |     updateLog: updateLog,
85 |     deleteLog: deleteLog
86 | };
87 | 
88 | 
89 | var plugin = new jailed.Plugin(__dirname + '/plugin.js', api);
90 | 
91 | // all other work is performed by the plugin
92 | 


--------------------------------------------------------------------------------
/demos/node/timeout/start.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /**
 3 |  * Timeout demo
 4 |  * 
 5 |  * Performs a heavy calculation within a Plugin, controls the
 6 |  * execution time. The Plugin runs in a separate and restricted
 7 |  * process which has no access to the external environment, it only
 8 |  * provides a method to perform the calculation. If the calculation is
 9 |  * not completed within a timeout, the Plugin process is
10 |  * terminated. This approach may be used for the untrusted code which
11 |  * may become too slow or even fall into an infinite loop.
12 |  */
13 | 
14 | var jailed = require('../../../lib/jailed.js');
15 | 
16 | 
17 | // determining the fibonacci number to calculate
18 | var num = 40;
19 | if (process.argv.length < 3 || !+process.argv[2]) {
20 |     console.log(
21 |         'Number was not provided, the default value of '
22 |             + num + ' used instead'
23 |     );
24 | 
25 |     console.log(
26 |         'Usage: ' +process.argv[0]+ ' ' +process.argv[1]+ ' [number]'
27 |     );
28 | 
29 | } else {
30 |     num = +process.argv[2]||num;
31 | }
32 | 
33 | 
34 | // displays the result
35 | var report = function(result) {
36 |     if (result) {
37 |         console.log('Success! The result is: ' + result);
38 |     } else {
39 |         console.log('The result is unknown :-/');
40 |     }
41 | 
42 |     plugin.disconnect();
43 |     clearInterval(countdownInterval);
44 | }
45 | 
46 | 
47 | // destroys the plugin after several calls
48 | var count = 6;
49 | var countdown = function() {
50 |     if (--count > 0) {
51 |         console.log('Plugin will be destroyed in '+ count +'"');
52 |     } else {
53 |         var msg = 'Plugin has failed to calculate on time ' +
54 |             'and will be destroyed!';
55 |         console.log(msg);
56 |         report(null);
57 |     }
58 | }
59 | 
60 | 
61 | // initialize everything
62 | var countdownInterval;
63 | 
64 | var init = function() {
65 |     console.log('Calculating the fibonacci number for '+num+'...');
66 |     plugin.remote.fib(num, report);
67 |     countdownInterval = setInterval(countdown, 1000);
68 | }
69 | 
70 | var plugin = new jailed.Plugin(__dirname+'/plugin.js');
71 | plugin.whenConnected(init);
72 | 
73 | 


--------------------------------------------------------------------------------
/lib/_pluginWebIframe.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /**
 3 |  * Contains the routines loaded by the plugin iframe under web-browser
 4 |  * in case when worker failed to initialize
 5 |  * 
 6 |  * Initializes the web environment version of the platform-dependent
 7 |  * connection object for the plugin site
 8 |  */
 9 | 
10 | 
11 | window.application = {};
12 | window.connection = {};
13 | 
14 | 
15 | // event listener for the plugin message
16 | window.addEventListener('message', function(e) {
17 |     var m = e.data.data;
18 |     switch (m.type) {
19 |     case 'import':
20 |     case 'importJailed':  // already jailed in the iframe
21 |         importScript(m.url);
22 |         break;
23 |     case 'execute':
24 |         execute(m.code);
25 |         break;
26 |     case 'message':
27 |         conn._messageHandler(m.data);
28 |         break;
29 |     }
30 | });
31 | 
32 | 
33 | // loads and executes the javascript file with the given url
34 | var importScript = function(url) {
35 |     var success = function() {
36 |         parent.postMessage({
37 |             type : 'importSuccess',
38 |             url  : url
39 |         }, '*');
40 |     }
41 | 
42 |     var failure = function() {
43 |        parent.postMessage({
44 |            type : 'importFailure',
45 |            url  : url
46 |        }, '*');
47 |     }
48 | 
49 |     var error = null;
50 |     try {
51 |         window.loadScript(url, success, failure);
52 |     } catch (e) {
53 |         error = e;
54 |     }
55 | 
56 |     if (error) {
57 |         throw error;
58 |         failure();
59 |     }
60 | }
61 | 
62 | 
63 | // evaluates the provided string
64 | var execute = function(code) {
65 |     try {
66 |         eval(code);
67 |     } catch (e) {
68 |         parent.postMessage({type : 'executeFailure'}, '*');
69 |         throw e;
70 |     }
71 | 
72 |     parent.postMessage({type : 'executeSuccess'}, '*');
73 | }
74 | 
75 | 
76 | // connection object for the JailedSite constructor
77 | var conn = {
78 |     disconnect : function() {},
79 |     send: function(data) {
80 |         parent.postMessage({type: 'message', data: data}, '*');
81 |     },
82 |     onMessage: function(h){ conn._messageHandler = h },
83 |     _messageHandler: function(){},
84 |     onDisconnect: function(){}
85 | };
86 | 
87 | window.connection = conn;
88 | 
89 | parent.postMessage({
90 |     type : 'initialized',
91 |     dedicatedThread : false
92 | }, '*');
93 | 
94 | 


--------------------------------------------------------------------------------
/demos/web/banner/style.css:
--------------------------------------------------------------------------------
  1 | body {
  2 |     background-color: #112233;
  3 |     color: #aabbcc;
  4 |     font-family: sans;
  5 |     font-size: 14px;
  6 |     line-height: 24px;
  7 |     cursor: default;
  8 | }
  9 | 
 10 | 
 11 | .rel {
 12 |     position: relative;
 13 |     padding: 0px;
 14 | }
 15 | 
 16 | 
 17 | .centered {
 18 |     width: 450px;
 19 |     padding: 0px;
 20 |     height: 300px;
 21 |     display: block;
 22 |     margin-left: auto;
 23 |     margin-right: auto;
 24 | }
 25 | 
 26 | 
 27 | .image {
 28 |     width: 100px;
 29 |     height: 100px;
 30 |     position: absolute;
 31 |     left: 176px;
 32 |     top: 100px;
 33 | }
 34 | 
 35 | 
 36 | .button {
 37 |     position: absolute;
 38 |     padding-top: 5px;
 39 |     padding-bottom: 1px;
 40 |     width: 200px;
 41 |     height: 25px;
 42 |     text-align: center;
 43 |     background-color: #112233;
 44 |     color: #aabbcc;
 45 |     cursor: pointer;
 46 |     font-family: sans;
 47 |     border: 1px solid #556677;
 48 |     border-radius: 2px;
 49 |     top: 230px;
 50 | }
 51 | 
 52 | 
 53 | .button:hover {
 54 |     background-color: #223344;
 55 |     color: #ddeeff;
 56 | }
 57 | 
 58 | 
 59 | .button:active {
 60 |     background-color: #334455;
 61 |     box-shadow: 0px 0px 3px 0px #556677;
 62 |     border: 1px solid #99AABB;
 63 |     cursor: default;
 64 |     color: #ccddee;
 65 | }
 66 | 
 67 | 
 68 | .first {
 69 |     left: 20px;
 70 | }
 71 | 
 72 | 
 73 | .second {
 74 |     left: 230px;
 75 | }
 76 | 
 77 | 
 78 | h3 {
 79 |     position: absolute;
 80 |     width: 412px;
 81 |     height: 100px;
 82 |     left: 20px;
 83 |     top: 20px;
 84 |     text-align: center;
 85 |     color: #aabbcc;
 86 |     font-family: sans;
 87 |     font-variant: small-caps;
 88 | }
 89 | 
 90 | 
 91 | .text {
 92 |     position: absolute;
 93 | #    text-indent: 2px;
 94 |     text-align: justify;
 95 |     width: 412px;
 96 |     height: 400px;
 97 |     top: 300px;
 98 |     left: 20px;
 99 | }
100 | 
101 | 
102 | .links {
103 |     position: absolute;
104 |     width: 412;
105 |     height: 50px;
106 |     top: 600px;
107 |     left: 20px;
108 |     text-align: center;
109 |     font-size: 11px;
110 | }
111 | 
112 | a {
113 |     color: #48D7E9;
114 |     text-shadow: 0px 0px 3px #133153;
115 | }
116 | 
117 | 
118 | a:hover {
119 |     color: #72EDFD;
120 |     text-shadow: 0px 0px 8px #3F638B;
121 | }
122 | 
123 | 
124 | 


--------------------------------------------------------------------------------
/demos/web/circle/application.js:
--------------------------------------------------------------------------------
 1 | 
 2 | // animates the circle
 3 | var circle = document.getElementById('circle');
 4 | var X = 0;  // animation parameters
 5 | var Y = 0;
 6 | 
 7 | setInterval(
 8 |     function() {
 9 |         X += .04;
10 |         Y += .05;
11 |         circle.style.marginLeft = Math.sin(Math.sin(X)*4)*13;
12 |         circle.style.marginTop  = Math.sin(Math.sin(Y)*4)*5;
13 |     }, 20
14 | );
15 | 
16 | 
17 | // (de)activates the circle highlight during the calculations
18 | var highlight = function(activate) {
19 |     if (activate) {
20 |         circle.style.backgroundColor = '#223344';
21 |         circle.style.border = '1px solid #99AABB';
22 |         circle.style.boxShadow =
23 |             '0px 0px 5px 0px rgba(100, 120, 140, .5)';
24 |     } else {
25 |         circle.style.backgroundColor = '#112233';
26 |         circle.style.border = '1px solid #556677';
27 |         circle.style.boxShadow = 'none';
28 |     }
29 | }
30 | 
31 | 
32 | // slowly calculates the fibonacci number
33 | var fib = function(num) {
34 |     var result = 0;
35 |     if (num < 2) {
36 |         result = num;
37 |     } else {
38 |         result = fib(num-1) + fib(num-2);
39 |     }
40 | 
41 |     return result;
42 | }
43 | 
44 | 
45 | var arg = 40;  // fibonacci number argument
46 | 
47 | // starts local calculation
48 | var calculateLocal = function() {
49 |     var output = document.getElementById('outputLocal');
50 | 
51 |     output.innerHTML = '';
52 |     highlight(true);
53 | 
54 |     setTimeout(
55 |         function() {
56 |             var result = fib(arg);
57 |             output.innerHTML = result;
58 |             highlight(false);
59 |         }, 100
60 |     );
61 | }
62 | 
63 | // starts calculation in the plugin
64 | var calculatePlugin = function() {
65 |     var output = document.getElementById('outputPlugin');
66 | 
67 |     output.innerHTML = '';
68 |     highlight(true);
69 | 
70 |     var cb = function(result) {
71 |         output.innerHTML = result;
72 |         highlight(false);
73 |     }
74 | 
75 |     plugin.remote.fib(arg, cb);
76 | }
77 | 
78 | 
79 | // initialize everything
80 | var start = function() {
81 |     document.getElementById('btnLocal').onclick = calculateLocal;
82 |     document.getElementById('btnPlugin').onclick = calculatePlugin;
83 | }
84 | 
85 | var scripts = document.getElementsByTagName('script');
86 | var path = scripts[scripts.length-1].src
87 |     .split('/')
88 |     .slice(0, -1)
89 |     .join('/')+'/';
90 | 
91 | var plugin = new jailed.Plugin(path+'plugin.js');
92 | plugin.whenConnected(start);
93 | 
94 | 


--------------------------------------------------------------------------------
/lib/_pluginCore.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /**
 3 |  * Core plugin script loaded into the plugin process/thread.
 4 |  * 
 5 |  * Initializes the plugin-site API global methods.
 6 |  */
 7 | 
 8 | (function(){
 9 |      
10 |     // localize
11 |     var site = new JailedSite(connection);
12 |     delete JailedSite;
13 |     delete connection;
14 |      
15 |     site.onGetInterface(function(){
16 |         launchConnected();
17 |     });
18 |      
19 |     site.onRemoteUpdate(function(){
20 |         application.remote = site.getRemote();
21 |     });
22 |      
23 |      
24 | 
25 |     /**
26 |      * Simplified clone of Whenable instance (the object can not be
27 |      * placed into a shared script, because the main library needs it
28 |      * before the additional scripts may load)
29 |      */
30 |     var connected = false;
31 |     var connectedHandlers = [];
32 |      
33 |     var launchConnected = function() {
34 |         if (!connected) {
35 |             connected = true;
36 | 
37 |             var handler;
38 |             while(handler = connectedHandlers.pop()) {
39 |                 handler();
40 |             }
41 |         }
42 |     }
43 |      
44 |     var checkHandler = function(handler){
45 |         var type = typeof handler;
46 |         if (type != 'function') {
47 |             var msg =
48 |                 'A function may only be subsribed to the event, '
49 |                 + type
50 |                 + ' was provided instead'
51 |             throw new Error(msg);
52 |         }
53 | 
54 |         return handler;
55 |     }
56 |     
57 |      
58 |     /**
59 |      * Sets a function executed after the connection to the
60 |      * application is estaplished, and the initial interface-exchange
61 |      * messaging is completed
62 |      * 
63 |      * @param {Function} handler to be called upon initialization
64 |      */
65 |     application.whenConnected = function(handler) {
66 |         handler = checkHandler(handler);
67 |         if (connected) {
68 |             handler();
69 |         } else {
70 |             connectedHandlers.push(handler);
71 |         }
72 |     }
73 | 
74 | 
75 |     /**
76 |      * Sets the plugin interface available to the application
77 |      * 
78 |      * @param {Object} _interface to set
79 |      */
80 |     application.setInterface = function(_interface) {
81 |         site.setInterface(_interface);
82 |     }
83 | 
84 |  
85 |  
86 |     /**
87 |      * Disconnects the plugin from the application (sending
88 |      * notification message) and destroys itself
89 |      */
90 |     application.disconnect = function(_interface) {
91 |         site.disconnect();
92 |     }
93 | 
94 | })();
95 | 
96 | 


--------------------------------------------------------------------------------
/demos/web/process/index.html:
--------------------------------------------------------------------------------
 1 |  <html>
 2 |   <head>
 3 |     <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 4 |     <title>Data processing demo</title>
 5 |     <script type="text/javascript" src="../../../lib/jailed.js"></script>
 6 |     <link rel="stylesheet" type="text/css" href="style.css" />
 7 |     <script type="text/javascript" src="intence.js"></script>
 8 | 
 9 |   </head>
10 |   <body>
11 |     <div class=centered>
12 |       <div class=rel>
13 |         <div class=main>
14 |           <div class=input_block>
15 |             <div class=label>Input:</div>
16 |             <div class=data id=input_data></div>
17 |             <div class=button id=button_regen_input></div>
18 |           </div>
19 | 
20 |           <div class=code_block>
21 |             <div class=label>Processing code:</div>
22 |             <div class="code intence" id=code contenteditable=true scrollImg=scroll.png></div>
23 |           </div>
24 | 
25 |           <div class=process_block>
26 |             <div class=button id=button_process>Process</div>
27 |           </div>
28 | 
29 |           <div class=output_block>
30 |             <div class=label>Output:</div>
31 |             <div class=data id=output_data></div>
32 |           </div>
33 | 
34 |           <div class=hpad></div>
35 | 
36 |           <div class=link_block>
37 |             <div class=link_label>Demo source code:</div>
38 |             <div class=link>
39 |               <a href='https://github.com/asvd/jailed/tree/master/demos/web/process/'>
40 |                 https://github.com/asvd/jailed/tree/master/demos/web/process/
41 |               </a>
42 |             </div>
43 |           </div>
44 | 
45 |           <div class=link_block>
46 |             <div class=link_label>Scrolling indicator:</div>
47 |             <div class=link>
48 |               <a href='https://asvd.github.com/intence/'>
49 |                 https://asvd.github.com/intence/
50 |               </a>
51 |             </div>
52 |           </div>
53 | 
54 | 
55 |         </div>
56 | 
57 |         <div class=annotation>
58 |           <h3>data processing</h3>
59 | 
60 |           The input data is shipped by the application. User-submitted
61 |           code for processing the&nbsp;data is evaluated in
62 |           a&nbsp;Plugin created with
63 |           the <a href="https://github.com/asvd/jailed">Jailed</a>
64 |           library. The code is executed in a sandboxed iframe in order
65 |           to prevent accessing the main application.
66 |         </div>
67 | 
68 | 
69 |       </div>
70 |     </div>
71 | 
72 |     <script type="text/javascript" src="application.js"></script>
73 |   </body>
74 | </html>
75 | 
76 | 
77 | 


--------------------------------------------------------------------------------
/demos/node/fs/plugin.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /**
  3 |  * A Plugin code, executed within a restricted subprocess and may only
  4 |  * perform the methods explicitly exported by the main aplication
  5 |  * (available at application.remote)
  6 |  */
  7 | 
  8 | var timeout = 3;
  9 | var timeoutMsec = timeout*1000;
 10 | var timeoutMsg = 'in '+timeout+' seconds';
 11 | var backup = '';
 12 | 
 13 | 
 14 | // functions order nearly corresponds to the execution sequence
 15 | 
 16 | var start = function() {
 17 |     application.remote.readLog(displayLog, reportNoLog);
 18 | }
 19 | 
 20 | 
 21 | var reportNoLog = function() {
 22 |     application.remote.print(
 23 |         'No log file found, '+
 24 |         'will create a new one '+timeoutMsg
 25 |     );
 26 | 
 27 |     setTimeout(createLog, timeoutMsec);
 28 | }
 29 | 
 30 | 
 31 | var displayLog = function(content) {
 32 |     var message =
 33 |         '=== Logfile content start: ===\n\n' +
 34 |         content +
 35 |         '\n=== Logfile content end ===\n';
 36 | 
 37 |     application.remote.print(message);
 38 |     backup = content;
 39 | 
 40 |     application.remote.print(
 41 |         'Logfile will be removed '+timeoutMsg
 42 |     );
 43 | 
 44 |     setTimeout(removeLog, timeoutMsec);
 45 | }
 46 | 
 47 | 
 48 | var removeLog = function() {
 49 |     application.remote.print('Removing logfile...');
 50 |     application.remote.deleteLog(reportRemove, createLog);
 51 | }
 52 | 
 53 | 
 54 | var reportRemove = function() {
 55 |     application.remote.print(
 56 |         'Logfile removed! Will be recreated '+timeoutMsg
 57 |     );
 58 | 
 59 |     setTimeout(createLog, timeoutMsec);
 60 | }
 61 | 
 62 | 
 63 | var createLog = function() {
 64 |     application.remote.print('Creating an empty log file');
 65 |     application.remote.createLog(reportCreate, finalize);
 66 | }
 67 | 
 68 | 
 69 | var reportCreate = function() {
 70 |     application.remote.print(
 71 |         'Empty logfile created, '+
 72 |         'will be filled with content '+timeoutMsg
 73 |     );
 74 | 
 75 |     setTimeout(writeLog, timeoutMsec);
 76 | }
 77 | 
 78 | 
 79 | var writeLog = function() {
 80 |     application.remote.print(
 81 |         'Writing the old content into the log file '+
 82 |             'along with a new message added'
 83 |     );
 84 |     var message = 'New message added by the plugin on ' +
 85 |         (new Date).toString();
 86 |     var text = backup + message + '\n';
 87 |     application.remote.updateLog(text, reportWrite, finalize);
 88 | }
 89 | 
 90 | 
 91 | var reportWrite = function() {
 92 |     application.remote.print('Logfile updated');
 93 |     finalize();
 94 | }
 95 | 
 96 | 
 97 | var finalize = function() {
 98 |     application.remote.print('Plugin finished');
 99 |     application.disconnect();
100 | }
101 | 
102 | 
103 | start();
104 | 
105 | 


--------------------------------------------------------------------------------
/demos/web/circle/style.css:
--------------------------------------------------------------------------------
  1 | body {
  2 |     background-color: #112233;
  3 |     color: #aabbcc;
  4 |     font-family: sans;
  5 |     font-size: 14px;
  6 |     line-height: 22px;
  7 |     cursor: default;
  8 | }
  9 | 
 10 | 
 11 | .rel {
 12 |     position: relative;
 13 |     padding: 0px;
 14 | }
 15 | 
 16 | 
 17 | h3 {
 18 |     position: absolute;
 19 |     width: 800px;
 20 |     height: 100px;
 21 |     left: 10px;
 22 |     top: 20px;
 23 |     text-align: center;
 24 |     color: #aabbcc;
 25 |     font-family: sans;
 26 |     font-variant: small-caps;
 27 | #    font-size: 20px;
 28 | }
 29 | 
 30 | .centered {
 31 |     width: 800px;
 32 |     padding: 0px;
 33 |     height: 500px;
 34 |     display: block;
 35 |     margin-left: auto;
 36 |     margin-right: auto;
 37 | }
 38 | 
 39 | .circle {
 40 |     position: absolute;
 41 |     width : 30px;
 42 |     height : 30px;
 43 |     top : 110px;
 44 |     left: 385px;
 45 |     border: 1px solid #556677;
 46 |     border-radius: 20px;
 47 | }
 48 | 
 49 | .output {
 50 |     position: absolute;
 51 |     font-family: mono;
 52 |     font-size: 10px;
 53 |     color: #667788;
 54 |     top: 200px;
 55 |     width : 200px;
 56 | }
 57 | 
 58 | .left .output {
 59 |     left: 150px;
 60 |     text-align: right;
 61 | }
 62 | 
 63 | .right .output {
 64 |     left: 450px;
 65 |     text-align: left;
 66 | }
 67 | 
 68 | 
 69 | .separator {
 70 |     position: absolute;
 71 |     background-color:#223344;
 72 |     width: 1px;
 73 |     height: 250px;
 74 |     top: 200px;
 75 |     left: 400;
 76 | }
 77 | 
 78 | .links {
 79 |     position: absolute;
 80 |     width: 800px;
 81 |     height: 50px;
 82 |     top: 500px;
 83 |     text-align: center;
 84 |     font-size: 11px;
 85 | }
 86 | 
 87 | .button {
 88 |     position: absolute;
 89 |     padding-top: 5px;
 90 |     padding-bottom: 1px;
 91 |     width: 200px;
 92 |     height: 25px;
 93 |     text-align: center;
 94 |     background-color: #112233;
 95 |     color: #aabbcc;
 96 |     cursor: pointer;
 97 |     font-family: sans;
 98 |     border: 1px solid #556677;
 99 |     border-radius: 2px;
100 |     top : 220px;
101 | }
102 | 
103 | .button:hover {
104 |     background-color: #223344;
105 |     color: #ddeeff;
106 | }
107 | 
108 | .button:active {
109 |     background-color: #334455;
110 |     box-shadow: 0px 0px 3px 0px #556677;
111 |     border: 1px solid #99AABB;
112 |     cursor: default;
113 |     color: #ccddee;
114 | }
115 | 
116 | 
117 | .left .button {
118 |     left: 150px;
119 | }
120 | 
121 | .right .button {
122 |     left: 450px;
123 | }
124 | 
125 | .text {
126 |     position: absolute;
127 |     width: 250px;
128 |     height: 300px;
129 |     top: 270px;
130 | }
131 | 
132 | .left .text {
133 |     left: 100px;
134 |     text-align: right;
135 | }
136 | 
137 | .right .text{
138 |     left: 450px;
139 | }
140 | 
141 | 
142 | .text h3 {
143 | }
144 | 
145 | a {
146 |     color: #48D7E9;
147 |     text-shadow: 0px 0px 3px #133153;
148 | }
149 | 
150 | a:hover {
151 |     color: #72EDFD;
152 |     text-shadow: 0px 0px 8px #3F638B;
153 | }
154 | 
155 | 
156 | 


--------------------------------------------------------------------------------
/lib/_pluginWebWorker.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /**
  3 |  * Contains the routines loaded by the plugin Worker under web-browser.
  4 |  * 
  5 |  * Initializes the web environment version of the platform-dependent
  6 |  * connection object for the plugin site
  7 |  */
  8 | 
  9 | self.application = {};
 10 | self.connection = {};
 11 | 
 12 | 
 13 | (function(){
 14 |      
 15 |     /**
 16 |      * Event lisener for the plugin message
 17 |      */
 18 |     self.addEventListener('message', function(e){
 19 |         var m = e.data.data;
 20 |         switch (m.type) {
 21 |         case 'import':
 22 |         case 'importJailed':  // already jailed in the iframe
 23 |             importScript(m.url);
 24 |             break;
 25 |         case 'execute':
 26 |             execute(m.code);
 27 |             break;
 28 |         case 'message':
 29 |             conn._messageHandler(m.data);
 30 |             break;
 31 |         }
 32 |      });
 33 | 
 34 | 
 35 |     /**
 36 |      * Loads and executes the JavaScript file with the given url
 37 |      *
 38 |      * @param {String} url to load
 39 |      */
 40 |     var importScript = function(url) {
 41 |         var error = null;
 42 | 
 43 |         // importScripts does not throw an exception in old webkits
 44 |         // (Opera 15.0), but we can determine a failure by the
 45 |         // returned value which must be undefined in case of success
 46 |         var returned = true;
 47 |         try {
 48 |             returned = importScripts(url);
 49 |         } catch (e) {
 50 |             error = e;
 51 |         }
 52 | 
 53 |         if (error || typeof returned != 'undefined') {
 54 |             self.postMessage({type: 'importFailure', url: url});
 55 |             if (error) {
 56 |                 throw error;
 57 |             }
 58 |         } else {
 59 |            self.postMessage({type: 'importSuccess', url: url});
 60 |         }
 61 | 
 62 |     }
 63 | 
 64 | 
 65 |     /**
 66 |      * Executes the given code in a jailed environment. For web
 67 |      * implementation, we're already jailed in the iframe and the
 68 |      * worker, so simply eval()
 69 |      * 
 70 |      * @param {String} code code to execute
 71 |      */
 72 |     var execute = function(code) {
 73 |         try {
 74 |             eval(code);
 75 |         } catch (e) {
 76 |             self.postMessage({type: 'executeFailure'});
 77 |             throw e;
 78 |         }
 79 | 
 80 |         self.postMessage({type: 'executeSuccess'});
 81 |     }
 82 | 
 83 |      
 84 |     /**
 85 |      * Connection object provided to the JailedSite constructor,
 86 |      * plugin site implementation for the web-based environment.
 87 |      * Global will be then cleared to prevent exposure into the
 88 |      * Worker, so we put this local connection object into a closure
 89 |      */
 90 |     var conn = {
 91 |         disconnect: function(){ self.close(); },
 92 |         send: function(data) {
 93 |             self.postMessage({type: 'message', data: data});
 94 |         },
 95 |         onMessage: function(h){ conn._messageHandler = h; },
 96 |         _messageHandler: function(){},
 97 |         onDisconnect: function() {}
 98 |     };
 99 |      
100 |     connection = conn;
101 |      
102 | })();
103 | 
104 | 


--------------------------------------------------------------------------------
/demos/web/process/style.css:
--------------------------------------------------------------------------------
  1 | 
  2 | body {
  3 |     background-color: #112233;
  4 |     color: #aabbcc;
  5 |     font-family: sans;
  6 |     font-size: 14px;
  7 |     line-height: 21px;
  8 |     cursor: default;
  9 | }
 10 | 
 11 | 
 12 | a {
 13 |     color: #48D7E9;
 14 |     text-shadow: 0px 0px 3px #133153;
 15 | }
 16 | 
 17 | a:hover {
 18 |     color: #72EDFD;
 19 |     text-shadow: 0px 0px 8px #3F638B;
 20 | }
 21 | 
 22 | .hpad {
 23 |     height : 15px;
 24 | }
 25 | 
 26 | .rel {
 27 |     position: relative;
 28 |     padding: 0px;
 29 | }
 30 | 
 31 | .centered {
 32 |     display: block;
 33 |     width: 900px;
 34 |     height: 400px;
 35 |     margin-left: auto;
 36 |     margin-right: auto;
 37 |     padding: 0px;
 38 | }
 39 | 
 40 | .annotation {
 41 |     position: absolute;
 42 |     left: 545px;
 43 |     top: 25px;
 44 |     width: 200px;
 45 |     height: 400px;
 46 | }
 47 | 
 48 | .annotation h3 {
 49 |     margin-top: 0px;
 50 |     font-variant: small-caps;
 51 | }
 52 | 
 53 | .label {
 54 |     font-variant: small-caps;
 55 |     text-align: right;
 56 |     width: 150px;
 57 | }
 58 | 
 59 | .link_block {
 60 |     position : relative;
 61 | }
 62 | 
 63 | .link_label {
 64 |     font-variant: small-caps;
 65 |     font-size : 12px;
 66 |     text-align: right;
 67 |     height : 20px;
 68 |     width: 150px;
 69 | }
 70 | 
 71 | .link {
 72 |     position:absolute;
 73 |     width: 500px;
 74 |     height : 20px;
 75 |     top : 0px;
 76 |     left: 160px;
 77 |     font-size: 11px;
 78 | }
 79 | 
 80 | 
 81 | .main {
 82 |     position: absolute;
 83 |     padding-top: 6px;
 84 |     left: 0;
 85 |     top: 25px;
 86 |     width : 550px;
 87 |     height : 400px;
 88 | }
 89 | 
 90 | 
 91 | .input_block {
 92 |     position:relative;
 93 |     width: 500px;
 94 |     height : 30px;
 95 | }
 96 | 
 97 | .code_block {
 98 |     position:relative;
 99 |     width: 500px;
100 |     height : 200px;
101 | }
102 | 
103 | .process_block {
104 |     position:relative;
105 |     margin-top: 10px;
106 |     margin-bottom: 10px;
107 |     width: 500px;
108 |     height : 30px;
109 | }
110 | 
111 | .output_block {
112 |     position:relative;
113 |     width: 500px;
114 |     height : 30px;
115 | }
116 | 
117 | 
118 | .code {
119 |     position: absolute;
120 |     padding: 5px;
121 |     top: 0px;
122 |     left: 160px;
123 |     height: 200px;
124 |     width: 360px;
125 |     background-color: #051627;
126 |     background-image: url('bg.png');
127 |     border: 1px solid #365666;
128 |     color: #B4EEF5;
129 |     font-family: monospace;
130 |     font-size: 12px;
131 |     line-height: 18px;
132 |     overflow: auto;
133 |     white-space: pre;
134 |     -moz-appearance:none;
135 |     outline:0px none transparent;
136 |     border : 1px solid #365666;
137 | }
138 | 
139 | .code:focus {
140 |     outline: 0;
141 | }
142 | 
143 | .data {
144 |     position: absolute;
145 |     height: 22px;
146 |     top: 0px;
147 |     left: 160px;
148 |     color: #B4EEF5;
149 |     font-family: monospace;
150 |     background-color: #06192B;
151 |     padding-left: 5px;
152 | }
153 | 
154 | #input_data {
155 |     width: 330px;
156 | }
157 | 
158 | #output_data {
159 |     width: 360px;
160 | }
161 | 
162 | .button {
163 |     font-variant: small-caps;
164 |     text-align: center;
165 | }
166 | 
167 | .button:hover {
168 |     background-color: #172839 !important;
169 | }
170 | 
171 | .button:active {
172 |     background-color: #0B1C2E !important;
173 | }
174 | 
175 | #button_regen_input {
176 |     position: absolute;
177 |     top: 0px;
178 |     left: 500px;
179 |     width : 22px;
180 |     height: 22px;
181 |     background-image: url('refresh.svg');
182 |     background-repeat: no-repeat;
183 | }
184 | 
185 | #button_process {
186 |     position: absolute;
187 |     top: 5px;
188 |     left: 286px;
189 |     width : 130px;
190 |     height: 22px;
191 |     border : 1px solid #365666;
192 |     background-color: #06192B;
193 | }
194 | 
195 | .error {
196 |     color : #E67C60;
197 | }
198 | 
199 | .loading {
200 |     padding-top: 3px;
201 |     opacity: .7;
202 | }
203 | 
204 | 
205 | 


--------------------------------------------------------------------------------
/lib/_frame.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /**
  3 |  * Contains the code executed in the sandboxed frame under web-browser
  4 |  * 
  5 |  * Tries to create a Web-Worker inside the frame and set up the
  6 |  * communication between the worker and the parent window. Some
  7 |  * browsers restrict creating a worker inside a sandboxed iframe - if
  8 |  * this happens, the plugin initialized right inside the frame (in the
  9 |  * same thread)
 10 |  */
 11 | 
 12 | 
 13 | var scripts = document.getElementsByTagName('script');
 14 | var thisScript = scripts[scripts.length-1];
 15 | var parentNode = thisScript.parentNode;
 16 | var __jailed__path__ = thisScript.src
 17 |     .split('?')[0]
 18 |     .split('/')
 19 |     .slice(0, -1)
 20 |     .join('/')+'/';
 21 | 
 22 | 
 23 | /**
 24 |  * Initializes the plugin inside a webworker. May throw an exception
 25 |  * in case this was not permitted by the browser.
 26 |  */
 27 | var initWebworkerPlugin = function() {
 28 |     // creating worker as a blob enables import of local files
 29 |     var blobCode = [
 30 |       ' self.addEventListener("message", function(m){   ',
 31 |       '     if (m.data.type == "initImport") {          ',
 32 |       '         importScripts(m.data.url);              ',
 33 |       '         self.postMessage({                      ',
 34 |       '             type : "initialized",               ',
 35 |       '             dedicatedThread : true              ',
 36 |       '         });                                     ',
 37 |       '     }                                           ',
 38 |       ' });                                             '
 39 |     ].join('\n');
 40 | 
 41 |     var blobUrl = window.URL.createObjectURL(
 42 |         new Blob([blobCode])
 43 |     );
 44 | 
 45 |     var worker = new Worker(blobUrl);
 46 | 
 47 |     // telling worker to load _pluginWebWorker.js (see blob code above)
 48 |     worker.postMessage({
 49 |         type: 'initImport',
 50 |         url: __jailed__path__ + '_pluginWebWorker.js'
 51 |     });
 52 | 
 53 | 
 54 |     // mixed content warning in Chrome silently skips worker
 55 |     // initialization without exception, handling this with timeout
 56 |     var fallbackTimeout = setTimeout(function() {
 57 |         worker.terminate();
 58 |         initIframePlugin();
 59 |     }, 300);
 60 | 
 61 |     // forwarding messages between the worker and parent window
 62 |     worker.addEventListener('message', function(m) {
 63 |         if (m.data.type == 'initialized') {
 64 |             clearTimeout(fallbackTimeout);
 65 |         }
 66 | 
 67 |         parent.postMessage(m.data, '*');
 68 |     });
 69 | 
 70 |     window.addEventListener('message', function(m) {
 71 |         worker.postMessage(m.data);
 72 |     });
 73 | }
 74 | 
 75 | 
 76 | /**
 77 |  * Creates plugin right in this iframe
 78 |  */
 79 | var initIframePlugin = function() {
 80 |     // loads additional script into the frame
 81 |     window.loadScript = function(path, sCb, fCb) {
 82 |         var script = document.createElement('script');
 83 |         script.src = path;
 84 | 
 85 |         var clear = function() {
 86 |             script.onload = null;
 87 |             script.onerror = null;
 88 |             script.onreadystatechange = null;
 89 |             script.parentNode.removeChild(script);
 90 |             currentErrorHandler = function(){};
 91 |         }
 92 | 
 93 |         var success = function() {
 94 |             clear();
 95 |             sCb();
 96 |         }
 97 | 
 98 |         var failure = function() {
 99 |             clear();
100 |             fCb();
101 |         }
102 | 
103 |         currentErrorHandler = failure;
104 | 
105 |         script.onerror = failure;
106 |         script.onload = success;
107 |         script.onreadystatechange = function() {
108 |             var state = script.readyState;
109 |             if (state==='loaded' || state==='complete') {
110 |                 success();
111 |             }
112 |         }
113 | 
114 |         parentNode.appendChild(script);
115 |     }
116 | 
117 |         
118 |     // handles script loading error
119 |     // (assuming scripts are loaded one by one in the iframe)
120 |     var currentErrorHandler = function(){};
121 |     window.addEventListener('error', function(message) {
122 |         currentErrorHandler();
123 |     });
124 | 
125 | 
126 |     window.loadScript(
127 |         __jailed__path__ + '_pluginWebIframe.js',
128 |         function(){}, function(){}
129 |     );
130 | }
131 | 
132 | 
133 | 
134 | try {
135 |     initWebworkerPlugin();
136 | } catch(e) {
137 |     initIframePlugin();
138 | }
139 | 
140 | 


--------------------------------------------------------------------------------
/demos/web/console/style.css:
--------------------------------------------------------------------------------
  1 | 
  2 | body {
  3 |     background-color: #112233;
  4 |     color: #aabbcc;
  5 |     font-family: sans;
  6 |     font-size: 14px;
  7 |     line-height: 21px;
  8 |     cursor: default;
  9 | }
 10 | 
 11 | .rel {
 12 |     position: relative;
 13 |     padding: 0px;
 14 | }
 15 | 
 16 | .centered {
 17 |     display: block;
 18 |     width: 900px;
 19 |     height: 400px;
 20 |     margin-left: auto;
 21 |     margin-right: auto;
 22 |     padding: 0px;
 23 | }
 24 | 
 25 | .border {
 26 |     position: absolute;
 27 |     left: 16px;
 28 |     top: 40px;
 29 |     width: 500px;
 30 |     height: 275px;
 31 |     background-color: #051627;
 32 |     background-image: url('bg.png');
 33 |     border: 1px solid #334455;
 34 |     color: #aabbcc;
 35 |     font-family: monospace;
 36 |     transition: border .3s;
 37 | }
 38 | 
 39 | .border:hover {
 40 |     transition: box-shadow .3s, border .3s;
 41 |     box-shadow: inset 0px 0px 15px 0px rgba(0, 0, 0, .1);
 42 | }
 43 | 
 44 | .border:active {
 45 |     transition: border 0s;
 46 |     border: 1px solid #445566;
 47 | }
 48 | 
 49 | .text {
 50 |     position: absolute;
 51 |     left: 545px;
 52 |     top: 25px;
 53 |     width: 300px;
 54 |     height: 400px;
 55 | }
 56 | 
 57 | .text h3 {
 58 |     font-variant: small-caps;
 59 | }
 60 | 
 61 | .links {
 62 |     position: absolute;
 63 |     width: 900;
 64 |     height: 50px;
 65 |     top: 350;
 66 |     left: 20px;
 67 |     font-size: 11px;
 68 | }
 69 | 
 70 | 
 71 | a {
 72 |     color: #48D7E9;
 73 |     text-shadow: 0px 0px 3px #133153;
 74 | }
 75 | 
 76 | a:hover {
 77 |     color: #72EDFD;
 78 |     text-shadow: 0px 0px 8px #3F638B;
 79 | }
 80 | 
 81 | .code {
 82 |     font: 10pt Bitstream Vera Sans Mono, monospace;
 83 |     color: #7EC3DD;
 84 |     text-shadow: 0px 0px 5px rgba(145, 194, 221, 0.26);
 85 | }
 86 | 
 87 | .terminalWrap {
 88 |     left: 0px;
 89 |     top: 0px;
 90 |     width: 500px;
 91 |     height: 253px;
 92 |     padding: 0px;
 93 |     overflow: hidden;
 94 |     font-family: mono;
 95 |     font-size: 14px;
 96 | }
 97 | 
 98 | .shadow {
 99 |     position: absolute;
100 |     left: 0px;
101 |     top:0px;
102 |     width: 500px;
103 |     height: 50px;
104 |     background: linear-gradient(
105 |         to bottom,
106 |         rgba(2,19,35,.8) 0%,
107 |         rgba(2,19,35,0) 100%
108 |     );
109 | 
110 | }
111 | 
112 | .indicator {
113 |     position: absolute;
114 |     left: 0px;
115 |     top: 253px;
116 |     width: 500px;
117 |     height: 2px;
118 |     padding-top: 6px;
119 |     background-color: #152637;
120 |     padding: 0px;
121 | }
122 | 
123 | 
124 | 
125 | .inv {
126 |     position: absolute;
127 |     left: 0px;
128 |     top:295px;
129 |     color: #556677;
130 |     font-family: monospace;
131 |     font-size:18px;
132 |     cursor: default;
133 | }
134 | 
135 | .command {
136 |     position: absolute;
137 |     left: 0px;
138 |     top: 255px;
139 |     width: 500px;
140 |     height: 20px;
141 |     padding: 0px;
142 |     overflow: hidden;
143 |     font-family: monospace;
144 | }
145 | 
146 | .commandTextAnimated {
147 |     position: absolute;
148 |     left: 2px;
149 |     top: -2px;
150 |     width: 497px;
151 |     height: 20px;
152 |     padding: 0px;
153 |     color: #aabbcc;
154 |     text-shadow: 0px 0px 4px rgba(160, 196, 228, 0.1);
155 |     font-family: mono;
156 |     font-size: 14px;
157 |     transition: top .15s, opacity .1s;
158 |     margin: 2px 0px 0px 0px;
159 | }
160 | 
161 | .commandText {
162 |     position: absolute;
163 |     left: 2px;
164 |     top: 0px;
165 |     width: 497px;
166 |     height: 20px;
167 |     padding: 0px;
168 |     color: #aabbcc;
169 |     text-shadow: 0px 0px 4px rgba(160, 196, 228, 0.1);
170 |     font-family: mono;
171 |     font-size: 14px;
172 |     margin: 0px;
173 | }
174 | 
175 | 
176 | .command input {
177 |     position: absolute;
178 |     background-color: rgba(0,0,0,0);
179 |     border: none;
180 |     outline: none;
181 | }
182 | 
183 | .terminal {
184 |     position: absolute;
185 |     top: 253px;
186 |     left: 0px;
187 |     width : 495px;
188 |     padding-left: 2px;
189 |     cursor: default;
190 | }
191 | 
192 | .separator {
193 |     width: 497px;
194 |     height: 0px;
195 |     float: left;
196 | }
197 | 
198 | .input {
199 |     float: left;
200 |     overflow: hidden;
201 |     max-width: 496px;
202 |     color: #aabbcc;
203 | }
204 | 
205 | .output {
206 |     padding-left: 10px;
207 |     float: right;
208 |     color: #627A93;
209 | }
210 | 
211 | .message {
212 |     padding-left: 10px;
213 |     float: right;
214 |     color: #355D87;
215 | }
216 | 
217 | 


--------------------------------------------------------------------------------
/demos/web/process/refresh.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 2 | <svg
 3 |    xmlns:dc="http://purl.org/dc/elements/1.1/"
 4 |    xmlns:cc="http://creativecommons.org/ns#"
 5 |    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 6 |    xmlns:svg="http://www.w3.org/2000/svg"
 7 |    xmlns="http://www.w3.org/2000/svg"
 8 |    xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
 9 |    xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
10 |    id="Layer_1"
11 |    style="enable-background:new 0 0 512 512;"
12 |    version="1.1"
13 |    viewBox="0 0 512 512"
14 |    xml:space="preserve"
15 |    inkscape:version="0.48.4 r9939"
16 |    width="100%"
17 |    height="100%"
18 |    sodipodi:docname="refresh.svg"
19 |    inkscape:export-filename="/home/xpostman/projects/code/asvd.github.io/jailed/demos/web/process/refresh.png"
20 |    inkscape:export-xdpi="90"
21 |    inkscape:export-ydpi="90"><metadata
22 |      id="metadata3047"><rdf:RDF><cc:Work
23 |          rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
24 |            rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
25 |      id="defs3045" /><sodipodi:namedview
26 |      pagecolor="#ffffff"
27 |      bordercolor="#666666"
28 |      borderopacity="1"
29 |      objecttolerance="10"
30 |      gridtolerance="10"
31 |      guidetolerance="10"
32 |      inkscape:pageopacity="0"
33 |      inkscape:pageshadow="2"
34 |      inkscape:window-width="1920"
35 |      inkscape:window-height="1005"
36 |      id="namedview3043"
37 |      showgrid="false"
38 |      inkscape:zoom="0.4609375"
39 |      inkscape:cx="-279.86441"
40 |      inkscape:cy="169.22034"
41 |      inkscape:window-x="-2"
42 |      inkscape:window-y="-3"
43 |      inkscape:window-maximized="1"
44 |      inkscape:current-layer="Layer_1" /><style
45 |      type="text/css"
46 |      id="style3037">
47 | 	.st0{fill:#3A3A3A;}
48 | </style><g
49 |      id="g3039"
50 |      style="fill-opacity:1;fill:#aabbcc"><path
51 |        class="st0"
52 |        d="M458.2,254c0-10.3-8.3-18.6-18.7-18.6c-8.6,0-15.9,5.9-18,13.8l0,0c0,0.1-0.1,0.3-0.1,0.6   c0,0.2-0.1,0.4-0.1,0.6c-0.5,2.3-1.7,6.6-1.9,7.6c-1.8,7.6-3.8,15-6.6,22.1c-5.4,14.2-12.8,27.2-21.4,38.5l-1.6,2.1l-1.7,2   c-1.1,1.3-2.2,2.7-3.4,4c-2.4,2.5-4.6,5.1-7,7.5c-4.7,4.8-9.8,9.1-14.8,13c-10.2,7.7-20.5,13.8-30.6,18.2   c-10,4.4-19.5,7.3-28.1,9.1c-2.1,0.4-4.2,0.9-6.2,1.2c-2,0.3-3.9,0.6-5.8,0.9c-1.9,0.2-3.7,0.4-5.4,0.6c-0.9,0.1-1.7,0.2-2.5,0.2   c-0.8,0-1.6,0.1-2.4,0.1c-1.5,0.1-3,0.2-4.4,0.2c-1.3,0-2.4,0-3.5,0c-1.1,0-2,0-2.9,0c-0.2,0-0.5,0-0.8,0v-26.4   c0-8.9-10.3-13.8-17.2-8.1L245,349c-22.2,15.8-43.2,33.3-62.7,52.4c-6.9,5.7-6.9,16.3,0,21.9l0.4,0.4c19.3,18.8,40,36.1,62,51.8   l8.6,6.1c6.9,5.6,17.2,0.8,17.2-8.1V447c0.3,0,0.6-0.1,0.9-0.1c0.6-0.1,1.1-0.1,2-0.2c1.6-0.2,3.4-0.4,5.3-0.6   c1.9-0.2,4-0.5,6.1-0.8c2-0.4,4.1-0.7,6.4-1.1c1.1-0.2,2.3-0.4,3.4-0.6c1.2-0.2,2.4-0.5,3.6-0.8c2.4-0.6,5-1.1,7.6-1.8   c2.6-0.8,5.4-1.5,8.2-2.4c2.8-0.8,5.7-1.9,8.7-2.9c11.8-4.2,24.8-10.1,37.9-18c13.1-7.9,26.2-18,38.5-30.2   c6.1-6.1,12-12.7,17.5-19.9c2.8-3.5,5.4-7.3,8-11c1.3-1.9,2.5-3.9,3.7-5.8l1.8-2.9l1.7-3c9.3-16.1,16.5-34,21-52.7   c2.3-9.3,3.7-18.9,4.7-28.5c0.2-2.4,0.5-4.9,0.6-7.3C458.2,255.5,458.2,254.7,458.2,254z"
53 |        id="XMLID_1138_"
54 |        style="fill-opacity:1;fill:#aabbcc" /><path
55 |        class="st0"
56 |        d="M53.8,258c0,10.3,8.3,18.6,18.7,18.6c8.6,0,15.9-5.9,18-13.8l0,0c0-0.1,0.1-0.3,0.1-0.6   c0-0.2,0.1-0.4,0.1-0.6c0.5-2.3,1.7-6.6,1.9-7.6c1.8-7.6,3.8-15,6.6-22.1c5.4-14.2,12.8-27.2,21.4-38.5l1.6-2.1l1.7-2   c1.1-1.3,2.2-2.7,3.4-4c2.4-2.5,4.6-5.1,7-7.5c4.7-4.8,9.8-9.1,14.8-13c10.2-7.7,20.5-13.8,30.6-18.2c10-4.4,19.5-7.3,28.1-9.1   c2.1-0.4,4.2-0.9,6.2-1.2c2-0.3,3.9-0.6,5.8-0.9c1.9-0.2,3.7-0.4,5.4-0.6c0.9-0.1,1.7-0.2,2.5-0.2c0.8,0,1.6-0.1,2.4-0.1   c1.5-0.1,3-0.2,4.4-0.2c1.3,0,2.4,0,3.5,0c1.1,0,2,0,2.9,0c0.2,0,0.5,0,0.8,0v26.4c0,8.9,10.3,13.8,17.2,8.1l8.3-5.9   c22.2-15.8,43.2-33.3,62.7-52.4c6.9-5.7,6.9-16.3,0-21.9l-0.4-0.4c-19.3-18.8-40-36.1-62-51.8l-8.6-6.1c-6.9-5.6-17.2-0.8-17.2,8.1   V65c-0.3,0-0.6,0.1-0.9,0.1c-0.6,0.1-1.1,0.1-2,0.2c-1.6,0.2-3.4,0.4-5.3,0.6c-1.9,0.2-4,0.5-6.1,0.8c-2,0.4-4.1,0.7-6.4,1.1   c-1.1,0.2-2.3,0.4-3.4,0.6c-1.2,0.2-2.4,0.5-3.6,0.8c-2.4,0.6-5,1.1-7.6,1.8c-2.6,0.8-5.4,1.5-8.2,2.4c-2.8,0.8-5.7,1.9-8.7,2.9   c-11.8,4.2-24.8,10.1-37.9,18c-13.1,7.9-26.2,18-38.5,30.2c-6.1,6.1-12,12.7-17.5,19.9c-2.8,3.5-5.4,7.3-8,11   c-1.3,1.9-2.5,3.9-3.7,5.8l-1.8,2.9l-1.7,3c-9.3,16.1-16.5,34-21,52.7c-2.3,9.3-3.7,18.9-4.7,28.5c-0.2,2.4-0.5,4.9-0.6,7.3   C53.8,256.5,53.8,257.3,53.8,258z"
57 |        id="XMLID_1202_"
58 |        style="fill-opacity:1;fill:#aabbcc" /></g></svg>


--------------------------------------------------------------------------------
/demos/web/process/application.js:
--------------------------------------------------------------------------------
  1 | var scripts = document.getElementsByTagName('script');
  2 | var path = scripts[scripts.length-1].src
  3 |     .split('/')
  4 |     .slice(0, -1)
  5 |     .join('/')+'/';
  6 | 
  7 | 
  8 | // component shortcuts
  9 | var el = {};
 10 | var list = [
 11 |     'input_data',
 12 |     'output_data',
 13 |     'button_regen_input',
 14 |     'button_process',
 15 |     'code'
 16 | ];
 17 | 
 18 | for (var i = 0; i < list.length; i++){
 19 |     el[list[i]] = document.getElementById(list[i]);
 20 | }
 21 | 
 22 | // generates random input and puts it into input field
 23 | var input;
 24 | function regen_input() {
 25 |     input = [];
 26 |     var len = 10;
 27 |     for (var i = 0; i < len; i++) {
 28 |         input.push(Math.floor(Math.random()*10));
 29 |     }
 30 | 
 31 |     el.input_data.innerHTML = stringify(input);
 32 | }
 33 | 
 34 | // processes the input data using provided code
 35 | function process() {
 36 |     el.output_data.innerHTML = '<img class="loading" src="loading.gif"/>';
 37 |     var code = el.code.innerText;
 38 |     var input = el.input_data.innerText;
 39 | 
 40 |     var plugin =  new jailed.Plugin(path+'plugin.js');
 41 |     var process = function() {
 42 |         var displayResult = function(result) {
 43 |             if (result.error) {
 44 |                 el.output_data.innerHTML =
 45 |                     '<span class="error">'+result.error + '</span>';
 46 |             } else {
 47 |                 el.output_data.innerHTML = stringify(result.output);
 48 |             }
 49 |             plugin.disconnect();
 50 |         }
 51 | 
 52 |         plugin.remote.process(input, code, displayResult);
 53 |     }
 54 | 
 55 |     plugin.whenConnected(process);
 56 | }
 57 | 
 58 | 
 59 | // converts an object into a string
 60 | function stringify(object) {
 61 |     var result;
 62 | 
 63 |     if (typeof object == 'undefined') {
 64 |         result = 'undefined';
 65 |     } else if (object === null) {
 66 |         result = 'null';
 67 |     } else {
 68 |         result = JSON.stringify(object) || object.toString();
 69 |     }
 70 | 
 71 |     return result;
 72 | }
 73 | 
 74 | 
 75 | 
 76 | // removes spaces from the end of the strings
 77 | function trim_tails(string) {
 78 |     var arr = string.split('\n');
 79 | 
 80 |     for (var i = 0; i < arr.length; i++) {
 81 |         arr[i] = arr[i].replace(/[\s\uFEFF\xA0]+$/g, '');
 82 |     }
 83 | 
 84 |     return arr.join('\n');
 85 | }
 86 | 
 87 | // fills the processing code textarea with initial content
 88 | function fill_code() {
 89 |     var code = trim_tails([
 90 |         'function(input) {                                 ',
 91 |         '    // bubble sorting the input array             ',
 92 |         '                                                  ',
 93 |         '    // switches the two elems if needed           ',
 94 |         '    // returns true if switched                   ',
 95 |         '    function switchEls(idx) {                     ',
 96 |         '        var switched = false;                     ',
 97 |         '        if (input[idx] < input[idx-1]) {          ',
 98 |         '            var tmp = input[idx];                 ',
 99 |         '            input[idx] = input[idx-1];            ',
100 |         '            input[idx-1] = tmp;                   ',
101 |         '            switched = true;                      ',
102 |         '        }                                         ',
103 |         '        return switched;                          ',
104 |         '    }                                             ',
105 |         '                                                  ',
106 |         '    var switched;                                 ',
107 |         '    do {                                          ',
108 |         '        switched = false;                         ',
109 |         '        for (var i = 1; i < input.length; i++) {  ',
110 |         '            switched |= switchEls(i);             ',
111 |         '        }                                         ',
112 |         '    } while(switched);                            ',
113 |         '                                                  ',
114 |         '    return input;                                 ',
115 |         '}                                                 ',
116 |         '                                                  ',
117 |         '                                                  '
118 |     ].join('\n'));
119 | 
120 |     el.code.container.innerHTML = code;
121 | }
122 | 
123 | 
124 | function init() {
125 |     el.button_regen_input.onclick = regen_input;
126 |     el.button_process.onclick = process;
127 |     fill_code();
128 |     regen_input();
129 | 
130 |     // caching
131 |     var plugin =  new jailed.Plugin(path+'plugin.js');
132 |     plugin.whenConnected(function(){plugin.disconnect();});
133 | 
134 |     el.code.container.focus();
135 | }
136 | 
137 | window.addEventListener("load", init, false);
138 | 
139 | 
140 | 
141 | 


--------------------------------------------------------------------------------
/demos/web/console/application.js:
--------------------------------------------------------------------------------
  1 | 
  2 | // component shortcuts
  3 | var el = {};
  4 | var list = [
  5 |     'terminalWrap', 'command', 'line', 'terminal', 'indicator'
  6 | ];
  7 | 
  8 | for (var i = 0; i < list.length; i++){
  9 |     el[list[i]] = document.getElementById(list[i]);
 10 | }
 11 | 
 12 | 
 13 | // newer elements template
 14 | var sample = document.createElement('div');
 15 | 
 16 | 
 17 | // command history
 18 | var hist = {
 19 |     _list: [''],
 20 |     _pos: 0,
 21 | 
 22 |     push: function(val) {
 23 |         var last = this._list.length-1;
 24 | 
 25 |         // prevent duplicates
 26 |         if (this._list[last-1] !== val) {
 27 |             this._list[last] = val;
 28 |             this._list.push('');
 29 |         }
 30 | 
 31 |         this._pos = this._list.length-1;
 32 |     },
 33 |     
 34 |     set: function(val) {
 35 |         if (this._pos >= this._list.length-1) {
 36 |             this._list[this._pos] = val;
 37 |         }
 38 |     },
 39 | 
 40 |     next: function() {
 41 |         if (typeof this._list[this._pos+1] != 'undefined') {
 42 |             this._pos++;
 43 |         }
 44 | 
 45 |         return this._list[this._pos];
 46 |     },
 47 | 
 48 |     prev: function() {
 49 |         if (typeof this._list[this._pos-1] != 'undefined') {
 50 |             this._pos--;
 51 |         }
 52 | 
 53 |         return this._list[this._pos];
 54 |     }
 55 | };
 56 | 
 57 | 
 58 | // command line keypress handlers
 59 | el.line.onkeydown = function(e) {
 60 |     switch (e.keyCode) {
 61 |     case 38: // up arrow
 62 |         var val = hist.prev();
 63 |         el.line.value = val;
 64 |         el.line.setSelectionRange(val.length, val.length);
 65 |         e.preventDefault();
 66 |         break;
 67 | 
 68 |     case 40: // down arrow
 69 |         var val = hist.next();
 70 |         el.line.value = val;
 71 |         el.line.setSelectionRange(val.length, val.length);
 72 |         e.preventDefault();
 73 |         break;
 74 | 
 75 |     case 13: // enter
 76 |         var val = el.line.value;
 77 |         if (val) {
 78 |             hist.push(val);
 79 |             el.line.value = '';
 80 |             submit(val);
 81 |         }
 82 |         break;
 83 |     }
 84 | }
 85 | 
 86 | 
 87 | el.line.onkeyup = function(e) {
 88 |     switch (e.keyCode) {
 89 |     case 38: // up arrow
 90 |     case 40: // down arrow
 91 |     case 13: // enter
 92 |         break;
 93 | 
 94 |     default:
 95 |         // update current history entry
 96 |         hist.set(el.line.value);
 97 |         break;
 98 |     }
 99 | }
100 | 
101 | 
102 | // sends the input to the plugin for evaluation
103 | var submit = function(code) {
104 |     animateSubmit(code);
105 | 
106 |     // postpone the evaluation until the plugin is initialized
107 |     plugin.whenConnected(
108 |         function() {
109 |             if (requests == 0) {
110 |                 startLoading();
111 |             }
112 | 
113 |             requests++;
114 |             plugin.remote.run(code);
115 |         }
116 |     );
117 | }
118 | 
119 | 
120 | // animates input submission
121 | var animateSubmit = function(code) {
122 |     var anim = sample.cloneNode(false);
123 |     anim.setAttribute('class', 'commandTextAnimated');
124 |     anim.innerHTML = escape(code);
125 | 
126 |     el.command.appendChild(anim);
127 | 
128 |     anim.offsetHeight;
129 |     anim.style.top = -20;
130 |     anim.style.opacity = .6;
131 | 
132 |     setTimeout(
133 |         function() {
134 |             el.command.removeChild(anim);
135 |         }, 500
136 |     );
137 | 
138 | }
139 | 
140 | 
141 | // prepares the string to be printed on the terminal
142 | var escape = function(msg) {
143 |     return msg.
144 |         replace(/&/g,'&amp;').
145 |         replace(/</g,'&lt;').
146 |         replace(/>/g,'&gt;').
147 |         replace(/\n/g, '<br/>').
148 |         replace(/ /g, '&nbsp;');
149 | }
150 | 
151 | 
152 | // puts the message on the terminal
153 | var print = function(cls, msg) {
154 |     var cmp = sample.cloneNode(false);
155 |     cmp.setAttribute('class', cls);
156 | 
157 |     if (msg) {
158 |         cmp.innerHTML = escape(msg);
159 |     }
160 | 
161 |     el.terminal.appendChild(cmp);
162 |     scroll();
163 | }
164 | 
165 | 
166 | // slides the terminal content to display the newly added message
167 | var scroll = function() {
168 |     el.terminal.offsetHeight;  // redraw
169 |     el.terminal.style.transition = 'top .15s';
170 |     el.terminal.style.top =
171 |         el.terminalWrap.offsetHeight - el.terminal.scrollHeight;
172 | }
173 | 
174 | 
175 | // will restart the plugin if it does not respond
176 | var disconnectTimeout = null;
177 | var startLoading = function() {
178 |     disconnectTimeout = setTimeout(disconnect, 3000);
179 |     el.indicator.offsetHeight;
180 |     el.indicator.style.transition = 'background-color 4s';
181 |     el.indicator.style.backgroundColor = '#839AC2';
182 | }
183 | 
184 | var endLoading = function() {
185 |     clearTimeout(disconnectTimeout);
186 |     el.indicator.offsetHeight;
187 |     el.indicator.style.transition = 'background-color .3s';
188 |     el.indicator.style.backgroundColor = '#152637';
189 | }
190 | 
191 | var disconnect = function() {
192 |     plugin.disconnect();
193 | }
194 | 
195 | 
196 | // interface provided to the plugin
197 | var api = {
198 |     output: function(data) {
199 |         if (!--requests) {
200 |             endLoading();
201 |         }
202 | 
203 |         print('separator');
204 |         print('input', data.input);
205 |         if (data.error) {
206 |             print('message', data.error);
207 |         } else {
208 |             print('output', data.output);
209 |         }
210 |     }
211 | };
212 | 
213 | 
214 | // obtaining absolute path of this script
215 | var scripts = document.getElementsByTagName('script');
216 | var path = scripts[scripts.length-1].src
217 |     .split('?')[0]
218 |     .split('/')
219 |     .slice(0, -1)
220 |     .join('/')+'/';
221 | 
222 | 
223 | 
224 | var requests;
225 | 
226 | // (re)initializes the plugin
227 | var reset = function() {
228 |     requests = 0;
229 |     plugin = new jailed.Plugin(path+'plugin.js', api);
230 |     plugin.whenDisconnected( function() {
231 |         // give some time to handle the last responce
232 |         setTimeout( function() {
233 |             endLoading();
234 | 
235 |             while (el.terminal.hasChildNodes()) {
236 |                 el.terminal.removeChild(el.terminal.childNodes[0]);
237 |             }
238 | 
239 |             el.terminal.style.transition = 'top 0s';
240 |             el.terminal.style.top = el.terminalWrap.offsetHeight;
241 | 
242 |             print('message', 'Well done, you have just ruined everything :-/');
243 |             print('message', 'The console was restarted');
244 | 
245 |             reset();
246 |         }, 10);
247 |     });
248 | }
249 | 
250 | 
251 | // initialize everything
252 | var plugin = null;
253 | 
254 | reset();
255 | el.line.focus();
256 | 
257 | el.terminalWrap.onclick = function(e) {
258 |     if (!window.getSelection().toString()) {
259 |         el.line.focus();
260 |         e.preventDefault();
261 |     }  // otherwise text selected
262 | }
263 | 
264 | 


--------------------------------------------------------------------------------
/lib/_pluginNode.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /**
  3 |  * Contains the routines loaded by the plugin process under Node.js
  4 |  * 
  5 |  * Initializes the Node.js environment version of the
  6 |  * platform-dependent connection object for the plugin site
  7 |  */
  8 | 
  9 | application = {};
 10 | connection = {};
 11 | 
 12 | 
 13 | /**
 14 |  * Prints error message and its stack
 15 |  * 
 16 |  * @param {Object} msg stack provided by error.stack or a message
 17 |  */
 18 | var printError = function(msg) {
 19 |     console.error();
 20 |     console.error(msg);
 21 | }
 22 | 
 23 | 
 24 | /**
 25 |  * Event lisener for the plugin message
 26 |  */
 27 | process.on('message', function(m) {
 28 |     switch(m.type){
 29 |     case 'import':
 30 |         importScript(m.url);
 31 |         break;
 32 |     case 'importJailed':
 33 |         importScriptJailed(m.url);
 34 |         break;
 35 |     case 'execute':
 36 |         execute(m.code);
 37 |         break;
 38 |     case 'message':
 39 |         // unhandled exception would break the IPC channel
 40 |         try {
 41 |             conn._messageHandler(m.data);
 42 |         } catch(e) {
 43 |             printError(e.stack);
 44 |         }
 45 |         break;
 46 |     }
 47 | });
 48 | 
 49 | 
 50 | /**
 51 |  * Checks if the given path is remote
 52 |  * 
 53 |  * @param {String} path to check
 54 |  * @returns {Boolean} true if path is remote
 55 |  */
 56 | var isRemote = function(path) {
 57 |     return (path.substr(0,7).toLowerCase() == 'http://' ||
 58 |             path.substr(0,8).toLowerCase() == 'https://');
 59 | }
 60 | 
 61 | 
 62 | /**
 63 |  * Loads and executes the JavaScript file with the given url
 64 |  *
 65 |  * @param {String} url of the script to load
 66 |  */
 67 | var importScript = function(url) {
 68 |     var sCb = function() {
 69 |        process.send({type: 'importSuccess', url: url});
 70 |     }
 71 | 
 72 |     var fCb = function() {
 73 |         process.send({type: 'importFailure', url: url});
 74 |     }
 75 | 
 76 |     var run = function(code) {
 77 |         executeNormal(code, url, sCb, fCb);
 78 |     }
 79 |     
 80 |     if (isRemote(url)) {
 81 |         loadRemote(url, run, fCb);
 82 |     } else {
 83 |         try {
 84 |             run(loadLocal(url));
 85 |         } catch(e) {
 86 |             printError(e.stack);
 87 |             fCb();
 88 |         }
 89 |     }
 90 | 
 91 | }
 92 | 
 93 | 
 94 | /**
 95 |  * Loads and executes the JavaScript file with the given url in a
 96 |  * jailed environment
 97 |  *
 98 |  * @param {String} url of the script to load
 99 |  */
100 | var importScriptJailed = function(url) {
101 |     var sCb = function() {
102 |        process.send({type: 'importSuccess', url: url});
103 |     }
104 | 
105 |     var fCb = function() {
106 |        process.send({type: 'importFailure', url: url});
107 |     }
108 | 
109 |     var run = function(code) {
110 |         executeJailed(code, url, sCb, fCb);
111 |     }
112 |     
113 |     if (isRemote(url)) {
114 |         loadRemote(url, run, fCb);
115 |     } else {
116 |         try {
117 |             run(loadLocal(url));
118 |         } catch (e) {
119 |             printError(e.stack);
120 |             fCb();
121 |         }
122 | 
123 |     }
124 | 
125 | }
126 | 
127 | 
128 | /**
129 |  * Executes the given code in the jailed environment, sends the
130 |  * corresponding message to the application site when succeeded/failed
131 |  * 
132 |  * @param {String} code to execute
133 |  */
134 | var execute = function(code) {
135 |     var sCb = function() {
136 |         process.send({type: 'executeSuccess'});
137 |     }
138 | 
139 |     var fCb = function() {
140 |         process.send({type: 'executeFailure'});
141 |     }
142 | 
143 |     executeJailed(code, 'DYNAMIC PLUGIN', sCb, fCb);
144 | }
145 | 
146 | 
147 | /**
148 |  * Executes the given code in the current environment / scope, runs
149 |  * the corresponding callback when done
150 |  * 
151 |  * @param {String} code to execute
152 |  * @param {String} url of the script (for displaying the stack)
153 |  * @param {Function} sCb
154 |  * @param {Function} fCb
155 |  */
156 | var executeNormal = function(code, url, sCb, fCb) {
157 |     var err = null;
158 |     try {
159 |         require('vm').runInThisContext(code, url);
160 |         sCb();
161 |     } catch (e) {
162 |         printError(e.stack);
163 |         fCb();
164 |     }
165 | }
166 | 
167 | 
168 | /**
169 |  * Executes the given code in a jailed environment, runs the
170 |  * corresponding callback when done
171 |  * 
172 |  * @param {String} code to execute
173 |  * @param {String} url of the script (for displaying the stack)
174 |  * @param {Function} sCb
175 |  * @param {Function} fCb
176 |  */
177 | var executeJailed = function(code, url, sCb, fCb) {
178 |     var vm  = require('vm');
179 |     var sandbox = {};
180 |     var expose = [
181 |         'application',
182 |         'setTimeout',
183 |         'setInterval',
184 |         'clearTimeout',
185 |         'clearInterval'
186 |     ];
187 | 
188 |     for (var i = 0; i < expose.length; i++) {
189 |         sandbox[expose[i]] = global[expose[i]];
190 |     }
191 | 
192 |     code = '"use strict";\n'+code;
193 |     try {
194 |         vm.runInNewContext(code, vm.createContext(sandbox), url);
195 |         sCb();
196 |     } catch (e) {
197 |         printError(e.stack);
198 |         fCb();
199 |     }
200 | }
201 | 
202 | 
203 | /**
204 |  * Loads local file and 
205 |  * 
206 |  * @param {String} path of the file to read
207 |  * 
208 |  * @returns {String} file contents
209 |  */
210 | var loadLocal = function(path) {
211 |     return require("fs").readFileSync(path).toString();
212 | }
213 | 
214 | 
215 | /**
216 |  * Downloads the script by remote url and provides its content as a
217 |  * string to the callback
218 |  * 
219 |  * @param {String} url of the remote module to load
220 |  * @param {Function} sCb success callback
221 |  * @param {Function} fCb failure callback
222 |  */
223 | var loadRemote = function(url, sCb, fCb) {
224 |     var receive = function(res) {
225 |         if (res.statusCode != 200) {
226 |             var msg = 'Failed to load ' + url + '\n' +
227 |                 'HTTP responce status code: ' + res.statusCode;
228 |             printError(msg);
229 |             fCb();
230 |         } else {
231 |             var content = '';
232 |             res.on('end', function(){ sCb(content); });
233 |             res.on(
234 |                 'readable',
235 |                 function() {
236 |                     var chunk = res.read();
237 |                     content += chunk.toString();
238 |                 }
239 |            );
240 |         }
241 |     }
242 | 
243 |     try {
244 |         require('http').get(url, receive).on('error', fCb);
245 |     } catch (e) {
246 |         printError(e.stack);
247 |         fCb();
248 |     }
249 | }
250 | 
251 | 
252 | /**
253 |  * Connection object provided to the SandboxedSite constructor, plugin
254 |  * site implementation for the Node.js environment
255 |  */
256 | var conn = {
257 |     disconnect: function(){ process.exit(); },
258 |     send: function(data) {
259 |         process.send({type: 'message', data: data});
260 |     },
261 |     onMessage: function(h){ conn._messageHandler = h; },
262 |     _messageHandler: function(){},
263 |     onDisconnect: function() {}
264 | };
265 |  
266 | connection = conn;
267 | 
268 | 


--------------------------------------------------------------------------------
/tests/lighttest.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * This is a set of Helios Kernel modules merged with helios-merge
  3 |  *
  4 |  * http://asvd.github.io/helios-kernel
  5 |  * http://github.com/asvd/helios-merge
  6 |  *
  7 |  * The comment related to this code normally preceeds the main module
  8 |  * (following the last here, according to the dependency order)
  9 |  */
 10 | 
 11 | 
 12 | // base.js
 13 | 
 14 | /**
 15 |  * @fileoverview Lighttest library base object definition
 16 |  */
 17 | (function(){
 18 |     lighttest = {};
 19 | })();
 20 | 
 21 | 
 22 | 
 23 | // platform.js
 24 | 
 25 | /**
 26 |  * @fileoverview Platform-dependent routines for the Lighttest library
 27 |  */
 28 | (function(){
 29 |     lighttest._platform = {};
 30 |     lighttest._platform._initialized = false;
 31 |     /**
 32 |      * Initializes Lighttest upon the first launch of the tests
 33 |      */
 34 |     lighttest._platform.init = function () {
 35 |         if (!lighttest._platform._initialized) {
 36 |             var __is__node__ = ((typeof process !== 'undefined') &&
 37 |                                 (!process.browser) &&
 38 |                                 (process.release.name.search(/node|io.js/) !== -1));
 39 |             if (__is__node__) {
 40 |                 lighttest._platform._initNode();
 41 |             } else {
 42 |                 lighttest._platform._initWeb();
 43 |             }
 44 |             lighttest._platform._initialized = true;
 45 |         }
 46 |     };
 47 |     /**
 48 |      * Initializes Lighttest for the web-based environment
 49 |      */
 50 |     lighttest._platform._initWeb = function () {
 51 |         var target = document.getElementById('lighttest') || document.getElementsByTagName('body').item(0);
 52 |         target.style.margin = 0;
 53 |         var style1 = {
 54 |                 backgroundColor: 'rgb(2,14,15)',
 55 |                 width: '100%',
 56 |                 height: '100%',
 57 |                 overflow: 'auto',
 58 |                 position: 'absolute'
 59 |             };
 60 |         var div1 = document.createElement('div');
 61 |         for (var i in style1) {
 62 |             div1.style[i] = style1[i];
 63 |         }
 64 |         target.appendChild(div1);
 65 |         var style2 = {
 66 |                 color: 'rgb(173,196,190)',
 67 |                 paddingBottom: '5px',
 68 |                 paddingLeft: '5px',
 69 |                 fontFamily: 'monospace',
 70 |                 fontSize: '8pt',
 71 |                 position: 'absolute'
 72 |             };
 73 |         var div2 = document.createElement('div');
 74 |         for (i in style2) {
 75 |             div2.style[i] = style2[i];
 76 |         }
 77 |         div1.appendChild(div2);
 78 | 
 79 |         if (typeof console.group == 'undefined') {
 80 |             console.group = function(text) {
 81 |                 console.log('[ GROUP START ]: ' + text);
 82 |             }
 83 |         }
 84 | 
 85 |         
 86 |         if (typeof console.groupEnd == 'undefined') {
 87 |             console.groupEnd = function() {
 88 |                 console.log('[  GROUP END  ]');
 89 |                 console.log(' ');
 90 |             }
 91 |         }
 92 | 
 93 |         
 94 |         lighttest._platform.print = function (text) {
 95 |             div2.innerHTML += text.replace(/\ /g, '&nbsp;');
 96 |         };
 97 |         lighttest._platform._printPlain = function (text) {
 98 |             div2.innerHTML += text;
 99 |         };
100 |         var styleRed = 'text-shadow : 0px 0px 6px #FD4E7F; color: #F13D35;';
101 |         lighttest._platform.printRed = function (text) {
102 |             lighttest._platform._printPlain('<span style="' + styleRed + '">' + text + '</span>');
103 |         };
104 |         var styleGreen = 'text-shadow : 0px 0px 8px #50A39C; color: #56D670;';
105 |         lighttest._platform.printGreen = function (text) {
106 |             lighttest._platform._printPlain('<span style="' + styleGreen + '">' + text + '</span>');
107 |         };
108 |         var styleBlue = 'text-shadow: 0px 0px 8px #507EA3; color: #58AEC9;';
109 |         lighttest._platform.printBlue = function (text) {
110 |             lighttest._platform._printPlain('<span style="' + styleBlue + '">' + text + '</span>');
111 |         };
112 |         lighttest._platform.printWhite = function (text) {
113 |             lighttest._platform._printPlain(text);
114 |         };
115 |         lighttest._platform.printLine = function () {
116 |             div2.innerHTML += '<br/>';
117 |             console.groupEnd();
118 |             setTimeout(function () {
119 |                 div1.scrollTop = div1.scrollHeight;
120 |             }, 1);
121 |         };
122 |         lighttest._platform.printTestLabel = function(text) {
123 |             lighttest._platform.printWhite(text + '  ');
124 |             console.group(text);
125 | //            console.group("%c" + '' + text, "font-weight:bold;");
126 |         }
127 |         lighttest._platform.printPass = function() {
128 |             lighttest._platform.printGreen('PASS ');
129 |             console.log('%c' + 'PASS', 'color: #36B650;font-weight:bold');
130 |         }
131 |         lighttest._platform.printFail = function() {
132 |             lighttest._platform.printRed('FAIL ');
133 |             console.error('%c' + 'FAIL', 'color: #F13D35;font-weight:bold');
134 |         }
135 |         lighttest._platform.reset = function () {
136 |             div2.innerHTML = '';
137 |         };
138 |         lighttest._platform.exit = function (code) {
139 |         };
140 |     };
141 |     /**
142 |      * Initializes Lighttest for the Node.js-based environment
143 |      */
144 |     lighttest._platform._initNode = function () {
145 |         var red = '\x1B[31m';
146 |         var green = '\x1B[32m';
147 |         var bold = '\x1b[1m';
148 |         var blue = '\x1B[36m';
149 |         var reset = '\x1B[0m';
150 |         lighttest._platform.print = function (val) {
151 |             process.stdout.write(val);
152 |         };
153 |         lighttest._platform.printRed = function (text) {
154 |             lighttest._platform.print(red + bold + text + reset);
155 |         };
156 |         lighttest._platform.printGreen = function (text) {
157 |             lighttest._platform.print(green + bold + text + reset);
158 |         };
159 |         lighttest._platform.printBlue = function (text) {
160 |             lighttest._platform.print(blue + text + reset);
161 |         };
162 |         lighttest._platform.printWhite = function (text) {
163 |             lighttest._platform.print(bold + text + reset);
164 |         };
165 |         lighttest._platform.printLine = function () {
166 |             console.log();
167 |         };
168 |         lighttest._platform.printTestLabel = function(text) {
169 |             lighttest._platform.printWhite(text + '  ');
170 |         }
171 |         lighttest._platform.printPass = function() {
172 |             lighttest._platform.printGreen('PASS ');
173 |         }
174 |         lighttest._platform.printFail = function() {
175 |             lighttest._platform.printRed('FAIL ');
176 |             console.log('');
177 |         }
178 |         lighttest._platform.reset = function (code) {
179 |         };
180 |         lighttest._platform.exit = function (code) {
181 |             process.exit(code);
182 |         };
183 |         // prevents from crashing on exceptions
184 |         process.on('uncaughtException', function (err) {
185 |             console.log();
186 |             console.error(err);
187 |         });
188 |     };
189 | })();
190 | 
191 | 
192 | 
193 | // lighttest.js
194 | 
195 | /**
196 |  * @fileoverview Lighttest - a clear testing environment
197 |  * 
198 |  * @version 0.1.3
199 |  * 
200 |  * Copyright (c) 2014 asvd <heliosframework@gmail.com> 
201 |  * 
202 |  * Lighttest library is licensed under the MIT license,
203 |  * see http://github.com/asvd/lighttest
204 |  */
205 | (function(){
206 |     lighttest._state = 'nothing';
207 |     lighttest._pendingTests = null;
208 |     lighttest._pendingCallback = null;
209 |     /**
210 |      * Wraps the given code so that in case of exception it will fail
211 |      * the test (instead of breaking the stack)
212 |      * 
213 |      * @param {Function} method to wrap
214 |      * 
215 |      * @returns {Function} wrapped method
216 |      */
217 |     lighttest.protect = function (method) {
218 |         return function () {
219 |             try {
220 |                 method.apply(this, arguments);
221 |             } catch (e) {
222 |                 lighttest.check(false);
223 |                 lighttest.done();
224 |                 throw e;
225 |             }
226 |         };
227 |     };
228 |     /**
229 |      * Runs the given set of tests
230 |      * 
231 |      * @param {Array} tests list of tests to execute
232 |      * @param {Function} callback to run after the tests
233 |      */
234 |     lighttest.start = function (tests, callback) {
235 |         switch (lighttest._state) {
236 |         case 'nothing':
237 |         case 'paused':
238 |             // (re)start
239 |             lighttest._platform.init();
240 |             lighttest._platform.reset();
241 |             lighttest._testsFailed = 0;
242 |             lighttest._currentTestIdx = 0;
243 |             lighttest._state = 'running';
244 |             lighttest._callback = callback || null;
245 |             lighttest._tests = [];
246 |             for (var label in tests) {
247 |                 if (tests.hasOwnProperty(label)) {
248 |                     lighttest._tests.push({
249 |                         label: label,
250 |                         method: lighttest.protect(tests[label])
251 |                     });
252 |                 }
253 |             }
254 |             lighttest._next();
255 |             break;
256 |         case 'running':
257 |         case 'interrupting':
258 |             // switching to restart even in case of requested pause
259 |             // (restart is stronger)
260 |             lighttest._state = 'interrupting';
261 |             lighttest._pendingTests = tests;
262 |             lighttest._pendingCallback = callback;
263 |             break;
264 |         }
265 |     };
266 |     /**
267 |      * (Un)pauses the tests execution (waiting until the currently
268 |      * running test is completed)
269 |      */
270 |     lighttest.pause = function () {
271 |         switch (lighttest._state) {
272 |         case 'nothing':
273 |         case 'interrupting':
274 |             break;
275 |         case 'running':
276 |             // pausing
277 |             lighttest._state = 'interrupting';
278 |             lighttest._pendingTests = null;
279 |             lighttest._pendingCallback = null;
280 |             break;
281 |         case 'paused':
282 |             // unpausing
283 |             lighttest._state = 'running';
284 |             lighttest._next();
285 |             break;
286 |         }
287 |     };
288 |     /**
289 |      * Checks the given value against being true, logs the result for
290 |      * the currently running test
291 |      * 
292 |      * @param {Boolean} value to check
293 |      */
294 |     lighttest.check = function (value) {
295 |         if (value) {
296 |             lighttest._platform.printPass();
297 |         } else {
298 |             lighttest._platform.printFail();
299 |             lighttest._currentFailed = true;
300 |         }
301 |     };
302 |     /**
303 |      * Called by the test body when finished, launches the next test
304 |      */
305 |     lighttest.done = function () {
306 |         // let pause() called after done() time to perform
307 |         setTimeout(lighttest._done, 10);
308 |     };
309 |     /**
310 |      * Launches the next test
311 |      */
312 |     lighttest._done = function () {
313 |         if (lighttest._currentFailed) {
314 |             lighttest._testsFailed++;
315 |         }
316 |         lighttest._currentTestIdx++;
317 |         switch (lighttest._state) {
318 |         case 'paused':
319 |         case 'nothing':
320 |             // tests not running
321 |             break;
322 |         case 'running':
323 |             // normal case, prevent stack growth
324 |             setTimeout(lighttest._next, 0);
325 |             break;
326 |         case 'interrupting':
327 |             if (lighttest._pendingTests) {
328 |                 // restart requested
329 |                 lighttest._state = 'nothing';
330 |                 var tests = lighttest._pendingTests;
331 |                 var callback = lighttest._pendingCallback;
332 |                 lighttest._pendingTests = null;
333 |                 lighttest._pendingCallback = null;
334 |                 lighttest.start(tests, callback);
335 |             } else {
336 |                 // pause requested
337 |                 lighttest._state = 'paused';
338 |                 lighttest._platform.printLine();
339 |                 lighttest._platform.printLine();
340 |                 lighttest._platform.printBlue('// paused');
341 |                 lighttest._platform.printLine();
342 |             }
343 |             break;
344 |         }
345 |     };
346 |      lighttest._genPfx = function(num) {
347 |          var testsnum = lighttest._tests.length;
348 |          var len = (''+testsnum).length;
349 |          var result  = ('00000000'+(num+1)).substr(-len);
350 |          result = ''+result + ' ';
351 |          return result;
352 |      }
353 |     /**
354 |      * Proceeds to the next test
355 |      */
356 |     lighttest._next = function () {
357 |         var idx = lighttest._currentTestIdx;
358 |         if (idx == lighttest._tests.length) {
359 |             lighttest._finalize();
360 |         } else {
361 |             lighttest._platform.printLine();
362 |             lighttest._currentFailed = false;
363 |             var test = lighttest._tests[idx];
364 |             lighttest._platform.printTestLabel(lighttest._genPfx(idx) + test.label);
365 |             setTimeout(test.method, 0);
366 |         }
367 |     };
368 |     /**
369 |      * Finalizes testing after all tests completed
370 |      */
371 |     lighttest._finalize = function () {
372 |         var failed = lighttest._testsFailed;
373 |         var total = lighttest._tests.length;
374 |         lighttest._platform.printLine();
375 |         lighttest._platform.printLine();
376 |         if (failed) {
377 |             lighttest._platform.print(failed + ' of ' + total + ' tests ');
378 |             lighttest._platform.printRed('FAILED');
379 |         } else {
380 |             lighttest._platform.print(total + ' tests ');
381 |             lighttest._platform.printGreen('PASSED');
382 |         }
383 |         lighttest._platform.printLine();
384 |         lighttest._platform.printLine();
385 |         lighttest._state = 'nothing';
386 |         if (lighttest._callback) {
387 |             lighttest._callback(failed);
388 |         }
389 |         lighttest._platform.exit(failed);
390 |     };
391 | })();
392 | 
393 | 
394 | 


--------------------------------------------------------------------------------
/lib/_JailedSite.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /**
  3 |  * Contains the JailedSite object used both by the application
  4 |  * site, and by each plugin
  5 |  */
  6 | 
  7 | (function(){
  8 |      
  9 |     /**
 10 |      * JailedSite object represents a single site in the
 11 |      * communication protocol between the application and the plugin
 12 |      * 
 13 |      * @param {Object} connection a special object allowing to send
 14 |      * and receive messages from the opposite site (basically it
 15 |      * should only provide send() and onMessage() methods)
 16 |      */
 17 |     JailedSite = function(connection) {
 18 |         this._interface = {};
 19 |         this._remote = null;
 20 |         this._remoteUpdateHandler = function(){};
 21 |         this._getInterfaceHandler = function(){};
 22 |         this._interfaceSetAsRemoteHandler = function(){};
 23 |         this._disconnectHandler = function(){};
 24 |         this._store = new ReferenceStore;
 25 | 
 26 |         var me = this;
 27 |         this._connection = connection;
 28 |         this._connection.onMessage(
 29 |             function(data){ me._processMessage(data); }
 30 |         );
 31 | 
 32 |         this._connection.onDisconnect(
 33 |             function(m){
 34 |                 me._disconnectHandler(m);
 35 |             }
 36 |         );
 37 |     }
 38 | 
 39 | 
 40 |     /**
 41 |      * Set a handler to be called when the remote site updates its
 42 |      * interface
 43 |      * 
 44 |      * @param {Function} handler
 45 |      */
 46 |     JailedSite.prototype.onRemoteUpdate = function(handler) {
 47 |         this._remoteUpdateHandler = handler;
 48 |     }
 49 | 
 50 | 
 51 |     /**
 52 |      * Set a handler to be called when received a responce from the
 53 |      * remote site reporting that the previously provided interface
 54 |      * has been succesfully set as remote for that site
 55 |      * 
 56 |      * @param {Function} handler
 57 |      */
 58 |     JailedSite.prototype.onInterfaceSetAsRemote = function(handler) {
 59 |         this._interfaceSetAsRemoteHandler = handler;
 60 |     }
 61 | 
 62 | 
 63 |     /**
 64 |      * Set a handler to be called when the remote site requests to
 65 |      * (re)send the interface. Used to detect an initialzation
 66 |      * completion without sending additional request, since in fact
 67 |      * 'getInterface' request is only sent by application at the last
 68 |      * step of the plugin initialization
 69 |      * 
 70 |      * @param {Function} handler
 71 |      */
 72 |     JailedSite.prototype.onGetInterface = function(handler) {
 73 |         this._getInterfaceHandler = handler;
 74 |     }
 75 | 
 76 | 
 77 |     /**
 78 |      * @returns {Object} set of remote interface methods
 79 |      */
 80 |     JailedSite.prototype.getRemote = function() {
 81 |         return this._remote;
 82 |     }
 83 | 
 84 | 
 85 |     /**
 86 |      * Sets the interface of this site making it available to the
 87 |      * remote site by sending a message with a set of methods names
 88 |      * 
 89 |      * @param {Object} _interface to set
 90 |      */
 91 |     JailedSite.prototype.setInterface = function(_interface) {
 92 |         this._interface = _interface;
 93 |         this._sendInterface();
 94 |     }
 95 | 
 96 | 
 97 |     /**
 98 |      * Sends the actual interface to the remote site upon it was
 99 |      * updated or by a special request of the remote site
100 |      */
101 |     JailedSite.prototype._sendInterface = function() {
102 |         var names = [];
103 |         for (var name in this._interface) {
104 |             if (this._interface.hasOwnProperty(name)) {
105 |                 names.push(name);
106 |             }
107 |         }
108 | 
109 |         this._connection.send({type:'setInterface', api: names});
110 |     }
111 | 
112 | 
113 |     /**
114 |      * Handles a message from the remote site
115 |      */
116 |     JailedSite.prototype._processMessage = function(data) {
117 |          switch(data.type) {
118 |          case 'method':
119 |              var method = this._interface[data.name];
120 |              var args = this._unwrap(data.args);
121 |              method.apply(null, args);
122 |              break;
123 |          case 'callback':
124 |              var method = this._store.fetch(data.id)[data.num];
125 |              var args = this._unwrap(data.args);
126 |              method.apply(null, args);
127 |              break;
128 |          case 'setInterface':
129 |              this._setRemote(data.api);
130 |              break;
131 |          case 'getInterface':
132 |              this._sendInterface();
133 |              this._getInterfaceHandler();
134 |              break;
135 |          case 'interfaceSetAsRemote':
136 |              this._interfaceSetAsRemoteHandler();
137 |              break;
138 |          case 'disconnect':
139 |              this._disconnectHandler();
140 |              this._connection.disconnect();
141 |              break;
142 |          }
143 |     }
144 | 
145 | 
146 |     /**
147 |      * Sends a requests to the remote site asking it to provide its
148 |      * current interface
149 |      */
150 |     JailedSite.prototype.requestRemote = function() {
151 |         this._connection.send({type:'getInterface'});
152 |     }
153 | 
154 | 
155 |     /**
156 |      * Sets the new remote interface provided by the other site
157 |      * 
158 |      * @param {Array} names list of function names
159 |      */
160 |     JailedSite.prototype._setRemote = function(names) {
161 |         this._remote = {};
162 |         var i, name;
163 |         for (i = 0; i < names.length; i++) {
164 |             name = names[i];
165 |             this._remote[name] = this._genRemoteMethod(name);
166 |         }
167 | 
168 |         this._remoteUpdateHandler();
169 |         this._reportRemoteSet();
170 |     }
171 |      
172 |      
173 |     /**
174 |      * Generates the wrapped function corresponding to a single remote
175 |      * method. When the generated function is called, it will send the
176 |      * corresponding message to the remote site asking it to execute
177 |      * the particular method of its interface
178 |      * 
179 |      * @param {String} name of the remote method
180 |      * 
181 |      * @returns {Function} wrapped remote method
182 |      */
183 |     JailedSite.prototype._genRemoteMethod = function(name) {
184 |         var me = this;
185 |         var remoteMethod = function() {
186 |             me._connection.send({
187 |                 type: 'method',
188 |                 name: name,
189 |                 args: me._wrap(arguments)
190 |             });
191 |         };
192 | 
193 |         return remoteMethod;
194 |     }
195 | 
196 | 
197 |     /**
198 |      * Sends a responce reporting that interface just provided by the
199 |      * remote site was sucessfully set by this site as remote
200 |      */
201 |     JailedSite.prototype._reportRemoteSet = function() {
202 |         this._connection.send({type:'interfaceSetAsRemote'});
203 |     }
204 | 
205 | 
206 |     /**
207 |      * Prepares the provided set of remote method arguments for
208 |      * sending to the remote site, replaces all the callbacks with
209 |      * identifiers
210 |      * 
211 |      * @param {Array} args to wrap 
212 |      * 
213 |      * @returns {Array} wrapped arguments
214 |      */
215 |     JailedSite.prototype._wrap = function(args) {
216 |         var wrapped = [];
217 |         var callbacks = {};
218 |         var callbacksPresent = false;
219 |         for (var i = 0; i < args.length; i++) {
220 |             if (typeof args[i] == 'function') {
221 |                 callbacks[i] = args[i];
222 |                 wrapped[i] = {type: 'callback', num : i};
223 |                 callbacksPresent = true;
224 |             } else {
225 |                 wrapped[i] = {type: 'argument', value : args[i]};
226 |             }
227 |         }
228 | 
229 |         var result = {args: wrapped};
230 | 
231 |         if (callbacksPresent) {
232 |             result.callbackId = this._store.put(callbacks);
233 |         }
234 | 
235 |         return result;
236 |     }
237 | 
238 | 
239 |     /**
240 |      * Unwraps the set of arguments delivered from the remote site,
241 |      * replaces all callback identifiers with a function which will
242 |      * initiate sending that callback identifier back to other site
243 |      * 
244 |      * @param {Object} args to unwrap
245 |      * 
246 |      * @returns {Array} unwrapped args
247 |      */
248 |     JailedSite.prototype._unwrap = function(args) {
249 |         var called = false;
250 |         
251 |         // wraps each callback so that the only one could be called
252 |         var once = function(cb) {
253 |             return function() {
254 |                 if (!called) {
255 |                     called = true;
256 |                     cb.apply(this, arguments);
257 |                 } else {
258 |                     var msg =
259 |                       'A callback from this set has already been executed';
260 |                     throw new Error(msg);
261 |                 }
262 |             };
263 |         }
264 |         
265 |         var result = [];
266 |         var i, arg, cb, me = this;
267 |         for (i = 0; i < args.args.length; i++) {
268 |             arg = args.args[i];
269 |             if (arg.type == 'argument') {
270 |                 result.push(arg.value);
271 |             } else {
272 |                 cb = once(
273 |                     this._genRemoteCallback(args.callbackId, i)
274 |                 );
275 |                 result.push(cb);
276 |             }
277 |         }
278 | 
279 |         return result;
280 |     }
281 |      
282 |      
283 |     /**
284 |      * Generates the wrapped function corresponding to a single remote
285 |      * callback. When the generated function is called, it will send
286 |      * the corresponding message to the remote site asking it to
287 |      * execute the particular callback previously saved during a call
288 |      * by the remote site a method from the interface of this site
289 |      * 
290 |      * @param {Number} id of the remote callback to execute
291 |      * @param {Number} argNum argument index of the callback
292 |      * 
293 |      * @returns {Function} wrapped remote callback
294 |      */
295 |     JailedSite.prototype._genRemoteCallback = function(id, argNum) {
296 |         var me = this;
297 |         var remoteCallback = function() {
298 |             me._connection.send({
299 |                 type : 'callback',
300 |                 id   : id,
301 |                 num  : argNum,
302 |                 args : me._wrap(arguments)
303 |             });
304 |         };
305 | 
306 |         return remoteCallback;
307 |     }
308 | 
309 |      
310 |     /**
311 |      * Sends the notification message and breaks the connection
312 |      */
313 |     JailedSite.prototype.disconnect = function() {
314 |         this._connection.send({type: 'disconnect'});
315 |         this._connection.disconnect();
316 |     }
317 |     
318 |      
319 |     /**
320 |      * Set a handler to be called when received a disconnect message
321 |      * from the remote site
322 |      * 
323 |      * @param {Function} handler
324 |      */
325 |     JailedSite.prototype.onDisconnect = function(handler) {
326 |         this._disconnectHandler = handler;
327 |     }
328 |      
329 |      
330 |      
331 | 
332 |     /**
333 |      * ReferenceStore is a special object which stores other objects
334 |      * and provides the references (number) instead. This reference
335 |      * may then be sent over a json-based communication channel (IPC
336 |      * to another Node.js process or a message to the Worker). Other
337 |      * site may then provide the reference in the responce message
338 |      * implying the given object should be activated.
339 |      * 
340 |      * Primary usage for the ReferenceStore is a storage for the
341 |      * callbacks, which therefore makes it possible to initiate a
342 |      * callback execution by the opposite site (which normally cannot
343 |      * directly execute functions over the communication channel).
344 |      * 
345 |      * Each stored object can only be fetched once and is not
346 |      * available for the second time. Each stored object must be
347 |      * fetched, since otherwise it will remain stored forever and
348 |      * consume memory.
349 |      * 
350 |      * Stored object indeces are simply the numbers, which are however
351 |      * released along with the objects, and are later reused again (in
352 |      * order to postpone the overflow, which should not likely happen,
353 |      * but anyway).
354 |      */
355 |     var ReferenceStore = function() {
356 |         this._store = {};    // stored object
357 |         this._indices = [0]; // smallest available indices
358 |     }
359 | 
360 | 
361 |     /**
362 |      * @function _genId() generates the new reference id
363 |      * 
364 |      * @returns {Number} smallest available id and reserves it
365 |      */
366 |     ReferenceStore.prototype._genId = function() {
367 |         var id;
368 |         if (this._indices.length == 1) {
369 |             id = this._indices[0]++;
370 |         } else {
371 |             id = this._indices.shift();
372 |         }
373 | 
374 |         return id;
375 |     }
376 | 
377 | 
378 |     /**
379 |      * Releases the given reference id so that it will be available by
380 |      * another object stored
381 |      * 
382 |      * @param {Number} id to release
383 |      */
384 |     ReferenceStore.prototype._releaseId = function(id) {
385 |         for (var i = 0; i < this._indices.length; i++) {
386 |             if (id < this._indices[i]) {
387 |                 this._indices.splice(i, 0, id);
388 |                 break;
389 |             }
390 |         }
391 | 
392 |         // cleaning-up the sequence tail
393 |         for (i = this._indices.length-1; i >= 0; i--) {
394 |             if (this._indices[i]-1 == this._indices[i-1]) {
395 |                 this._indices.pop();
396 |             } else {
397 |                 break;
398 |             }
399 |         }
400 |     }
401 | 
402 | 
403 |     /**
404 |      * Stores the given object and returns the refernce id instead
405 |      * 
406 |      * @param {Object} obj to store
407 |      * 
408 |      * @returns {Number} reference id of the stored object
409 |      */
410 |     ReferenceStore.prototype.put = function(obj) {
411 |         var id = this._genId();
412 |         this._store[id] = obj;
413 |         return id;
414 |     }
415 | 
416 | 
417 |     /**
418 |      * Retrieves previously stored object and releases its reference
419 |      * 
420 |      * @param {Number} id of an object to retrieve
421 |      */
422 |     ReferenceStore.prototype.fetch = function(id) {
423 |         var obj = this._store[id];
424 |         this._store[id] = null;
425 |         delete this._store[id];
426 |         this._releaseId(id);
427 |         return obj;
428 |     }
429 | 
430 | 
431 | })();
432 | 
433 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Jailed — flexible JS sandbox
  2 | ============================
  3 | 
  4 | Jailed is a small JavaScript library for running untrusted code in a
  5 | sandbox. The library is written in vanilla-js and has no dependencies.
  6 | 
  7 | With Jailed you can:
  8 | 
  9 | - Load an untrusted code into a secure sandbox;
 10 | 
 11 | - Export a set of external functions into the sandbox.
 12 | 
 13 | The untrusted code may then interract with the main application by
 14 | directly calling those functions, but the application owner decides
 15 | which functions to export, and therefore what will be allowed for the
 16 | untrusted code to perform.
 17 | 
 18 | The code is executed as a *plugin*, a special instance running as a
 19 | restricted subprocess (in Node.js), or in a web-worker inside a
 20 | sandboxed frame (in case of web-browser environment). The iframe is
 21 | created locally, so that you don't need to host it on a separate
 22 | (sub)domain.
 23 | 
 24 | 
 25 | You can use Jailed to:
 26 | 
 27 | - Setup a safe environment for executing untrusted code, without a
 28 |   need to create a sandboxed worker / subprocess manually;
 29 | 
 30 | - Do that in an isomorphic way: the syntax is same both for Node.js
 31 |   and web-browser, the code works unchanged;
 32 | 
 33 | - Execute a code from a string or from a file;
 34 | 
 35 | - Initiate and interrupt the execution anytime;
 36 | 
 37 | - *[Demo](http://asvd.github.io/jailed/demos/web/console/)* safely
 38 |    execute user-submitted code;
 39 | 
 40 | - *[Demo](http://asvd.github.io/jailed/demos/web/banner/)* embed
 41 |   3rd-party code and provide it the precise set of functions to
 42 |   harmlessly operate on the part of your application;
 43 |   
 44 | - Export the particular set of application functions into the sandbox
 45 |   (or in the opposite direction), and let those functions be invoked
 46 |   from the other site (without a need for manual messaging) thus
 47 |   building any custom API and set of permissions.
 48 | 
 49 | 
 50 | For instance:
 51 | 
 52 | 
 53 | ```js
 54 | var path = 'http://path.to/the/plugin.js';
 55 | 
 56 | // exported methods, will be available to the plugin
 57 | var api = {
 58 |     alert: alert
 59 | };
 60 | 
 61 | var plugin = new jailed.Plugin(path, api);
 62 | ```
 63 | 
 64 | 
 65 | *plugin.js:*
 66 | 
 67 | ```js
 68 | // runs in a sandboxed worker, cannot access the main application,
 69 | // with except for the explicitly exported alert() method
 70 | 
 71 | // exported methods are stored in the application.remote object
 72 | application.remote.alert('Hello from the plugin!');
 73 | ```
 74 | 
 75 | *(exporting the `alert()` method is not that good idea actually)*
 76 | 
 77 | Under the hood, an application may only communicate to a plugin
 78 | (sandboxed worker / jailed subprocess) through a messaging mechanism,
 79 | which is reused by Jailed in order to simulate the exporting of
 80 | particular functions. Each exported function is duplicated on the
 81 | opposite site with a special wrapper method with the same name. Upon
 82 | the wrapper method is called, arguments are serialized, and the
 83 | corresponding message is sent, which leads to the actual function
 84 | invocation on the other site. If the executed function then issues a
 85 | callback, the responce message will be sent back and handled by the
 86 | opposite site, which will, in turn, execute the actual callback
 87 | previously stored upon the initial wrapper method invocation. A
 88 | callback is in fact a short-term exported function and behaves in the
 89 | same way, particularly it may invoke a newer callback in reply.
 90 | 
 91 | 
 92 | ### Installation
 93 | 
 94 | For the web-browser environment — download and unpack the
 95 | [distribution](https://github.com/asvd/jailed/releases/download/v0.3.1/jailed-0.3.1.tar.gz), or install it using [Bower](http://bower.io/):
 96 | 
 97 | ```sh
 98 | $ bower install jailed
 99 | ```
100 | 
101 | Load the `jailed.js` in a preferrable way. That is an UMD module, thus
102 | for instance it may simply be loaded as a plain JavaScript file using
103 | the `<script>` tag:
104 | 
105 | ```html
106 | <script src="jailed/jailed.js"></script>
107 | ```
108 | 
109 | For Node.js — install Jailed with npm:
110 | 
111 | ```sh
112 | $ npm install jailed
113 | ```
114 | 
115 | and then in your code:
116 | 
117 | ```js
118 | var jailed = require('jailed');
119 | ```
120 | 
121 | Optionally you may load the script from the
122 | [distribution](https://github.com/asvd/jailed/releases/download/v0.3.1/jailed-0.3.1.tar.gz):
123 | 
124 | ```js
125 | var jailed = require('path/to/jailed.js');
126 | ```
127 | 
128 | After the module is loaded, the two plugin constructors are available:
129 | `jailed.Plugin` and `jailed.DynamicPlugin`.
130 | 
131 | 
132 | 
133 | ### Usage
134 | 
135 | The messaging mechanism reused beyond the remote method invocation
136 | introduces some natural limitations for the exported functions and
137 | their usage (nevertheless the most common use-cases are still
138 | straightforward):
139 | 
140 | - Exported function arguments may only be either simple objects (which
141 |   are then serialized and sent within a message), or callbacks (which
142 |   are preserved and replaced with special identifiers before
143 |   sending). Custom object instance may not be used as an argument.
144 | 
145 | - A callback can not be executed several times, it will be destroyed
146 |   upon the first invocation.
147 | 
148 | - If several callbacks are provided, only one of them may be called.
149 | 
150 | - Returned value of an exported function is ignored, result should be
151 |   provided to a callback instead.
152 | 
153 | 
154 | *In Node.js the
155 |  [send()](http://nodejs.org/api/child_process.html#child_process_child_send_message_sendhandle)
156 |  method of a child process object is used for transfering messages,
157 |  which serializes an object into a JSON-string. In a web-browser
158 |  environment, the messages are transfered via
159 |  [postMessage()](https://developer.mozilla.org/en-US/docs/Web/API/Window.postMessage)
160 |  method, which implements [the structured clone
161 |  algorithm](https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/The_structured_clone_algorithm)
162 |  for the serialization. That algorithm is more capable than JSON (for
163 |  instance, in a web-browser you may send a RegExp object, which is not
164 |  possible in Node.js). [More details about structured clone algorithm
165 |  and its comparsion to
166 |  JSON](https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/The_structured_clone_algorithm).*
167 | 
168 | A plugin object may be created either from a string containing a
169 | source code to be executed, or with a path to the script. To load a
170 | plugin code from a file, create the plugin using `jailed.Plugin`
171 | constructor and provide the path:
172 | 
173 | ```js
174 | var path = 'http://path.to/some/plugin.js';
175 | 
176 | // set of methods to be exported into the plugin
177 | var api = {
178 |     alert: alert
179 | }
180 | 
181 | var plugin = new jailed.Plugin(path, api);
182 | ```
183 | 
184 | 
185 | *plugin.js:*
186 | 
187 | ```js
188 | application.remote.alert('Hello from the plugin!');
189 | ```
190 | 
191 | 
192 | Creating a plugin from a string containing a code is very similar,
193 | this is performed using `jailed.DynamicPlugin` constructor:
194 | 
195 | 
196 | ```js
197 | var code = "application.remote.alert('Hello from the plugin!');";
198 | 
199 | var api = {
200 |     alert: alert
201 | }
202 | 
203 | var plugin = new jailed.DynamicPlugin(code, api);
204 | ```
205 | 
206 | 
207 | The second `api` argument provided to the `jailed.Plugin` and
208 | `jailed.DynamicPlugin` constructors is an interface object with a set
209 | of functions to be exported into the plugin. It is also possible to
210 | export functions in the opposite direction — from a plugin to the main
211 | application. It may be used for instance if a plugin provides a method
212 | to perform a calculation. In this case the second argument of a plugin
213 | constructor may be omitted. To export some plugin functions, use
214 | `application.setInterface()` method in the plugin code:
215 | 
216 | 
217 | ```js
218 | // create a plugin
219 | var path = "http://path.to/some/plugin.js";
220 | var plugin = new jailed.Plugin(path);
221 | 
222 | // called after the plugin is loaded
223 | var start = function() {
224 |     // exported method is available at this point
225 |     plugin.remote.square(2, reportResult);
226 | }
227 | 
228 | var reportResult = function(result) {
229 |     window.alert("Result is: " + result);
230 | }
231 | 
232 | // execute start() upon the plugin is loaded
233 | plugin.whenConnected(start);
234 | ```
235 | 
236 | *plugin.js:*
237 | 
238 | ```js
239 | // provides the method to square a number
240 | var api = {
241 |     square: function(num, cb) {
242 |         // result reported to the callback
243 |         cb(num*num);
244 |     }
245 | }
246 | 
247 | // exports the api to the application environment
248 | application.setInterface(api);
249 | ```
250 | 
251 | In this example the `whenConnected()` plugin method is used at the
252 | application site: that method subscribes the given function to the
253 | plugin connection event, after which the functions exported by the
254 | plugin become accessible at the `remote` property of a plugin.
255 | 
256 | The `whenConnected()` method may be used as many times as needed and
257 | thus subscribe several handlers for a single connection event. For
258 | additional convenience, it is also possible to set a connection
259 | handler even after the plugin has already been connected — in this
260 | case the handler is issued immediately (yet asynchronously).
261 | 
262 | When a plugin code is executed, a set of functions exported by the
263 | application is already prepared. But if one of those functions is
264 | invoked, it will actually be called on the application site. If in
265 | this case the code of that function will try to use a function
266 | exported by the plugin, it may not be prepared yet. To solve this, the
267 | similar `application.whenConnected()` method is available on the
268 | plugin site. The method works same as the one of the plugin object:
269 | the subscribed handler function will be executed after the connection
270 | is initialized, and a set of functions exported by each site is
271 | available on the opposite site.
272 | 
273 | 
274 | Therefore:
275 | 
276 | - If you need to load a plugin and supply it with a set of exported
277 |   functions, simply provide those functions into the plugin
278 |   constructor, and then access those at `application.remote` property
279 |   on the plugin site — the exported functions are already prepared
280 |   when the plugin code is exectued.
281 | 
282 | - If you need to load a plugin and use the functions it provides
283 |   through exporting, set up a handler using `plugin.whenConnected()`
284 |   method on the application site. After the event is fired, the
285 |   functions exported by the plugin are available at its `remote`
286 |   property of the plugin object;.
287 | 
288 | - If both application and a plugin use the exported functions of each
289 |   other, *and* the communication is initiated by the plugin, you will
290 |   most likely need to use the `application.whenConnected()` method on
291 |   the plugin site before initiating the communication, in order to
292 |   make sure that the functions exported by the plugin are already
293 |   available to the application.
294 | 
295 | 
296 | To disconnect a plugin, use the `disconnect()` method: it kills a
297 | worker / subprocess immediately without any chance for its code to
298 | react.
299 | 
300 | A plugin may also disconnect itself by calling the
301 | `application.disconnect()` method.
302 | 
303 | In addition to `whenConnected()` method, the plugin object also
304 | provides similar `whenFailed()` and `whenDisconnected()` methods:
305 | 
306 | - `whenFailed()` subscribes a handler function to the connection
307 |   failure event, which happens if there have been some error during
308 |   the plugin initialization, like a network problem or a syntax error
309 |   in the plugin initialization code.
310 | 
311 | - `whenDisconnected()` subscribes a function to the disconnect event,
312 |   which happens if a plugin was disconnected by calling the
313 |   `disconnect()` method, or a plugin has disconnected itself by
314 |   calling `application.disconnect()`, or if a plugin failed to
315 |   initialize (along with the failure event mentioned above). After the
316 |   event is fired, the plugin is not usable anymore.
317 | 
318 | Just like as for `whenConnected()` method, those two methods may also
319 | be used several times or even after the event has actually been fired.
320 | 
321 | 
322 | ### Compatibility
323 | 
324 | Jailed was tested and should work in Node.js, and in the following
325 | browsers:
326 | 
327 | - Internet Explorer 10+, Edge
328 | - Firefox 26+
329 | - Opera 12+
330 | - Safari 6+
331 | - Chrome 10+
332 | 
333 | 
334 | ### Security
335 | 
336 | This is how the sandbox is built:
337 | 
338 | ##### In a web-browser:
339 | 
340 | - a [sandboxed
341 | iframe](http://www.html5rocks.com/en/tutorials/security/sandboxed-iframes/)
342 | is created with its `sandbox` attribute only set to `"allow-scripts"`
343 | (to prevent the content of the frame from accessing anything of the
344 | main application origin);
345 | 
346 | - then a web-worker is started inside that frame;
347 | 
348 | - finally the code is loaded by the worker and executed.
349 | 
350 | *Note: when Jailed library is loaded from the local source (its path
351 |  starts with `file://`), the `"allow-same-origin"` permission is added
352 |  to the `sandbox` attribute of the iframe. Local installations are
353 |  mostly used for testing, and without that permission it would not be
354 |  possible to load the plugin code from a local file. This means that
355 |  the plugin code has an access to the local filesystem, and to some
356 |  origin-shared things like IndexedDB (though the main application page
357 |  is still not accessible from the worker). Therefore if you need to
358 |  safely execute untrusted code on a local system, reuse the Jailed
359 |  library in Node.js.*
360 | 
361 | 
362 | ##### In Node.js:
363 | 
364 | *Warning: according to recent reports
365 |  ([#33](https://github.com/asvd/jailed/issues/33)) this way of
366 |  sandboxing is not secure any longer, the fix is being prepared...*
367 | 
368 | - A Node.js subprocess is created by the Jailed library;
369 | 
370 | - the subprocess (down)loads the file containing an untrusted code as
371 |   a string (or, in case of `DynamicPlugin`, simply uses the provided
372 |   string with code)
373 | 
374 | - then `"use strict";` is appended to the head of that code (in order
375 |   to prevent breaking the sandbox using `arguments.callee.caller`);
376 | 
377 | - finally the code is executed using `vm.runInNewContext()` method,
378 |   where the provided sandbox only exposes some basic methods like
379 |   `setTimeout()`, and the `application` object for messaging with the
380 |    application site.
381 | 
382 | --
383 | 
384 | follow me on twitter: https://twitter.com/asvd0
385 | 
386 | 


--------------------------------------------------------------------------------
/lib/jailed.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @fileoverview Jailed - safe yet flexible sandbox
  3 |  * @version 0.3.1
  4 |  * 
  5 |  * @license MIT, see http://github.com/asvd/jailed
  6 |  * Copyright (c) 2014 asvd <heliosframework@gmail.com> 
  7 |  * 
  8 |  * Main library script, the only one to be loaded by a developer into
  9 |  * the application. Other scrips shipped along will be loaded by the
 10 |  * library either here (application site), or into the plugin site
 11 |  * (Worker/child process):
 12 |  *
 13 |  *  _JailedSite.js    loaded into both applicaiton and plugin sites
 14 |  *  _frame.html       sandboxed frame (web)
 15 |  *  _frame.js         sandboxed frame code (web)
 16 |  *  _pluginWebWorker.js  platform-dependent plugin routines (web / worker)
 17 |  *  _pluginWebIframe.js  platform-dependent plugin routines (web / iframe)
 18 |  *  _pluginNode.js    platform-dependent plugin routines (Node.js)
 19 |  *  _pluginCore.js    common plugin site protocol implementation
 20 |  */
 21 | 
 22 | 
 23 | var __jailed__path__;
 24 | var __is__node__ = ((typeof process !== 'undefined') &&
 25 |                     (!process.browser) &&
 26 |                     (process.release.name.search(/node|io.js/) !== -1));
 27 | if (__is__node__) {
 28 |     // Node.js
 29 |     __jailed__path__ = __dirname + '/';
 30 | } else {
 31 |     // web
 32 |     var scripts = document.getElementsByTagName('script');
 33 |     __jailed__path__ = scripts[scripts.length-1].src
 34 |         .split('?')[0]
 35 |         .split('/')
 36 |         .slice(0, -1)
 37 |         .join('/')+'/';
 38 | }
 39 | 
 40 | 
 41 | (function (root, factory) {
 42 |     if (typeof define === 'function' && define.amd) {
 43 |         define(['exports'], factory);
 44 |     } else if (typeof exports !== 'undefined') {
 45 |         factory(exports);
 46 |     } else {
 47 |         factory((root.jailed = {}));
 48 |     }
 49 | }(this, function (exports) {
 50 |     /**
 51 |      * A special kind of event:
 52 |      *  - which can only be emitted once;
 53 |      *  - executes a set of subscribed handlers upon emission;
 54 |      *  - if a handler is subscribed after the event was emitted, it
 55 |      *    will be invoked immideately.
 56 |      * 
 57 |      * Used for the events which only happen once (or do not happen at
 58 |      * all) during a single plugin lifecycle - connect, disconnect and
 59 |      * connection failure
 60 |      */
 61 |     var Whenable = function() {
 62 |         this._emitted = false;
 63 |         this._handlers = [];
 64 |     }
 65 | 
 66 | 
 67 |     /**
 68 |      * Emits the Whenable event, calls all the handlers already
 69 |      * subscribed, switches the object to the 'emitted' state (when
 70 |      * all future subscibed listeners will be immideately issued
 71 |      * instead of being stored)
 72 |      */
 73 |     Whenable.prototype.emit = function(){
 74 |         if (!this._emitted) {
 75 |             this._emitted = true;
 76 | 
 77 |             var handler;
 78 |             while(handler = this._handlers.pop()) {
 79 |                 setTimeout(handler,0);
 80 |             }
 81 |         }
 82 |     }
 83 | 
 84 | 
 85 |     /**
 86 |      * Saves the provided function as a handler for the Whenable
 87 |      * event. This handler will then be called upon the event emission
 88 |      * (if it has not been emitted yet), or will be scheduled for
 89 |      * immediate issue (if the event has already been emmitted before)
 90 |      * 
 91 |      * @param {Function} handler to subscribe for the event
 92 |      */
 93 |     Whenable.prototype.whenEmitted = function(handler){
 94 |         handler = this._checkHandler(handler);
 95 |         if (this._emitted) {
 96 |             setTimeout(handler, 0);
 97 |         } else {
 98 |             this._handlers.push(handler);
 99 |         }
100 |     }
101 | 
102 | 
103 |     /**
104 |      * Checks if the provided object is suitable for being subscribed
105 |      * to the event (= is a function), throws an exception if not
106 |      * 
107 |      * @param {Object} obj to check for being subscribable
108 |      * 
109 |      * @throws {Exception} if object is not suitable for subscription
110 |      * 
111 |      * @returns {Object} the provided object if yes
112 |      */
113 |     Whenable.prototype._checkHandler = function(handler){
114 |         var type = typeof handler;
115 |         if (type != 'function') {
116 |             var msg =
117 |                 'A function may only be subsribed to the event, '
118 |                 + type
119 |                 + ' was provided instead'
120 |             throw new Error(msg);
121 |         }
122 | 
123 |         return handler;
124 |     }
125 | 
126 | 
127 | 
128 |     /**
129 |      * Initializes the library site for Node.js environment (loads
130 |      * _JailedSite.js)
131 |      */
132 |     var initNode = function() {
133 |         require('./_JailedSite.js');
134 |     }
135 | 
136 | 
137 |     /**
138 |      * Initializes the library site for web environment (loads
139 |      * _JailedSite.js)
140 |      */
141 |     var platformInit;
142 |     var initWeb = function() {
143 |         // loads additional script to the application environment
144 |         var load = function(path, cb) {
145 |             var script = document.createElement('script');
146 |             script.src = path;
147 | 
148 |             var clear = function() {
149 |                 script.onload = null;
150 |                 script.onerror = null;
151 |                 script.onreadystatechange = null;
152 |                 script.parentNode.removeChild(script);
153 |             }
154 | 
155 |             var success = function() {
156 |                 clear();
157 |                 cb();
158 |             }
159 | 
160 |             script.onerror = clear;
161 |             script.onload = success;
162 |             script.onreadystatechange = function() {
163 |                 var state = script.readyState;
164 |                 if (state==='loaded' || state==='complete') {
165 |                     success();
166 |                 }
167 |             }
168 | 
169 |             document.body.appendChild(script);
170 |         }
171 | 
172 |         platformInit = new Whenable;
173 |         var origOnload = window.onload || function(){};
174 | 
175 |         window.onload = function(){
176 |             origOnload();
177 |             load(
178 |                 __jailed__path__+'_JailedSite.js',
179 |                 function(){ platformInit.emit(); }
180 |             );
181 |         }
182 |     }
183 | 
184 | 
185 |     var BasicConnection;
186 |       
187 |     /**
188 |      * Creates the platform-dependent BasicConnection object in the
189 |      * Node.js environment
190 |      */
191 |     var basicConnectionNode = function() {
192 |         var childProcess = require('child_process');
193 | 
194 |         /**
195 |          * Platform-dependent implementation of the BasicConnection
196 |          * object, initializes the plugin site and provides the basic
197 |          * messaging-based connection with it
198 |          * 
199 |          * For Node.js the plugin is created as a forked process
200 |          */
201 |         BasicConnection = function() {
202 |             // in Node.js always has a subprocess
203 |             this.dedicatedThread = true;
204 |             this._disconnected = false;
205 |             this._messageHandler = function(){};
206 |             this._disconnectHandler = function(){};
207 | 
208 |             this._process = childProcess.fork(
209 |                 __jailed__path__+'_pluginNode.js'
210 |             );
211 | 
212 |             var me = this;
213 |             this._process.on('message', function(m){
214 |                 me._messageHandler(m);
215 |             });
216 | 
217 |             this._process.on('exit', function(m){
218 |                 me._disconnected = true;
219 |                 me._disconnectHandler(m);
220 |             });
221 |         }
222 | 
223 | 
224 |         /**
225 |          * Sets-up the handler to be called upon the BasicConnection
226 |          * initialization is completed.
227 |          * 
228 |          * For Node.js the connection is fully initialized within the
229 |          * constructor, so simply calls the provided handler.
230 |          * 
231 |          * @param {Function} handler to be called upon connection init
232 |          */
233 |         BasicConnection.prototype.whenInit = function(handler) {
234 |             handler();
235 |         }
236 | 
237 | 
238 |         /**
239 |          * Sends a message to the plugin site
240 |          * 
241 |          * @param {Object} data to send
242 |          */
243 |         BasicConnection.prototype.send = function(data) {
244 |             if (!this._disconnected) {
245 |                 this._process.send(data);
246 |             }
247 |         }
248 | 
249 | 
250 |         /**
251 |          * Adds a handler for a message received from the plugin site
252 |          * 
253 |          * @param {Function} handler to call upon a message
254 |          */
255 |         BasicConnection.prototype.onMessage = function(handler) {
256 |             this._messageHandler = function(data) {
257 |                 // broken stack would break the IPC in Node.js
258 |                 try {
259 |                     handler(data);
260 |                 } catch (e) {
261 |                     console.error();
262 |                     console.error(e.stack);
263 |                 }
264 |             }
265 |         }
266 | 
267 | 
268 |         /**
269 |          * Adds a handler for the event of plugin disconnection
270 |          * (= plugin process exit)
271 |          * 
272 |          * @param {Function} handler to call upon a disconnect
273 |          */
274 |         BasicConnection.prototype.onDisconnect = function(handler) {
275 |             this._disconnectHandler = handler;
276 |         }
277 | 
278 | 
279 |         /**
280 |          * Disconnects the plugin (= kills the forked process)
281 |          */
282 |         BasicConnection.prototype.disconnect = function() {
283 |             this._process.kill('SIGKILL');
284 |             this._disconnected = true;
285 |         }
286 | 
287 |     }
288 | 
289 | 
290 |     /**
291 |      * Creates the platform-dependent BasicConnection object in the
292 |      * web-browser environment
293 |      */
294 |     var basicConnectionWeb = function() {
295 |         var perm = ['allow-scripts'];
296 | 
297 |         if (__jailed__path__.substr(0,7).toLowerCase() == 'file://') {
298 |             // local instance requires extra permission
299 |             perm.push('allow-same-origin');
300 |         }
301 | 
302 |         // frame element to be cloned
303 |         var sample = document.createElement('iframe');
304 |         sample.src = __jailed__path__ + '_frame.html';
305 |         sample.sandbox = perm.join(' ');
306 |         sample.style.display = 'none';
307 | 
308 | 
309 |         /**
310 |          * Platform-dependent implementation of the BasicConnection
311 |          * object, initializes the plugin site and provides the basic
312 |          * messaging-based connection with it
313 |          * 
314 |          * For the web-browser environment, the plugin is created as a
315 |          * Worker in a sandbaxed frame
316 |          */
317 |         BasicConnection = function() {
318 |             this._init = new Whenable;
319 |             this._disconnected = false;
320 | 
321 |             var me = this;
322 |             platformInit.whenEmitted(function() {
323 |                 if (!me._disconnected) {
324 |                     me._frame = sample.cloneNode(false);
325 |                     document.body.appendChild(me._frame);
326 | 
327 |                     window.addEventListener('message', function (e) {
328 |                         if (e.source === me._frame.contentWindow) {
329 |                             if (e.data.type == 'initialized') {
330 |                                 me.dedicatedThread =
331 |                                     e.data.dedicatedThread;
332 |                                 me._init.emit();
333 |                             } else {
334 |                                 me._messageHandler(e.data);
335 |                             }
336 |                         }
337 |                     });
338 |                 }
339 |             });
340 |         }
341 |         
342 |         
343 |         /**
344 |          * Sets-up the handler to be called upon the BasicConnection
345 |          * initialization is completed.
346 |          * 
347 |          * For the web-browser environment, the handler is issued when
348 |          * the plugin worker successfully imported and executed the
349 |          * _pluginWebWorker.js or _pluginWebIframe.js, and replied to
350 |          * the application site with the initImprotSuccess message.
351 |          * 
352 |          * @param {Function} handler to be called upon connection init
353 |          */
354 |         BasicConnection.prototype.whenInit = function(handler) {
355 |             this._init.whenEmitted(handler);
356 |         }
357 | 
358 | 
359 |         /**
360 |          * Sends a message to the plugin site
361 |          * 
362 |          * @param {Object} data to send
363 |          */
364 |         BasicConnection.prototype.send = function(data) {
365 |             this._frame.contentWindow.postMessage(
366 |                 {type: 'message', data: data}, '*'
367 |             );
368 |         }
369 | 
370 | 
371 |         /**
372 |          * Adds a handler for a message received from the plugin site
373 |          * 
374 |          * @param {Function} handler to call upon a message
375 |          */
376 |         BasicConnection.prototype.onMessage = function(handler) {
377 |             this._messageHandler = handler;
378 |         }
379 | 
380 | 
381 |         /**
382 |          * Adds a handler for the event of plugin disconnection
383 |          * (not used in case of Worker)
384 |          * 
385 |          * @param {Function} handler to call upon a disconnect
386 |          */
387 |         BasicConnection.prototype.onDisconnect = function(){};
388 | 
389 | 
390 |         /**
391 |          * Disconnects the plugin (= kills the frame)
392 |          */
393 |         BasicConnection.prototype.disconnect = function() {
394 |             if (!this._disconnected) {
395 |                 this._disconnected = true;
396 |                 if (typeof this._frame != 'undefined') {
397 |                     this._frame.parentNode.removeChild(this._frame);
398 |                 }  // otherwise farme is not yet created
399 |             }
400 |         }
401 | 
402 |     }
403 | 
404 | 
405 |     if (__is__node__) {
406 |         initNode();
407 |         basicConnectionNode();
408 |     } else {
409 |         initWeb();
410 |         basicConnectionWeb();
411 |     }
412 | 
413 | 
414 |       
415 |     /**
416 |      * Application-site Connection object constructon, reuses the
417 |      * platform-dependent BasicConnection declared above in order to
418 |      * communicate with the plugin environment, implements the
419 |      * application-site protocol of the interraction: provides some
420 |      * methods for loading scripts and executing the given code in the
421 |      * plugin
422 |      */
423 |     var Connection = function(){
424 |         this._platformConnection = new BasicConnection;
425 | 
426 |         this._importCallbacks = {};
427 |         this._executeSCb = function(){};
428 |         this._executeFCb = function(){};
429 |         this._messageHandler = function(){};
430 | 
431 |         var me = this;
432 |         this.whenInit = function(cb){
433 |             me._platformConnection.whenInit(cb);
434 |         };
435 | 
436 |         this._platformConnection.onMessage(function(m) {
437 |             switch(m.type) {
438 |             case 'message':
439 |                 me._messageHandler(m.data);
440 |                 break;
441 |             case 'importSuccess':
442 |                 me._handleImportSuccess(m.url);
443 |                 break;
444 |             case 'importFailure':
445 |                 me._handleImportFailure(m.url);
446 |                 break;
447 |             case 'executeSuccess':
448 |                 me._executeSCb();
449 |                 break;
450 |             case 'executeFailure':
451 |                 me._executeFCb();
452 |                 break;
453 |             }
454 |         });
455 |     }
456 | 
457 | 
458 |     /**
459 |      * @returns {Boolean} true if a connection obtained a dedicated
460 |      * thread (subprocess in Node.js or a subworker in browser) and
461 |      * therefore will not hang up on the infinite loop in the
462 |      * untrusted code
463 |      */
464 |     Connection.prototype.hasDedicatedThread = function() {
465 |         return this._platformConnection.dedicatedThread;
466 |     }
467 | 
468 | 
469 |     /**
470 |      * Tells the plugin to load a script with the given path, and to
471 |      * execute it. Callbacks executed upon the corresponding responce
472 |      * message from the plugin site
473 |      * 
474 |      * @param {String} path of a script to load
475 |      * @param {Function} sCb to call upon success
476 |      * @param {Function} fCb to call upon failure
477 |      */
478 |     Connection.prototype.importScript = function(path, sCb, fCb) {
479 |         var f = function(){};
480 |         this._importCallbacks[path] = {sCb: sCb||f, fCb: fCb||f};
481 |         this._platformConnection.send({type: 'import', url: path});
482 |     }
483 |       
484 | 
485 |     /**
486 |      * Tells the plugin to load a script with the given path, and to
487 |      * execute it in the JAILED environment. Callbacks executed upon
488 |      * the corresponding responce message from the plugin site
489 |      * 
490 |      * @param {String} path of a script to load
491 |      * @param {Function} sCb to call upon success
492 |      * @param {Function} fCb to call upon failure
493 |      */
494 |     Connection.prototype.importJailedScript = function(path, sCb, fCb) {
495 |         var f = function(){};
496 |         this._importCallbacks[path] = {sCb: sCb||f, fCb: fCb||f};
497 |         this._platformConnection.send({type: 'importJailed', url: path});
498 |     }
499 | 
500 | 
501 |     /**
502 |      * Sends the code to the plugin site in order to have it executed
503 |      * in the JAILED enviroment. Assuming the execution may only be
504 |      * requested once by the Plugin object, which means a single set
505 |      * of callbacks is enough (unlike importing additional scripts)
506 |      * 
507 |      * @param {String} code code to execute
508 |      * @param {Function} sCb to call upon success
509 |      * @param {Function} fCb to call upon failure
510 |      */
511 |     Connection.prototype.execute = function(code, sCb, fCb) {
512 |         this._executeSCb = sCb||function(){};
513 |         this._executeFCb = fCb||function(){};
514 |         this._platformConnection.send({type: 'execute', code: code});
515 |     }
516 | 
517 | 
518 |     /**
519 |      * Adds a handler for a message received from the plugin site
520 |      * 
521 |      * @param {Function} handler to call upon a message
522 |      */
523 |     Connection.prototype.onMessage = function(handler) {
524 |         this._messageHandler = handler;
525 |     }
526 |       
527 |       
528 |     /**
529 |      * Adds a handler for a disconnect message received from the
530 |      * plugin site
531 |      * 
532 |      * @param {Function} handler to call upon disconnect
533 |      */
534 |     Connection.prototype.onDisconnect = function(handler) {
535 |         this._platformConnection.onDisconnect(handler);
536 |     }
537 | 
538 | 
539 |     /**
540 |      * Sends a message to the plugin
541 |      * 
542 |      * @param {Object} data of the message to send
543 |      */
544 |     Connection.prototype.send = function(data) {
545 |         this._platformConnection.send({
546 |             type: 'message',
547 |             data: data
548 |         });
549 |     }
550 | 
551 | 
552 |     /**
553 |      * Handles import succeeded message from the plugin
554 |      * 
555 |      * @param {String} url of a script loaded by the plugin
556 |      */
557 |     Connection.prototype._handleImportSuccess = function(url) {
558 |         var sCb = this._importCallbacks[url].sCb;
559 |         this._importCallbacks[url] = null;
560 |         delete this._importCallbacks[url];
561 |         sCb();
562 |     }
563 | 
564 | 
565 |     /**
566 |      * Handles import failure message from the plugin
567 |      * 
568 |      * @param {String} url of a script loaded by the plugin
569 |      */
570 |     Connection.prototype._handleImportFailure = function(url) {
571 |         var fCb = this._importCallbacks[url].fCb;
572 |         this._importCallbacks[url] = null;
573 |         delete this._importCallbacks[url];
574 |         fCb();
575 |     }
576 | 
577 | 
578 |     /**
579 |      * Disconnects the plugin when it is not needed anymore
580 |      */
581 |     Connection.prototype.disconnect = function() {
582 |         this._platformConnection.disconnect();
583 |     }
584 | 
585 | 
586 | 
587 | 
588 |     /**
589 |      * Plugin constructor, represents a plugin initialized by a script
590 |      * with the given path
591 |      * 
592 |      * @param {String} url of a plugin source
593 |      * @param {Object} _interface to provide for the plugin
594 |      */
595 |     var Plugin = function(url, _interface) {
596 |         this._path = url;
597 |         this._initialInterface = _interface||{};
598 |         this._connect();
599 |     };
600 | 
601 | 
602 |     /**
603 |      * DynamicPlugin constructor, represents a plugin initialized by a
604 |      * string containing the code to be executed
605 |      * 
606 |      * @param {String} code of the plugin
607 |      * @param {Object} _interface to provide to the plugin
608 |      */
609 |     var DynamicPlugin = function(code, _interface) {
610 |         this._code = code;
611 |         this._initialInterface = _interface||{};
612 |         this._connect();
613 |     };
614 | 
615 | 
616 |     /**
617 |      * Creates the connection to the plugin site
618 |      */
619 |     DynamicPlugin.prototype._connect =
620 |            Plugin.prototype._connect = function() {
621 |         this.remote = null;
622 | 
623 |         this._connect    = new Whenable;
624 |         this._fail       = new Whenable;
625 |         this._disconnect = new Whenable;
626 |                
627 |         var me = this;
628 |                
629 |         // binded failure callback
630 |         this._fCb = function(){
631 |             me._fail.emit();
632 |             me.disconnect();
633 |         }
634 |                
635 |         this._connection = new Connection;
636 |         this._connection.whenInit(function(){
637 |             me._init();
638 |         });
639 |     }
640 | 
641 | 
642 |     /**
643 |      * Creates the Site object for the plugin, and then loads the
644 |      * common routines (_JailedSite.js)
645 |      */
646 |     DynamicPlugin.prototype._init =
647 |            Plugin.prototype._init = function() {
648 |         this._site = new JailedSite(this._connection);
649 |                
650 |         var me = this;
651 |         this._site.onDisconnect(function() {
652 |             me._disconnect.emit();
653 |         });
654 | 
655 |         var sCb = function() {
656 |             me._loadCore();
657 |         }
658 | 
659 |         this._connection.importScript(
660 |             __jailed__path__+'_JailedSite.js', sCb, this._fCb
661 |         );
662 |     }
663 | 
664 | 
665 |     /**
666 |      * Loads the core scirpt into the plugin
667 |      */
668 |     DynamicPlugin.prototype._loadCore =
669 |            Plugin.prototype._loadCore = function() {
670 |         var me = this;
671 |         var sCb = function() {
672 |             me._sendInterface();
673 |         }
674 | 
675 |         this._connection.importScript(
676 |             __jailed__path__+'_pluginCore.js', sCb, this._fCb
677 |         );
678 |     }
679 |     
680 |     
681 |     /**
682 |      * Sends to the remote site a signature of the interface provided
683 |      * upon the Plugin creation
684 |      */
685 |     DynamicPlugin.prototype._sendInterface =
686 |            Plugin.prototype._sendInterface = function() {
687 |         var me = this;
688 |         this._site.onInterfaceSetAsRemote(function() {
689 |             if (!me._connected) {
690 |                 me._loadPlugin();
691 |             }
692 |         });
693 | 
694 |         this._site.setInterface(this._initialInterface);
695 |     }
696 |     
697 |     
698 |     /**
699 |      * Loads the plugin body (loads the plugin url in case of the
700 |      * Plugin)
701 |      */
702 |     Plugin.prototype._loadPlugin = function() {
703 |         var me = this;
704 |         var sCb = function() {
705 |             me._requestRemote();
706 |         }
707 | 
708 |         this._connection.importJailedScript(this._path, sCb, this._fCb);
709 |     }
710 |     
711 |     
712 |     /**
713 |      * Loads the plugin body (executes the code in case of the
714 |      * DynamicPlugin)
715 |      */
716 |     DynamicPlugin.prototype._loadPlugin = function() {
717 |         var me = this;
718 |         var sCb = function() {
719 |             me._requestRemote();
720 |         }
721 | 
722 |         this._connection.execute(this._code, sCb, this._fCb);
723 |     }
724 |     
725 |     
726 |     /**
727 |      * Requests the remote interface from the plugin (which was
728 |      * probably set by the plugin during its initialization), emits
729 |      * the connect event when done, then the plugin is fully usable
730 |      * (meaning both the plugin and the application can use the
731 |      * interfaces provided to each other)
732 |      */
733 |     DynamicPlugin.prototype._requestRemote = 
734 |            Plugin.prototype._requestRemote = function() {
735 |         var me = this;
736 |         this._site.onRemoteUpdate(function(){
737 |             me.remote = me._site.getRemote();
738 |             me._connect.emit();
739 |         });
740 | 
741 |         this._site.requestRemote();
742 |     }
743 | 
744 | 
745 |     /**
746 |      * @returns {Boolean} true if a plugin runs on a dedicated thread
747 |      * (subprocess in Node.js or a subworker in browser) and therefore
748 |      * will not hang up on the infinite loop in the untrusted code
749 |      */
750 |     DynamicPlugin.prototype.hasDedicatedThread =
751 |            Plugin.prototype.hasDedicatedThread = function() {
752 |         return this._connection.hasDedicatedThread();
753 |     }
754 | 
755 |     
756 |     /**
757 |      * Disconnects the plugin immideately
758 |      */
759 |     DynamicPlugin.prototype.disconnect = 
760 |            Plugin.prototype.disconnect = function() {
761 |         this._connection.disconnect();
762 |         this._disconnect.emit();
763 |     }
764 |    
765 |     
766 |     /**
767 |      * Saves the provided function as a handler for the connection
768 |      * failure Whenable event
769 |      * 
770 |      * @param {Function} handler to be issued upon disconnect
771 |      */
772 |     DynamicPlugin.prototype.whenFailed = 
773 |            Plugin.prototype.whenFailed = function(handler) {
774 |         this._fail.whenEmitted(handler);
775 |     }
776 | 
777 | 
778 |     /**
779 |      * Saves the provided function as a handler for the connection
780 |      * success Whenable event
781 |      * 
782 |      * @param {Function} handler to be issued upon connection
783 |      */
784 |     DynamicPlugin.prototype.whenConnected = 
785 |            Plugin.prototype.whenConnected = function(handler) {
786 |         this._connect.whenEmitted(handler);
787 |     }
788 |     
789 |     
790 |     /**
791 |      * Saves the provided function as a handler for the connection
792 |      * failure Whenable event
793 |      * 
794 |      * @param {Function} handler to be issued upon connection failure
795 |      */
796 |     DynamicPlugin.prototype.whenDisconnected = 
797 |            Plugin.prototype.whenDisconnected = function(handler) {
798 |         this._disconnect.whenEmitted(handler);
799 |     }
800 |     
801 |     
802 |     
803 |     exports.Plugin = Plugin;
804 |     exports.DynamicPlugin = DynamicPlugin;
805 |   
806 | }));
807 | 
808 | 


--------------------------------------------------------------------------------
/tests/tests.js:
--------------------------------------------------------------------------------
   1 | var __is__node__ = ((typeof process !== 'undefined') &&
   2 |                     (!process.browser) &&
   3 |                     (process.release.name.search(/node|io.js/) !== -1));
   4 | var currentPath;
   5 | 
   6 | var whenFailed = function(){
   7 |     lighttest.check(false);
   8 |     lighttest.done();
   9 | }
  10 | 
  11 | if (__is__node__) {
  12 |     currentPath = __dirname + '/';
  13 | } else {
  14 |     var scripts = document.getElementsByTagName('script');
  15 |     currentPath = scripts[scripts.length-1].src
  16 |         .split('?')[0]
  17 |         .split('/')
  18 |         .slice(0, -1)
  19 |         .join('/')+'/';
  20 | }
  21 | 
  22 | 
  23 | var tests = {
  24 | 
  25 |     'Initialization':
  26 |     function() {
  27 |         lighttest.check(
  28 |             jailed &&
  29 |             jailed.Plugin &&
  30 |             jailed.DynamicPlugin
  31 |         );
  32 | 
  33 | //        lighttest.check(false);
  34 | 
  35 |         lighttest.done();
  36 |     },
  37 | 
  38 |     'Static plugin':
  39 |     function() {
  40 |         var api = {
  41 |             callMe : lighttest.protect(function() {
  42 |                 plugin.disconnect();
  43 |                 lighttest.check(true);
  44 |                 lighttest.done();
  45 |             })
  46 |         };
  47 | 
  48 |         var path = currentPath + 'stage01/plugin1.js';
  49 |         var plugin = new jailed.Plugin(path, api);
  50 |         plugin.whenFailed(whenFailed);
  51 |     },
  52 | 
  53 | 
  54 |     'Dynamic plugin':
  55 |     function() {
  56 |         var api = {
  57 |             callMe : lighttest.protect(function() {
  58 |                 plugin.disconnect();
  59 |                 lighttest.check(true);
  60 |                 lighttest.done();
  61 |             })
  62 |         };
  63 | 
  64 |         var code = 'application.remote.callMe();';
  65 |         var plugin = new jailed.DynamicPlugin(code, api);
  66 |         plugin.whenFailed(whenFailed);
  67 |     },
  68 | 
  69 |                     
  70 |     'Application API':
  71 |     function() {
  72 |         var api = {
  73 |             square : lighttest.protect(function(val, cb) {
  74 |                 cb(val*val);
  75 |             }),
  76 |             report : lighttest.protect(function(result) {
  77 |                 plugin.disconnect();
  78 |                 lighttest.check(result == 4);
  79 |                 lighttest.done();
  80 |             })
  81 |         };
  82 | 
  83 |         var path = currentPath + 'stage02/plugin2.js';
  84 |         var plugin = new jailed.Plugin(path, api);
  85 |         plugin.whenFailed(whenFailed);
  86 |     },
  87 | 
  88 |                     
  89 |     'Plugin API':
  90 |     function() {
  91 |         var init = lighttest.protect(function() {
  92 |             var val = 2;
  93 | 
  94 |             var cb = lighttest.protect(function(result) {
  95 |                 plugin.disconnect();
  96 |                 lighttest.check(result == val*val);
  97 |                 lighttest.done();
  98 |             });
  99 | 
 100 |             plugin.remote.square(val, cb);
 101 |         });
 102 | 
 103 |         var plugin = new jailed.Plugin(currentPath + 'stage03/plugin3.js');
 104 |         plugin.whenFailed(whenFailed);
 105 |         plugin.whenConnected(init);
 106 |     },
 107 | 
 108 |                     
 109 |     'Bidirectional communication initiated by the application':
 110 |     function() {
 111 |         var path = currentPath + 'stage04/plugin4.js';
 112 |         var waitCalled = false;
 113 | 
 114 |         var api = {
 115 |             wait : lighttest.protect(function(cb) {
 116 |                 waitCalled = true;
 117 |                 setTimeout(cb, 1000);
 118 |             })
 119 |         };
 120 | 
 121 |         var init = lighttest.protect(function() {
 122 |             var val = 2;
 123 | 
 124 |             var cb = lighttest.protect(function(result) {
 125 |                 plugin.disconnect();
 126 |                 lighttest.check(waitCalled);
 127 |                 lighttest.check(result == val*val);
 128 |                 lighttest.done();
 129 |             });
 130 | 
 131 |             plugin.remote.squareDelayed(val, cb);
 132 |         });
 133 | 
 134 |         var plugin = new jailed.Plugin(path, api);
 135 |         plugin.whenFailed(whenFailed);
 136 |         plugin.whenConnected(init);
 137 |     },
 138 | 
 139 |                     
 140 |     'Bidirectional communication initiated by the plugin':
 141 |     function() {
 142 |         var path = currentPath + 'stage05/plugin5.js';
 143 | 
 144 |         var api = {
 145 |             squareDelayed : lighttest.protect(function(val, cb) {
 146 |                 var cb1 = lighttest.protect(function() {
 147 |                     cb(val*val);
 148 |                 });
 149 | 
 150 |                 plugin.remote.wait(cb1);
 151 |             }),
 152 |             report : lighttest.protect(function(result, waitCalled) {
 153 |                 plugin.disconnect();
 154 |                 lighttest.check(result == 4);
 155 |                 lighttest.check(waitCalled);
 156 |                 lighttest.done();
 157 |             })
 158 |         };
 159 | 
 160 |         var plugin = new jailed.Plugin(path, api);
 161 |         plugin.whenFailed(whenFailed);
 162 |     },
 163 | 
 164 |                     
 165 |     'Loading several plugins at once':
 166 |     function() {
 167 |         var path1 = currentPath + 'stage06/plugin6_1.js';
 168 |         var path2 = currentPath + 'stage06/plugin6_2.js';
 169 | 
 170 |         var replied1 = false;
 171 |         var replied2 = false;
 172 |         
 173 |         var finalize = lighttest.protect(function() {
 174 |             if (replied1 && replied2) {
 175 |                 lighttest.check(true);
 176 |                 lighttest.done();
 177 |             }
 178 |         });
 179 | 
 180 |         var init1 = lighttest.protect(function() {
 181 |             var val = 2;
 182 |             var cb = lighttest.protect(function(result) {
 183 |                 replied1 = true;
 184 |                 plugin1.disconnect();
 185 |                 lighttest.check(result == val*val);
 186 |                 finalize();
 187 |             });
 188 | 
 189 |             plugin1.remote.square(val, cb);
 190 |         });
 191 | 
 192 |         var init2 = lighttest.protect(function() {
 193 |             var val = 3;
 194 |             var cb = function(result) {
 195 |                 replied2 = true;
 196 |                 plugin2.disconnect();
 197 |                 lighttest.check(result == val*val);
 198 |                 finalize();
 199 |             }
 200 | 
 201 |             plugin2.remote.square(val, cb);
 202 |         });
 203 | 
 204 |         var plugin1 = new jailed.Plugin(path1);
 205 |         var plugin2 = new jailed.Plugin(path2);
 206 | 
 207 |         plugin1.whenFailed(whenFailed);
 208 |         plugin2.whenFailed(whenFailed);
 209 | 
 210 |         plugin1.whenConnected(init1);
 211 |         plugin2.whenConnected(init2);
 212 |     },
 213 |                     
 214 |                     
 215 |     'Using the plugin during a period':
 216 |     function() {
 217 |         var path = currentPath + 'stage07/plugin7.js';
 218 | 
 219 |         var init = lighttest.protect(function() {
 220 |             var val1 = 2;
 221 |             var cb1 = lighttest.protect(function(result) {
 222 |                 lighttest.check(result == val1*val1);
 223 | 
 224 |                 setTimeout(step2, 1000);
 225 |             });
 226 | 
 227 |             var step2 = lighttest.protect(function(){
 228 |                 var val2 = 3;
 229 |                 var cb2 = lighttest.protect(function(result) {
 230 |                     plugin.disconnect();
 231 |                     lighttest.check(result == val2*val2);
 232 |                     lighttest.done();
 233 |                 });
 234 | 
 235 |                 plugin.remote.square(val2, cb2);
 236 |             });
 237 | 
 238 |             plugin.remote.square(val1, cb1);
 239 |         });
 240 | 
 241 |         var plugin = new jailed.Plugin(path);
 242 |         plugin.whenFailed(whenFailed);
 243 |         plugin.whenConnected(init);
 244 |     },
 245 | 
 246 |                     
 247 |     'Using the application during a period':
 248 |     function() {
 249 |         var path = currentPath + 'stage08/plugin8.js';
 250 | 
 251 |         var api = {
 252 |             square: lighttest.protect(function(val, cb){
 253 |                 cb(val*val);
 254 |             }),
 255 |             check : lighttest.protect(function(result){
 256 |                 lighttest.check(result);
 257 |             }),
 258 |             done : lighttest.protect(function() {
 259 |                 plugin.disconnect();
 260 |                 lighttest.check(true);
 261 |                 lighttest.done();
 262 |             })
 263 |         }
 264 | 
 265 |         var plugin = new jailed.Plugin(path, api);
 266 |         plugin.whenFailed(whenFailed);
 267 |     },
 268 |                     
 269 |                     
 270 |     'Using the plugin several times':
 271 |     function() {
 272 |         var path = currentPath + 'stage09/plugin9.js';
 273 |         var attempt = 1;
 274 |         var api1 = {
 275 |             checkAttempt : lighttest.protect(function(cb) {
 276 |                 lighttest.check(attempt == 1);
 277 |                 cb();
 278 |             }),
 279 |             done : lighttest.protect(function() {
 280 |                 plugin1.disconnect();
 281 |                 lighttest.check(true);
 282 |                 step2();
 283 |             })
 284 |         }
 285 | 
 286 |         var step2 = lighttest.protect(function() {
 287 |             attempt = 2;
 288 |             
 289 |             var api2 = {
 290 |                 checkAttempt : lighttest.protect(function(cb) {
 291 |                     lighttest.check(attempt == 2);
 292 |                     cb();
 293 |                 }),
 294 |                 done : lighttest.protect(function() {
 295 |                     plugin2.disconnect();
 296 |                     lighttest.check(true);
 297 |                     lighttest.done();
 298 |                 })
 299 |             }
 300 | 
 301 |             var plugin2 = new jailed.Plugin(path, api2);
 302 |             plugin2.whenFailed(whenFailed);
 303 |         });
 304 | 
 305 |         var plugin1 = new jailed.Plugin(path, api1);
 306 |         plugin1.whenFailed(whenFailed);
 307 |     },
 308 |                     
 309 |                     
 310 | 
 311 |     'Two plugins with the same source but different interface':
 312 |     function() {
 313 |         var path = currentPath + 'stage10/plugin10.js';
 314 | 
 315 |         var done1 = false;
 316 |         var done2 = false;
 317 | 
 318 |         var api1 = {
 319 |             getNum : lighttest.protect(function(cb){
 320 |                 cb(1);
 321 |             }),
 322 |             report : lighttest.protect(function(result, cb) {
 323 |                 lighttest.check(result == 1);
 324 |                 cb();
 325 |             }),
 326 |             done : lighttest.protect(function() {
 327 |                 done1 = true;
 328 |                 finalize();
 329 |             })
 330 |         };
 331 | 
 332 | 
 333 |         var api2 = {
 334 |             getNum : lighttest.protect(function(cb){
 335 |                 cb(2);
 336 |             }),
 337 |             report : lighttest.protect(function(result, cb) {
 338 |                 lighttest.check(result == 2);
 339 |                 cb();
 340 |             }),
 341 |             done : lighttest.protect(function() {
 342 |                 done2 = true;
 343 |                 finalize();
 344 |             })
 345 |         };
 346 | 
 347 |         var finalize = lighttest.protect(function() {
 348 |             if (done1 && done2) {
 349 |                 plugin1.disconnect();
 350 |                 plugin2.disconnect();
 351 |                 lighttest.check(true);
 352 |                 lighttest.done();
 353 |             }
 354 |         });
 355 | 
 356 |         var plugin1 = new jailed.Plugin(path, api1);
 357 |         var plugin2 = new jailed.Plugin(path, api2);
 358 |         plugin1.whenFailed(whenFailed);
 359 |         plugin2.whenFailed(whenFailed);
 360 |     },
 361 |     
 362 | 
 363 |                     
 364 |     'Plugin disconnected right after creation':
 365 |     function() {
 366 | 
 367 |         var fail = lighttest.protect(
 368 |             function() {
 369 |                 plugin.disconnect();
 370 |                 lighttest.check(false);
 371 |                 lighttest.done();
 372 |             }
 373 |         );
 374 | 
 375 |         var disconnected = false;
 376 |         var disconnect = lighttest.protect(
 377 |             function() {
 378 |                 disconnected = true;
 379 |                 lighttest.check(true);
 380 |             }
 381 |         );
 382 | 
 383 |         var finalize = lighttest.protect(
 384 |             function() {
 385 |                 lighttest.check(disconnected);
 386 |                 lighttest.done();
 387 |             }
 388 |         );
 389 | 
 390 |         var path = currentPath + 'stage11/plugin11.js';
 391 |         var plugin = new jailed.Plugin(path);
 392 |         plugin.whenConnected(fail);
 393 |         plugin.whenDisconnected(disconnect);
 394 |         plugin.whenFailed(whenFailed);
 395 |         plugin.disconnect();
 396 |         setTimeout(finalize, 1000);
 397 |     },
 398 | 
 399 | 
 400 | 
 401 |     'Plugin disconnected after connection':
 402 |     function() {
 403 | 
 404 |         var fail = lighttest.protect(
 405 |             function() {
 406 |                 plugin.disconnect();
 407 |                 lighttest.check(false);
 408 |                 lighttest.done();
 409 |             }
 410 |         );
 411 |         
 412 |         var connect = lighttest.protect(
 413 |             function() {
 414 |                 lighttest.check(true);
 415 |                 plugin.disconnect();
 416 |                 setTimeout(finalize, 1000);
 417 |             }
 418 |         );
 419 | 
 420 |         var disconnected = false;
 421 |         var disconnect = lighttest.protect(
 422 |             function() {
 423 |                 disconnected = true;
 424 |                 lighttest.check(true);
 425 |             }
 426 |         );
 427 | 
 428 |         var finalize = lighttest.protect(
 429 |             function() {
 430 |                 lighttest.check(disconnected);
 431 |                 lighttest.done();
 432 |             }
 433 |         );
 434 | 
 435 |         var path = currentPath + 'stage11/plugin11.js';
 436 |         var plugin = new jailed.Plugin(path);
 437 |         plugin.whenConnected(connect);
 438 |         plugin.whenDisconnected(disconnect);
 439 |         plugin.whenFailed(whenFailed);
 440 | 
 441 |     },
 442 | 
 443 | 
 444 |     'Plugin disconnected by its method':
 445 |     function() {
 446 |         var path = currentPath + 'stage11/plugin11.js';
 447 | 
 448 |         var connected = lighttest.protect(function() {
 449 |             lighttest.check(true);
 450 | 
 451 |             var val = 2;
 452 |             var cb = lighttest.protect(function(result) {
 453 |                 lighttest.check(result == val*val);
 454 |                 setTimeout(
 455 |                     lighttest.protect(function() {
 456 |                         plugin.remote.killYourself();
 457 |                     }), 1000
 458 |                 );
 459 |             });
 460 | 
 461 |             plugin.remote.square(val, cb);
 462 |         });
 463 | 
 464 |         var disconnected = lighttest.protect(function() {
 465 |             lighttest.check(true);
 466 |             lighttest.done();
 467 |         });
 468 | 
 469 |         var plugin = new jailed.Plugin(path);
 470 |         plugin.whenConnected(connected);
 471 |         plugin.whenDisconnected(disconnected);
 472 |         plugin.whenFailed(whenFailed);
 473 |     },
 474 | 
 475 |                     
 476 |     'Plugin disconnected during initialization':
 477 |     function() {
 478 |         var path = currentPath + 'stage11/plugin11_1.js';
 479 | 
 480 |         var failed = function() {
 481 |             plugin.disconnect();
 482 |             lighttest.check(false);
 483 |             lighttest.done();
 484 |         }
 485 | 
 486 |         var disconnected = function() {
 487 |             lighttest.check(true);
 488 |             lighttest.done();
 489 |         }
 490 | 
 491 |         var plugin = new jailed.Plugin(path);
 492 |         plugin.whenConnected(failed);
 493 |         plugin.whenFailed(failed);
 494 |         plugin.whenDisconnected(disconnected);
 495 |     },
 496 | 
 497 |                     
 498 |                     
 499 |     'Mixed plugin loading sequence':
 500 |     function() {
 501 |         var path = currentPath + 'stage12/plugin12.js';
 502 |         var plugin1, plugin2;
 503 | 
 504 |         var step1 = lighttest.protect(function() {
 505 |             var val = 2;
 506 |             var cb = lighttest.protect(function(result) {
 507 |                 lighttest.check(result == val*val);
 508 |                 step2();
 509 |             });
 510 | 
 511 |             plugin1.remote.square(val, cb);
 512 |         });
 513 | 
 514 |         var step2 = lighttest.protect(function() {
 515 |             var connected2 = lighttest.protect(function() {
 516 |                 var val = 7;
 517 |                 var cb = lighttest.protect(function(result) {
 518 |                     lighttest.check(result == val*val);
 519 |                     step3();
 520 |                 });
 521 | 
 522 |                 plugin2.remote.square(val, cb);
 523 |             });
 524 | 
 525 |             plugin2 = new jailed.Plugin(path);
 526 |             plugin2.whenConnected(connected2);
 527 |             plugin2.whenFailed(whenFailed);
 528 |         });
 529 | 
 530 |         var step3 = lighttest.protect(function() {
 531 |             plugin1.disconnect();
 532 |             setTimeout(step4, 1000);
 533 |         });
 534 | 
 535 |         var step4 = lighttest.protect(function() {
 536 |             var val = 11;
 537 |             var cb = lighttest.protect(function(result) {
 538 |                 lighttest.check(result == val*val);
 539 |                 finalize();
 540 |             });
 541 | 
 542 |             plugin2.remote.square(val, cb);
 543 |         });
 544 | 
 545 |         var finalize = lighttest.protect(function() {
 546 |             plugin2.disconnect();
 547 |             lighttest.done();
 548 |         });
 549 | 
 550 |         plugin1 = new jailed.Plugin(path);
 551 |         plugin1.whenConnected(step1);
 552 |         plugin1.whenFailed(whenFailed);
 553 |     },
 554 | 
 555 |                     
 556 |     'Executing function with several callbacks':
 557 |     function() {
 558 |         var path = currentPath + 'stage13/plugin13.js';
 559 | 
 560 |         var api = {
 561 |             callMeBack : lighttest.protect(function(success, sCb, fCb) {
 562 |                 if (success) {
 563 |                     sCb();
 564 |                 } else {
 565 |                     fCb();
 566 |                 }
 567 |             }),
 568 |             report : lighttest.protect(function(result, cb) {
 569 |                 lighttest.check(result);
 570 |                 cb();
 571 |             }),
 572 |             done : lighttest.protect(function() {
 573 |                 plugin.disconnect();
 574 |                 lighttest.check(true);
 575 |                 lighttest.done();
 576 |             })
 577 |         }
 578 | 
 579 |         var plugin = new jailed.Plugin(path, api);
 580 |         plugin.whenFailed(whenFailed);
 581 |     },
 582 | 
 583 |     
 584 | 
 585 | 
 586 |     
 587 |     'Remote plugin':
 588 |     function() {
 589 |         var path = 'https://asvd.github.io/jailed/tests/plugin14.js';
 590 | 
 591 |         var api = {
 592 |             square: lighttest.protect(function(val, cb) {
 593 |                 cb(val*val);
 594 |             }),
 595 |             check: lighttest.protect(function(result, cb) {
 596 |                 lighttest.check(result);
 597 |                 cb();
 598 |             }),
 599 |             done: lighttest.protect(function() {
 600 |                 plugin.disconnect();
 601 |                 lighttest.done();
 602 |             })
 603 |         }
 604 | 
 605 |         var plugin = new jailed.Plugin(path, api);
 606 |         plugin.whenFailed(whenFailed);
 607 |     },
 608 | 
 609 | 
 610 |     
 611 |     
 612 |     'Plugin with infinite loop':
 613 |     function() {
 614 |         var pathBad = currentPath + 'stage15/plugin15_bad.js';
 615 |         var pathGood = currentPath + 'stage15/plugin15_good.js';
 616 | 
 617 |         var pluginGood;
 618 |         var pluginBad;
 619 | 
 620 |         var step1 = lighttest.protect(
 621 |             function() {
 622 |                 lighttest.check(true);
 623 | 
 624 |                 if (pluginBad.hasDedicatedThread()) {
 625 |                     var cb = lighttest.protect(
 626 |                         function() {
 627 |                             // should never be called
 628 |                             lighttest.check(false);
 629 |                             pluginBad.disconnect();
 630 |                             lighttest.done();
 631 |                         }
 632 |                     );
 633 | 
 634 |                     pluginBad.remote.infinite(cb);
 635 | 
 636 |                     setTimeout(step2, 2000);
 637 |                 } else {
 638 |                     // thread not obtained because of the browser
 639 |                     pluginBad.disconnect();
 640 |                     lighttest.done();
 641 |                 }
 642 |             }
 643 |         );
 644 | 
 645 |         var step2 = lighttest.protect(
 646 |             function() {
 647 |                 pluginBad.disconnect();
 648 |                 setTimeout(step3, 1000);
 649 |             }
 650 |         );
 651 | 
 652 |         var step3 = lighttest.protect(
 653 |             function() {
 654 |                 lighttest.check(true);
 655 | 
 656 |                 pluginBad = new jailed.Plugin(pathBad);
 657 |                 pluginBad.whenConnected(step4);
 658 |                 pluginBad.whenFailed(whenFailed);
 659 |             }
 660 |         );
 661 | 
 662 |         var step4 = lighttest.protect(
 663 |             function() {
 664 |                 var cb = lighttest.protect(
 665 |                     function() {
 666 |                         // should never be called
 667 |                         lighttest.check(false);
 668 |                         pluginBad.disconnect();
 669 |                         lighttest.done();
 670 |                     }
 671 |                 );
 672 | 
 673 |                 pluginBad.remote.infinite(cb);
 674 | 
 675 |                 setTimeout(step5, 2000);
 676 |             }
 677 |         );
 678 | 
 679 |         var step5 = lighttest.protect(
 680 |             function() {
 681 |                 lighttest.check(true);
 682 | 
 683 |                 pluginGood = new jailed.Plugin(pathGood);
 684 |                 pluginGood.whenConnected(step6);
 685 |                 pluginGood.whenFailed(whenFailed);
 686 |             }
 687 |         );
 688 | 
 689 |         var step6 = lighttest.protect(
 690 |             function() {
 691 |                 var val = 8;
 692 |                 var cb = lighttest.protect(function(result) {
 693 |                     lighttest.check(result == val*val);
 694 |                     pluginGood.disconnect();
 695 |                     pluginBad.disconnect();
 696 |                     lighttest.done();
 697 |                 });
 698 | 
 699 |                 pluginGood.remote.square(val, cb);
 700 |             }
 701 |         );
 702 |         
 703 |         pluginBad = new jailed.Plugin(pathBad);
 704 |         pluginBad.whenConnected(step1);
 705 |         pluginBad.whenFailed(whenFailed);
 706 |     },
 707 |  
 708 |                    
 709 |     'Permission restriction':
 710 |     function() {
 711 |         var path = currentPath + 'stage16/plugin16.js';
 712 | 
 713 |         var api = {
 714 |             check : lighttest.protect(
 715 |                 function(result, cb) {
 716 |                     lighttest.check(result);
 717 |                     cb();
 718 |                 }
 719 |             ),
 720 |             done : lighttest.protect(
 721 |                 function() {
 722 |                     plugin.disconnect();
 723 |                     lighttest.check(true);
 724 |                     lighttest.done();
 725 |                 }
 726 |             )
 727 |         };
 728 | 
 729 |         var plugin = new jailed.Plugin(path, api);
 730 |         plugin.whenFailed(whenFailed);
 731 |     },
 732 |                     
 733 |                     
 734 | 
 735 | 
 736 |     'Broken plugin':
 737 |     function() {
 738 |         var path = currentPath + 'stage17/plugin17.js';
 739 | 
 740 |         var plugin = new jailed.Plugin(path);
 741 | 
 742 |         var fail = lighttest.protect(
 743 |             function() {
 744 |                 plugin.disconnect();
 745 |                 lighttest.check(false);
 746 |                 lighttest.done();
 747 |             }
 748 |         );
 749 |         
 750 |         plugin.whenConnected(fail);
 751 | 
 752 |         plugin.whenFailed(
 753 |             lighttest.protect(
 754 |                 function() {
 755 |                     lighttest.check(true);
 756 |                     lighttest.done();
 757 |                 }
 758 |             )
 759 |         );
 760 |     },
 761 | 
 762 | 
 763 | 
 764 |     'Broken dynamic plugin':
 765 |     function() {
 766 |         var code = 'u';
 767 | //        var code = 'auaa } u((uu&';
 768 | 
 769 |         var plugin = new jailed.DynamicPlugin(code);
 770 | 
 771 |         var connect = lighttest.protect(
 772 |             function() {
 773 |                 plugin.disconnect();
 774 |                 lighttest.check(false);
 775 |                 lighttest.done();
 776 |             }
 777 |         );
 778 | 
 779 |         var disconnected = false;
 780 |         var disconnect = lighttest.protect(
 781 |             function() {
 782 |                 lighttest.check(true);
 783 |                 disconnected = true;
 784 |             }
 785 |         );
 786 | 
 787 |         var failed = false;
 788 |         var fail = lighttest.protect(
 789 |             function() {
 790 |                 lighttest.check(true);
 791 |                 failed = true;
 792 |                 setTimeout(finalize,500);
 793 |             }
 794 |         );
 795 | 
 796 |         var finalize = lighttest.protect(
 797 |             function() {
 798 |                 plugin.disconnect();
 799 |                 lighttest.check(failed&&disconnected);
 800 |                 lighttest.done();
 801 |             }
 802 |         );
 803 | 
 804 |         plugin.whenConnected(connect);
 805 |         plugin.whenDisconnected(disconnect);
 806 |         plugin.whenFailed(fail);
 807 |     },
 808 | 
 809 | 
 810 | 
 811 |     'Broken remote plugin':
 812 |     function() {
 813 |         var path = 'https://asvd.github.io/jailed/tests/plugin18.js';
 814 | 
 815 |         var plugin = new jailed.Plugin(path);
 816 | 
 817 |         var connect = lighttest.protect(
 818 |             function() {
 819 |                 plugin.disconnect();
 820 |                 lighttest.check(false);
 821 |                 lighttest.done();
 822 |             }
 823 |         );
 824 | 
 825 |         var disconnected = false;
 826 |         var disconnect = lighttest.protect(
 827 |             function() {
 828 |                 lighttest.check(true);
 829 |                 disconnected = true;
 830 |             }
 831 |         );
 832 | 
 833 |         var failed = false;
 834 |         var fail = lighttest.protect(
 835 |             function() {
 836 |                 lighttest.check(true);
 837 |                 failed = true;
 838 |                 setTimeout(finalize,500);
 839 |             }
 840 |         );
 841 | 
 842 |         var finalize = lighttest.protect(
 843 |             function() {
 844 |                 plugin.disconnect();
 845 |                 lighttest.check(failed&&disconnected);
 846 |                 lighttest.done();
 847 |             }
 848 |         );
 849 | 
 850 |         plugin.whenConnected(connect);
 851 |         plugin.whenDisconnected(disconnect);
 852 |         plugin.whenFailed(fail);
 853 |     },
 854 | 
 855 |                     
 856 |                     
 857 | 
 858 |     'Nonexisting plugin':
 859 |     function() {
 860 |         var path = currentPath + 'no_such_path.js';
 861 |         var plugin = new jailed.Plugin(path);
 862 | 
 863 |         var connect = lighttest.protect(
 864 |             function() {
 865 |                 plugin.disconnect();
 866 |                 lighttest.check(false);
 867 |                 lighttest.done();
 868 |             }
 869 |         );
 870 | 
 871 |         var disconnected = false;
 872 |         var disconnect = lighttest.protect(
 873 |             function() {
 874 |                 lighttest.check(true);
 875 |                 disconnected = true;
 876 |             }
 877 |         );
 878 | 
 879 |         var failed = false;
 880 |         var fail = lighttest.protect(
 881 |             function() {
 882 |                 lighttest.check(true);
 883 |                 failed = true;
 884 |                 setTimeout(finalize,500);
 885 |             }
 886 |         );
 887 | 
 888 |         var finalize = lighttest.protect(
 889 |             function() {
 890 |                 lighttest.check(failed&&disconnected);
 891 |                 plugin.disconnect();
 892 |                 lighttest.done();
 893 |             }
 894 |         );
 895 | 
 896 |         plugin.whenConnected(connect);
 897 |         plugin.whenDisconnected(disconnect);
 898 |         plugin.whenFailed(fail);
 899 |     },
 900 |                     
 901 | 
 902 |     'Nonexisting remote plugin':
 903 |     function() {
 904 |         var path = 'https://asvd.github.io/no_such_path.js';
 905 |         var plugin = new jailed.Plugin(path);
 906 | 
 907 |         var connect = lighttest.protect(
 908 |             function() {
 909 |                 plugin.disconnect();
 910 |                 lighttest.check(false);
 911 |                 lighttest.done();
 912 |             }
 913 |         );
 914 | 
 915 |         var disconnected = false;
 916 |         var disconnect = lighttest.protect(
 917 |             function() {
 918 |                 lighttest.check(true);
 919 |                 disconnected = true;
 920 |             }
 921 |         );
 922 | 
 923 |         var failed = false;
 924 |         var fail = lighttest.protect(
 925 |             function() {
 926 |                 lighttest.check(true);
 927 |                 failed = true;
 928 |                 setTimeout(finalize,500);
 929 |             }
 930 |         );
 931 | 
 932 |         var finalize = lighttest.protect(
 933 |             function() {
 934 |                 plugin.disconnect();
 935 |                 lighttest.check(failed&&disconnected);
 936 |                 lighttest.done();
 937 |             }
 938 |         );
 939 | 
 940 |         plugin.whenConnected(connect);
 941 |         plugin.whenDisconnected(disconnect);
 942 |         plugin.whenFailed(fail);
 943 |     },
 944 | 
 945 |     
 946 |     'Broken plugin method':
 947 |     function() {
 948 |         var step1 = lighttest.protect(
 949 |             function() {
 950 |                 var cb = lighttest.protect(
 951 |                     function() {
 952 |                         plugin.disconnect();
 953 |                         clearTimeout(timeout);
 954 |                         lighttest.check(false);
 955 |                         lighttest.done();
 956 |                     }
 957 |                 );
 958 | 
 959 |                 plugin.remote.broken(cb);
 960 | 
 961 |                 var timeout = setTimeout(step2, 1000);
 962 |             }
 963 |         );
 964 | 
 965 |         var step2 = lighttest.protect(
 966 |             function() {
 967 |                 var timeout = setTimeout(
 968 |                     lighttest.protect(
 969 |                         function() {
 970 |                             plugin.disconnect();
 971 |                             lighttest.check(false);
 972 |                             lighttest.done();
 973 |                         }
 974 |                     ),
 975 |                     2000
 976 |                 );
 977 | 
 978 |                 var cb = lighttest.protect(
 979 |                     function() {
 980 |                         clearTimeout(timeout);
 981 |                         lighttest.check(true);
 982 |                         step3();
 983 |                     }
 984 |                 );
 985 | 
 986 |                 plugin.remote.brokenDelayed(cb);
 987 |             }
 988 |         );
 989 | 
 990 |         var step3 = lighttest.protect(
 991 |             function() {
 992 |                 var cb = lighttest.protect(
 993 |                     function() {
 994 |                         clearTimeout(timeout);
 995 |                         plugin.disconnect();
 996 |                         lighttest.check(false);
 997 |                         lighttest.done();
 998 |                     }
 999 |                 );
1000 | 
1001 |                 plugin.remote.broken(cb);
1002 |                 var timeout = setTimeout(step4, 500);
1003 |             }
1004 |         );
1005 | 
1006 |         var step4 = lighttest.protect(
1007 |             function() {
1008 |                 var val = 6;
1009 |                 var cb = lighttest.protect(
1010 |                     function(result) {
1011 |                         plugin.disconnect();
1012 |                         lighttest.check(result = val*val);
1013 |                         lighttest.done();
1014 |                     }
1015 |                 );
1016 | 
1017 |                 plugin.remote.square(val, cb);
1018 |             }
1019 |         );
1020 | 
1021 | 
1022 |         var path = currentPath + 'stage19/plugin19.js';
1023 |         var plugin = new jailed.Plugin(path);
1024 |         plugin.whenConnected(step1);
1025 |         plugin.whenFailed(whenFailed);
1026 |     },
1027 | 
1028 |                     
1029 |     'Broken application method':
1030 |     function() {
1031 |         var api = {
1032 |             // intentionally not protected, must fail
1033 |             broken:  function(cb) {
1034 |                 somethingWrong();
1035 |                 cb();
1036 |             },
1037 | 
1038 |             // intentionally not protected, must fail
1039 |             brokenDelayed:  function(cb) {
1040 |                 setTimeout(cb, 500);
1041 |                 somethingWrong();
1042 |             },
1043 | 
1044 |             square: lighttest.protect(
1045 |                 function(val, cb) {
1046 |                     cb(val*val);
1047 |                 }
1048 |             ),
1049 | 
1050 |             check: lighttest.protect(
1051 |                 function(result, cb){
1052 |                     lighttest.check(result);
1053 |                     cb();
1054 |                 }
1055 |             ),
1056 | 
1057 |             done: lighttest.protect(
1058 |                 function(){
1059 |                     plugin.disconnect();
1060 |                     lighttest.done();
1061 |                 }
1062 |             )
1063 |         };
1064 | 
1065 |         var path = currentPath + 'stage20/plugin20.js';
1066 |         var plugin = new jailed.Plugin(path, api);
1067 |         plugin.whenFailed(whenFailed);
1068 |     },
1069 | 
1070 |                     
1071 |                     
1072 |     'Several plugin methods execution':
1073 |     function() {
1074 |         var cubeFinished = false;
1075 |         var squareFinished = false;
1076 | 
1077 |         var step1 = lighttest.protect(
1078 |             function() {
1079 |                 var valCube = 7;
1080 | 
1081 |                 var cbCube = lighttest.protect(
1082 |                     function(result) {
1083 |                         lighttest.check(result == valCube*valCube*valCube);
1084 |                         cubeFinished = true;
1085 |                         finalize();
1086 |                     }
1087 |                 );
1088 | 
1089 |                 plugin.remote.cubeDelayed(valCube, cbCube);
1090 |                 step2();
1091 |             }
1092 |         );
1093 | 
1094 | 
1095 |         
1096 |         var step2 = lighttest.protect(
1097 |             function() {
1098 |                 var val = 8;
1099 | 
1100 |                 var cb = lighttest.protect(
1101 |                     function(result) {
1102 |                         lighttest.check(result == val*val);
1103 |                         squareFinished = true;
1104 |                         finalize();
1105 |                     }
1106 |                 );
1107 | 
1108 |                 plugin.remote.square(val, cb);
1109 |         
1110 |             }
1111 |         );
1112 |         
1113 |         var finalize = lighttest.protect(
1114 |             function() {
1115 |                 if (cubeFinished && squareFinished) {
1116 |                     plugin.disconnect();
1117 |                     lighttest.check(true);
1118 |                     lighttest.done();
1119 |                 }
1120 |             }
1121 |         );
1122 |         
1123 |         var path = currentPath + 'stage21/plugin21.js';
1124 |         var plugin = new jailed.Plugin(path);
1125 |         plugin.whenFailed(whenFailed);
1126 |         plugin.whenConnected(step1);
1127 |     },
1128 | 
1129 |                     
1130 | 
1131 |     'Several application methods execution':
1132 |     function() {
1133 |         var api = {
1134 |             square: lighttest.protect(
1135 |                 function(val, cb) {
1136 |                     cb(val*val);
1137 |                 }
1138 |             ),
1139 |             cubeDelayed: lighttest.protect(
1140 |                 function(val, cb) {
1141 |                     setTimeout(
1142 |                         lighttest.protect(
1143 |                             function() {
1144 |                                 cb(val*val*val);
1145 |                             }
1146 |                         ), 1000
1147 |                     );
1148 |                 }
1149 |             ),
1150 |             check: lighttest.protect(
1151 |                 function(result, cb){
1152 |                     lighttest.check(result);
1153 |                     cb();
1154 |                 }
1155 |             ),
1156 | 
1157 |             done: lighttest.protect(
1158 |                 function(){
1159 |                     plugin.disconnect();
1160 |                     lighttest.done();
1161 |                 }
1162 |             )
1163 |         }
1164 |         
1165 |         var path = currentPath + 'stage22/plugin22.js';
1166 |         var plugin = new jailed.Plugin(path, api);
1167 |         plugin.whenFailed(whenFailed);
1168 |     },
1169 |                     
1170 |     
1171 |     'Plugin method with several callbacks':
1172 |     function() {
1173 |         var step1 = lighttest.protect(
1174 |             function() {
1175 |                 var cb0 = lighttest.protect(
1176 |                     function() {
1177 |                         lighttest.check(false);
1178 |                         step2();
1179 |                     }
1180 |                 );
1181 | 
1182 |                 var cb1 = lighttest.protect(
1183 |                     function() {
1184 |                         lighttest.check(true);
1185 |                         step2();
1186 |                     }
1187 |                 );
1188 | 
1189 |                 plugin.remote.callback(1, cb0, cb1);
1190 |             }
1191 |         );
1192 |         
1193 |         var step2 = lighttest.protect(
1194 |             function() {
1195 |                 var cb0 = lighttest.protect(
1196 |                     function() {
1197 |                         lighttest.check(true);
1198 |                         finalize();
1199 |                     }
1200 |                 );
1201 | 
1202 |                 var cb1 = lighttest.protect(
1203 |                     function() {
1204 |                         lighttest.check(false);
1205 |                         finalize();
1206 |                     }
1207 |                 );
1208 | 
1209 |                 plugin.remote.callback(0, cb0, cb1);
1210 |             }
1211 |         );
1212 | 
1213 |         var finalize = lighttest.protect(
1214 |             function() {
1215 |                 plugin.disconnect();
1216 |                 lighttest.done();
1217 |             }
1218 |         );
1219 |         
1220 |         var path = currentPath + 'stage23/plugin23.js';
1221 |         var plugin = new jailed.Plugin(path);
1222 |         plugin.whenFailed(whenFailed);
1223 |         plugin.whenConnected(step1);
1224 |     },
1225 |                     
1226 | 
1227 | 
1228 |     'Application method with several callbacks':
1229 |     function() {
1230 |         var api = {
1231 |             callback: lighttest.protect(
1232 |                 function(num, cb0, cb1) {
1233 |                     if (num == 0) {
1234 |                         cb0();
1235 |                     } else {
1236 |                         cb1();
1237 |                     }
1238 |                 }
1239 |             ),
1240 | 
1241 |             check: lighttest.protect(
1242 |                 function(result, cb){
1243 |                     lighttest.check(result);
1244 |                     cb();
1245 |                 }
1246 |             ),
1247 | 
1248 |             done: lighttest.protect(
1249 |                 function(){
1250 |                     plugin.disconnect();
1251 |                     lighttest.done();
1252 |                 }
1253 |             )
1254 |         };
1255 |         
1256 |         var path = currentPath + 'stage24/plugin24.js';
1257 |         var plugin = new jailed.Plugin(path, api);
1258 |         plugin.whenFailed(whenFailed);
1259 |     },
1260 | 
1261 | 
1262 |                     
1263 |     'Two-sided communication, initiated by the plugin':
1264 |     function() {
1265 |         var api = {
1266 |             squareDelayed: lighttest.protect(
1267 |                 function(val, cb) {
1268 |                     plugin.remote.wait(
1269 |                         lighttest.protect(
1270 |                             function() {
1271 |                                 cb(val*val);
1272 |                             }
1273 |                         )
1274 |                     );
1275 |                 }
1276 |             ),
1277 | 
1278 |             check: lighttest.protect(
1279 |                 function(result, cb){
1280 |                     lighttest.check(result);
1281 |                     cb();
1282 |                 }
1283 |             ),
1284 | 
1285 |             done: lighttest.protect(
1286 |                 function(){
1287 |                     plugin.disconnect();
1288 |                     lighttest.done();
1289 |                 }
1290 |             )
1291 |         };
1292 | 
1293 |         var path = currentPath + 'stage25/plugin25.js';
1294 |         var plugin = new jailed.Plugin(path, api);
1295 |         plugin.whenFailed(whenFailed);
1296 |     },
1297 | 
1298 | 
1299 |                     
1300 |     'Two-sided communication, initiated by the application':
1301 |     function() {
1302 |         var api = {
1303 |             wait: function(cb) {
1304 |                 setTimeout(cb, 1000);
1305 |             }
1306 |         };
1307 | 
1308 |         var step1 = lighttest.protect(
1309 |             function() {
1310 |                 var val = 54;
1311 |                 var cb = lighttest.protect(
1312 |                     function(result) {
1313 |                         plugin.disconnect();
1314 |                         lighttest.check(result == val*val);
1315 |                         lighttest.done();
1316 |                     }
1317 |                 );
1318 | 
1319 |                 plugin.remote.squareDelayed(val, cb);
1320 |             }
1321 |         );
1322 | 
1323 |         var path = currentPath + 'stage26/plugin26.js';
1324 |         var plugin = new jailed.Plugin(path, api);
1325 |         plugin.whenFailed(whenFailed);
1326 |         plugin.whenConnected(step1);
1327 |     },
1328 | 
1329 | 
1330 |     'Calling plugin callbacks from the same arguments several times':
1331 |     function() {
1332 |         var api = {
1333 |             callme : function(cb0, cb1) {
1334 |                 var step1 =function() {
1335 |                     setTimeout(finalize, 1000);
1336 |                      
1337 |                     try {
1338 |                         cb1();
1339 |                         lighttest.check(false);
1340 |                     } catch(e) {
1341 |                         lighttest.check(true);
1342 |                         throw e;
1343 |                     }
1344 |                 }
1345 | 
1346 |                 setTimeout(step1, 1000);
1347 | 
1348 |                 cb0();
1349 | 
1350 |                 try {
1351 |                     cb0();
1352 |                     lighttest.check(false);
1353 |                 } catch(e) {
1354 |                     lighttest.check(true);
1355 |                     throw e;
1356 |                 }
1357 | 
1358 |             },
1359 | 
1360 |             check: lighttest.protect(
1361 |                 function(result){
1362 |                     lighttest.check(result);
1363 |                 }
1364 |             )
1365 |         }
1366 | 
1367 |         var finalize = lighttest.protect(
1368 |             function() {
1369 |                 plugin.disconnect();
1370 |                 lighttest.done();
1371 |             }
1372 |         );
1373 | 
1374 |         var path = currentPath + 'stage27/plugin27.js';
1375 |         var plugin = new jailed.Plugin(path, api);
1376 |         plugin.whenFailed(whenFailed);
1377 |     },
1378 | 
1379 | 
1380 | 
1381 |     'Calling application callbacks from the same arguments several times':
1382 |     function() {
1383 |         var init = lighttest.protect(
1384 |             function() {
1385 |                 var notYetCalled = true;
1386 |                 var cb = lighttest.protect(
1387 |                     function() {
1388 |                         lighttest.check(notYetCalled);
1389 |                         notYetCalled = false;
1390 |                     }
1391 |                 );
1392 | 
1393 |                 plugin.remote.callme(cb, cb);
1394 |             }
1395 |         );
1396 | 
1397 |         var api = {
1398 |             check: lighttest.protect(
1399 |                 function(result){
1400 |                     lighttest.check(result);
1401 |                 }
1402 |             ),
1403 | 
1404 |             done: lighttest.protect(
1405 |                 function(){
1406 |                     plugin.disconnect();
1407 |                     lighttest.done();
1408 |                 }
1409 |             )
1410 |         }
1411 | 
1412 |         var path = currentPath + 'stage28/plugin28.js';
1413 |         var plugin = new jailed.Plugin(path, api);
1414 |         plugin.whenFailed(whenFailed);
1415 |         plugin.whenConnected(init);
1416 |     },
1417 | 
1418 | 
1419 |     'Delayed plugin error':
1420 |     function() {
1421 |         var init = lighttest.protect(
1422 |             function() {
1423 |                 var cb = lighttest.protect(
1424 |                     function() {
1425 |                         plugin.disconnect();
1426 |                         lighttest.check(true);
1427 |                     }
1428 |                 );
1429 | 
1430 |                 // Node.js child process will exit,
1431 |                 // Worker will throw, but proceed
1432 |                 plugin.remote.brokenDelayed(cb);
1433 |             }
1434 |         );
1435 | 
1436 |         var disconnect = lighttest.protect(
1437 |             function() {
1438 |                 lighttest.check(true);
1439 |                 setTimeout(finalize, 300);
1440 |             }
1441 |         );
1442 | 
1443 |         var finalize = lighttest.protect(
1444 |             function() {
1445 |                 lighttest.done();
1446 |             }
1447 |         );
1448 |         
1449 |         
1450 |         var path = currentPath + 'stage29/plugin29.js';
1451 |         var plugin = new jailed.Plugin(path);
1452 |         plugin.whenFailed(whenFailed);
1453 |         plugin.whenConnected(init);
1454 |         plugin.whenDisconnected(disconnect);
1455 |     },
1456 | 
1457 |     
1458 |     
1459 |     'Subscribing non-functions to events in the application environment':
1460 |     function() {
1461 |         var plugin = new jailed.DynamicPlugin('');
1462 | 
1463 |         var step1 = function() {
1464 |             setTimeout(step2, 100);
1465 |             try {
1466 |                 plugin.whenConnected([]);
1467 |                 lighttest.check(false);
1468 |             } catch (e) {
1469 |                 lighttest.check(true);
1470 |                 throw e;
1471 |             }
1472 |         }
1473 | 
1474 |         var step2 = function() {
1475 |             setTimeout(step3, 100);
1476 |             try {
1477 |                 plugin.whenFailed('something');
1478 |                 lighttest.check(false);
1479 |             } catch (e) {
1480 |                 lighttest.check(true);
1481 |                 throw e;
1482 |             }
1483 |         }
1484 | 
1485 |         var step3 = function() {
1486 |             setTimeout(step4, 100);
1487 |             try {
1488 |                 plugin.whenDisconnected(new Date);
1489 |                 lighttest.check(false);
1490 |             } catch (e) {
1491 |                 lighttest.check(true);
1492 |                 throw e;
1493 |             }
1494 |         }
1495 | 
1496 |         var step4 = function() {
1497 |             plugin.whenConnected(step5);
1498 |         }
1499 | 
1500 |         var step5 = function() {
1501 |             plugin.disconnect();
1502 |             lighttest.check(true);
1503 |             lighttest.done();
1504 |         }
1505 | 
1506 |         setTimeout(step1, 100);
1507 |     },
1508 |     
1509 |     
1510 |     'Subscribing non-functions to events in the plugin environment':
1511 |     function() {
1512 |         var fail = lighttest.protect(
1513 |             function() {
1514 |                 plugin.disconnect();
1515 |                 lighttest.check(true);
1516 |                 setTimeout(finalize, 300);
1517 |             }
1518 |         );
1519 |         
1520 |         var connect = lighttest.protect(
1521 |             function() {
1522 |                 plugin.disconnect();
1523 |                 lighttest.check(false);
1524 |                 lighttest.done();
1525 |             }
1526 |         );
1527 | 
1528 |         var disconnected = false;
1529 |         var disconnect = lighttest.protect(
1530 |             function() {
1531 |                 lighttest.check(true);
1532 |                 disconnected = true;
1533 |             }
1534 |         );
1535 | 
1536 |         var finalize = lighttest.protect(
1537 |             function() {
1538 |                 lighttest.check(disconnected);
1539 |                 lighttest.done();
1540 |             }
1541 |         );
1542 |         
1543 |         
1544 |         var path = currentPath + 'stage30/plugin30.js';
1545 |         var plugin = new jailed.Plugin(path);
1546 |         plugin.whenFailed(fail);
1547 |         plugin.whenConnected(connect);
1548 |         plugin.whenDisconnected(disconnect);
1549 |     },
1550 |     
1551 | 
1552 | 
1553 |     'Delayed event subscription in the application':
1554 |     function() {
1555 |         var stage1 = lighttest.protect(
1556 |             function() {
1557 |                 var plugin = new jailed.DynamicPlugin('');
1558 | 
1559 |                 var connectionCompleted = false;
1560 | 
1561 |                 var tryConnect = lighttest.protect(
1562 |                     function() {
1563 |                         plugin.whenConnected(connected);
1564 |                         setTimeout(connectCheck, 4000);
1565 |                     }
1566 |                 );
1567 | 
1568 |                 var connected = function() {
1569 |                     connectionCompleted = true;
1570 |                 }
1571 | 
1572 |                 var connectCheck = lighttest.protect(
1573 |                     function() {
1574 |                         plugin.disconnect();
1575 |                         lighttest.check(connectionCompleted);
1576 |                         setTimeout(stage2, 300);
1577 |                     }
1578 |                 );
1579 | 
1580 |                 setTimeout(tryConnect, 300);
1581 |             }
1582 |         );
1583 | 
1584 | 
1585 |         var stage2 = lighttest.protect(
1586 |             function() {
1587 |                 var plugin = new jailed.DynamicPlugin('uau}');
1588 | 
1589 |                 var failureCompleted = false;
1590 | 
1591 |                 var tryFailure = lighttest.protect(
1592 |                     function() {
1593 |                         plugin.whenFailed(failed);
1594 |                         setTimeout(failureCheck, 3500);
1595 |                     }
1596 |                 );
1597 | 
1598 |                 var failed = function() {
1599 |                     failureCompleted = true;
1600 |                 }
1601 | 
1602 |                 var failureCheck = lighttest.protect(
1603 |                     function() {
1604 |                         plugin.disconnect();
1605 |                         lighttest.check(failureCompleted);
1606 |                         setTimeout(stage3, 300);
1607 |                     }
1608 |                 );
1609 | 
1610 |                 setTimeout(tryFailure, 300);
1611 |             }
1612 |         );
1613 | 
1614 | 
1615 | 
1616 |         var stage3 = lighttest.protect(
1617 |             function() {
1618 |                 var plugin = new jailed.DynamicPlugin('application.disconnect();');
1619 | 
1620 |                 var disconnectCompleted = false;
1621 | 
1622 |                 var tryDisconnect = lighttest.protect(
1623 |                     function() {
1624 |                         plugin.whenDisconnected(disconnected);
1625 |                     }
1626 |                 );
1627 | 
1628 |                 var disconnected = function() {
1629 |                     disconnectCompleted = true;
1630 |                 }
1631 | 
1632 |                 var disconnectCheck = lighttest.protect(
1633 |                     function() {
1634 |                         plugin.disconnect();
1635 |                         lighttest.check(disconnectCompleted);
1636 |                         lighttest.done();
1637 |                     }
1638 |                 );
1639 | 
1640 |                 setTimeout(tryDisconnect, 300);
1641 |                 setTimeout(disconnectCheck, 5000);
1642 |             }
1643 |         );
1644 | 
1645 | 
1646 |         stage1();
1647 |     },
1648 | 
1649 | 
1650 | 
1651 | 
1652 |     'Delayed event subscription in the plugin':
1653 |     function() {
1654 |         var api = {
1655 |             check : lighttest.protect(function(result, cb){
1656 |                 lighttest.check(result);
1657 |                 cb();
1658 |             }),
1659 | 
1660 |             done : lighttest.protect(function() {
1661 |                 plugin.disconnect();
1662 |                 lighttest.check(true);
1663 |                 lighttest.done();
1664 |             })
1665 |         }
1666 | 
1667 |         var path = currentPath + 'stage31/plugin31.js';
1668 |         var plugin = new jailed.Plugin(path, api);
1669 | 
1670 |     },
1671 |     
1672 | 
1673 | 
1674 |     'Subscibing to Whenable events several times before and after emission':
1675 |     function() {
1676 |         var pluginFinished = 0;
1677 |         var api = {
1678 |             check : lighttest.protect(function(result, cb){
1679 |                 lighttest.check(result);
1680 |                 cb();
1681 |             }),
1682 | 
1683 |             finished : lighttest.protect(function() {
1684 |                 lighttest.check(true);
1685 |                 pluginFinished++;
1686 |                 disconnect();
1687 |             })
1688 |         }
1689 | 
1690 |         var beforeConnect1Finished = 0;
1691 |         var beforeConnect1 = lighttest.protect(
1692 |             function() {
1693 |                 beforeConnect1Finished++;
1694 |                 lighttest.check(true);
1695 |                 finalize();
1696 |             }
1697 |         );
1698 | 
1699 |         var beforeConnect2Finished = 0;
1700 |         var beforeConnect2 = lighttest.protect(
1701 |             function() {
1702 |                 beforeConnect2Finished++;
1703 |                 lighttest.check(true);
1704 |                 finalize();
1705 |             }
1706 |         );
1707 | 
1708 | 
1709 |         var beforeDisconnect1Finished = 0;
1710 |         var beforeDisconnect1 = lighttest.protect(
1711 |             function() {
1712 |                 beforeDisconnect1Finished++;
1713 |                 lighttest.check(true);
1714 |                 finalize();
1715 |             }
1716 |         );
1717 | 
1718 |         var beforeDisconnect2Finished = 0;
1719 |         var beforeDisconnect2 = lighttest.protect(
1720 |             function() {
1721 |                 beforeDisconnect2Finished++;
1722 |                 lighttest.check(true);
1723 |                 finalize();
1724 |             }
1725 |         );
1726 | 
1727 | 
1728 |         var afterConnect1Finished = 0;
1729 |         var afterConnect1 = lighttest.protect(
1730 |             function() {
1731 |                 afterConnect1Finished++;
1732 |                 lighttest.check(true);
1733 |                 finalize();
1734 |             }
1735 |         );
1736 | 
1737 |         var afterConnect2Finished = 0;
1738 |         var afterConnect2 = lighttest.protect(
1739 |             function() {
1740 |                 afterConnect2Finished++;
1741 |                 lighttest.check(true);
1742 |                 finalize();
1743 |             }
1744 |         );
1745 | 
1746 | 
1747 |         var afterDisconnect1Finished = 0;
1748 |         var afterDisconnect1 = lighttest.protect(
1749 |             function() {
1750 |                 afterDisconnect1Finished++;
1751 |                 lighttest.check(true);
1752 |                 finalize();
1753 |             }
1754 |         );
1755 | 
1756 |         var afterDisconnect2Finished = 0;
1757 |         var afterDisconnect2 = lighttest.protect(
1758 |             function() {
1759 |                 afterDisconnect2Finished++;
1760 |                 lighttest.check(true);
1761 |                 finalize();
1762 |             }
1763 |         );
1764 | 
1765 | 
1766 |         var finalize = lighttest.protect(
1767 |             function() {
1768 |                 if (
1769 |                     pluginFinished == 1 &&
1770 |                     beforeConnect1Finished == 1 &&
1771 |                     beforeConnect2Finished == 1 &&
1772 |                     beforeDisconnect1Finished == 1 &&
1773 |                     beforeDisconnect2Finished == 1 &&
1774 |                     afterConnect1Finished == 1 &&
1775 |                     afterConnect2Finished == 1 &&
1776 |                     afterDisconnect1Finished == 1 &&
1777 |                     afterDisconnect2Finished == 1
1778 |                 ) {
1779 |                     lighttest.check(
1780 |                         pluginFinished == 1 &&
1781 |                         beforeConnect1Finished == 1 &&
1782 |                         beforeConnect2Finished == 1 &&
1783 |                         beforeDisconnect1Finished == 1 &&
1784 |                         beforeDisconnect2Finished == 1 &&
1785 |                         afterConnect1Finished == 1 &&
1786 |                         afterConnect2Finished == 1 &&
1787 |                         afterDisconnect1Finished == 1 &&
1788 |                         afterDisconnect2Finished == 1
1789 |                     );
1790 |                     lighttest.done();
1791 |                 }
1792 |             }
1793 |         );
1794 | 
1795 |         var disconnect = lighttest.protect(
1796 |             function() {
1797 |                 plugin.disconnect();
1798 |                 setTimeout(
1799 |                     lighttest.protect(
1800 |                         function() {
1801 |                             plugin.whenDisconnected(afterDisconnect);
1802 |                         }
1803 |                     ), 300
1804 |                 );
1805 |             }
1806 |         );
1807 | 
1808 | 
1809 |         var afterDisconnect = lighttest.protect(
1810 |             function() {
1811 |                 plugin.whenConnected(afterConnect1);
1812 |                 plugin.whenConnected(afterConnect2);
1813 |                 plugin.whenDisconnected(afterDisconnect1);
1814 |                 plugin.whenDisconnected(afterDisconnect2);
1815 |             }
1816 |         );
1817 | 
1818 | 
1819 |         var path = currentPath + 'stage32/plugin32.js';
1820 |         var plugin = new jailed.Plugin(path, api);
1821 |         plugin.whenConnected(beforeConnect1);
1822 |         plugin.whenConnected(beforeConnect2);
1823 |         plugin.whenDisconnected(beforeDisconnect1);
1824 |         plugin.whenDisconnected(beforeDisconnect2);
1825 |     }
1826 |     
1827 |     
1828 | };
1829 | 
1830 |     
1831 | lighttest.start(tests);
1832 | 
1833 | 
1834 | 


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