├── .gitignore
├── .travis.yml
├── spec
    ├── host_scan_spec.js
    ├── host_probe_spec.js
    └── utils_spec.js
├── package.json
├── src
    ├── utils.js
    ├── ip_discovery.js
    ├── host_scan.js
    ├── device_scan.js
    └── db.js
├── Gruntfile.js
├── DOCUMENTATION.md
├── LICENSE
├── demo.html
├── README.md
└── examples
    └── dashboard.html


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | .DS_Store
3 | 
4 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |     - "0.10"
4 | 


--------------------------------------------------------------------------------
/spec/host_scan_spec.js:
--------------------------------------------------------------------------------
1 | describe("lan.HostScan", function() {
2 | 
3 | });


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "lan-js",
 3 |   "version": "0.2.0",
 4 |   "description": "Probe LAN devices from a web browser.",
 5 |   "author": "Joe Vennix",
 6 |   "devDependencies": {
 7 |     "grunt": "~0.4.1",
 8 |     "grunt-contrib-jshint": "~0.6.3",
 9 |     "grunt-contrib-uglify": "~0.2.2",
10 |     "grunt-contrib-concat": "~0.3.0",
11 |     "grunt-contrib-watch": "~0.5.3",
12 |     "grunt-contrib-jasmine": "~0.5.2",
13 |     "grunt-contrib-compress": "0.7.0",
14 |     "grunt-cli": "~0.1.13"
15 |   },
16 |   "scripts": {
17 |     "test": "./node_modules/.bin/grunt"
18 |   },
19 |   "license": "BSD-3-Clause",
20 |   "repository": {
21 |     "type": "git",
22 |     "url": "https://github.com/jvennix-r7/lan-js"
23 |   },
24 |   "bugs": {
25 |     "url": "https://github.com/jvennix-r7/lan-js/issues"
26 |   }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/utils.js:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Small collection of shims and global functions.
 3 |  */
 4 | (function() {
 5 | 
 6 | // really hard to live without this
 7 | var merge = function(_this, hash) {
 8 |   for (var k in hash) { _this[k] = hash[k]; }
 9 |   return _this;
10 | };
11 | 
12 | // normalize #forEach() implementation, for my sanity.
13 | var each = function(_this, cb) {
14 |   for (var i = 0; i < _this.length; i++) cb(_this[i], i);
15 | };
16 | 
17 | // list some useful constants
18 | var constants = {
19 |   // set #style of any DOMElement to this to hide
20 |   HIDDEN_STYLE: 'position:fixed;top:-500px;left:-500px;visibility:hidden;'
21 | };
22 | 
23 | /*
24 |  * Creates and returns an <iframe> element.
25 |  *
26 |  * @param [Object] opts the options object
27 |  * @option opts [String] url the url to point the iframe to. defaults to about:blank.
28 |  * @option opts [Boolean] insert insert into DOM. defaults to false.
29 |  */
30 | var createIframe = function(opts) {
31 |   opts = opts || {};
32 |   var url = opts.url || 'about:blank';
33 |   var iframe = document.createElement('iframe');
34 |   iframe.setAttribute('style', constants.HIDDEN_STYLE);
35 |   iframe.setAttribute('src', url);
36 |   if (opts.insert) { document.body.appendChild(iframe); }
37 |   return iframe;
38 | };
39 | 
40 | /*
41 |  * exports
42 |  */
43 | this.lan = this.lan || {};
44 | this.lan.utils = {
45 |   createIframe: createIframe,
46 |   constants: constants,
47 |   merge: merge,
48 |   each: each
49 | };
50 | 
51 | }).call(window);


--------------------------------------------------------------------------------
/Gruntfile.js:
--------------------------------------------------------------------------------
 1 | module.exports = function(grunt) {
 2 |   // The order of these files is very important!
 3 |   // They will be concatenated in order, so make sure dependencies match position.
 4 |   var SRC_FILES = [
 5 |     'src/utils.js',
 6 |     'src/host_scan.js',
 7 |     'src/device_scan.js',
 8 |     'src/ip_discovery.js',
 9 |     'src/db.js'
10 |   ];
11 | 
12 |   grunt.loadNpmTasks('grunt-contrib-compress');
13 | 
14 |   // Project configuration.
15 |   grunt.initConfig({
16 |     pkg: grunt.file.readJSON('package.json'),
17 |     jshint: {
18 |       all: ['Gruntfile.js', 'src/*.js', 'spec/*.js']
19 |     },
20 |     concat: {
21 |       dist: {
22 |         src: SRC_FILES,
23 |         dest: 'build/lan.js',
24 |       }
25 |     },
26 |     uglify: {
27 |       options: {
28 |         compress: {},
29 |         mangle: {},
30 |         banner: '/*! <%= pkg.name %>@<%= pkg.version %> <%= grunt.template.today("yyyy-mm-dd") %> */\n'
31 |       },
32 |       build: {
33 |         src: 'build/lan.js',
34 |         dest: 'build/lan.min.js'
35 |       }
36 |     },
37 |     jasmine: {
38 |       pivotal: {
39 |         src: SRC_FILES,
40 |         options: {
41 |           specs: 'spec/**.js'
42 |         }
43 |       }
44 |     },
45 |     watch: {
46 |       scripts: {
47 |         files: ['spec/*.js', 'src/*.js'],
48 |         tasks: ['jshint', 'jasmine'],
49 |         options: {
50 |           spawn: false,
51 |         }
52 |       }
53 |     }
54 |   });
55 | 
56 |   grunt.loadNpmTasks('grunt-contrib-jasmine');
57 |   grunt.loadNpmTasks('grunt-contrib-jshint');
58 |   grunt.loadNpmTasks('grunt-contrib-concat');
59 |   grunt.loadNpmTasks('grunt-contrib-uglify');
60 |   grunt.loadNpmTasks('grunt-contrib-watch');
61 |   grunt.registerTask('default', ['jshint', 'jasmine', 'concat', 'uglify']);
62 | };
63 | 


--------------------------------------------------------------------------------
/DOCUMENTATION.md:
--------------------------------------------------------------------------------
 1 | lan-js
 2 | ===
 3 | 
 4 | `lan-js` is a Javascript library for probing (cross-domain) hosts on your LAN from a browser. `lan-js` operates in two stages: 
 5 | 
 6 | 1. `HostScan`: An initial scan of the desired address range is performed with `WebSockets` (and `Image` fallbacks for older browsers). Alive hosts are identified via timing differences when a connection is attempted.
 7 | 
 8 | 2. `DeviceScan`: A secondary scan for known device fingerprints accessible via HTTP. A small example database is provided in `src/db.js`, 
 9 | 
10 | #### lan.HostScan
11 | 
12 | The `lan.HostScan` class handles running a single scan over an array of hosts.
13 | 
14 |     var scan = new lan.HostScan(['192.168.0.1', '192.168.0.2']);
15 |     scan.start({
16 |       stream: function(address, state, deltat) {
17 |         // called while the scan is running anytime we discover a new alive host
18 |         console.log("Host at "+address+" is "+state);
19 |       },
20 |       complete: function(results) {
21 |         // called at the end of the scan
22 |         console.log("Complete!");
23 |       }
24 |     });
25 | 
26 | #### lan.DeviceScan
27 | 
28 | The `lan.DeviceScan` class handles running a scan to fingerprint specific devices on your network. It first performs a `lan.TcpScan` to find alive hosts, and then tries to identify them by sending a catalog of requests for known images, stylesheets, and Javascript files that can be read by a cross-domain website.
29 | 
30 |     lan.DeviceScan.start(['192.168.0.1', '192.168.0.2', '192.168.1.1', '10.0.0.1'], {
31 |       found: function(address, fingerprint) {
32 |         console.log("["+address+"] Found device: "+fingerprint);
33 |       },
34 |       complete: function(results) {
35 |         console.log("Scan complete.")
36 |       },
37 |       hostup: function(address) {
38 |         console.log("Host up: "+address);
39 |       }
40 |     });
41 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
 2 | Source: http://www.metasploit.com/
 3 | 
 4 | Files: *
 5 | Copyright: 2006-2014, Rapid7, Inc.
 6 | License: BSD-3-clause
 7 | 
 8 | # lan-js is provided under the 3-clause BSD license provided
 9 | # at the end of this file.
10 | #
11 | # The copyright on this package is held by Rapid7, Inc.
12 | #
13 | # This license does not apply to third-party components detailed below.
14 | #
15 | # Last updated: 2014-Sep-19
16 | 
17 | License: BSD-3-clause
18 |  Redistribution and use in source and binary forms, with or without modification,
19 |  are permitted provided that the following conditions are met:
20 |  .
21 |      * Redistributions of source code must retain the above copyright notice,
22 |      this list of conditions and the following disclaimer.
23 |  .
24 |      * Redistributions in binary form must reproduce the above copyright notice,
25 |      this list of conditions and the following disclaimer in the documentation
26 |      and/or other materials provided with the distribution.
27 |  .
28 |      * Neither the name of Rapid7, Inc. nor the names of its contributors
29 |      may be used to endorse or promote products derived from this software
30 |      without specific prior written permission.
31 |  .
32 |  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
33 |  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
34 |  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
35 |  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
36 |  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
37 |  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
38 |  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
39 |  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
40 |  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
41 |  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42 | 
43 | 


--------------------------------------------------------------------------------
/demo.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 | <body>
 4 |   <label>
 5 |     <div>Hosts to scan</div>
 6 |     <div>
 7 |       <textarea rows=20 cols=50 id='h'>10.6.0.242
 8 |       </textarea>
 9 |     </div>
10 |   </label>
11 |   <button id='b' onclick='scan()'>Scan</button>
12 | 
13 |   <div id='c' style='background:#000; color: #fff; font-family:monospace; padding: 5px; margin-top:0; display: none;'>
14 |   </div>
15 | 
16 | 
17 | <script src='./src/utils.js'></script>
18 | <script src='./src/db.js'></script>
19 | <script src='./src/host_scan.js'></script>
20 | <script src='./src/device_scan.js'></script>
21 | 
22 | <script>
23 |   function log(s) {
24 |     c.innerHTML += '<div>'+s+'</div>';
25 |   }
26 | 
27 |   function scan() {
28 |     b.style.display = 'none';
29 |     c.style.display = 'block';
30 |     log('Scanning...');
31 |     lan.DeviceScan.start(h.value.trim().split(/\s+/), {
32 |       found: function(address, fingerprint) {
33 |         log("["+address+"] Found device: "+fingerprint);
34 |       },
35 |       complete: function(results) {
36 |         log("Scan complete.")
37 |       },
38 |       hostup: function(address) {
39 |         log("Host up: "+address);
40 |       },
41 |       hostdown: function(address) {
42 |         log("Host down: "+address);
43 |       }
44 |     });
45 | 
46 |     // var range = function(ip, start, end) {
47 |     //   var addrs = [];
48 |     //   while (start <= end) addrs.push(ip+'.'+start++);
49 |     //   return addrs;
50 |     // }
51 |     // var addrs = range('172.16.10', 1, 80).concat(range('172.16.10', 0, 50)).concat(range('10.6.0', 0, 255))
52 |     // new lan.HostScan(addrs, {batchSize: 1000, batchDelay: 500}).start({
53 |     //   complete: function(responses, duration) {
54 |     //     log('complete callback: '+duration/1000+'s');
55 |     //     var results = {};
56 |     //     lan.utils.each(responses, function(response) {
57 |     //       results[response.state] = results[response.state] || 0;
58 |     //       results[response.state]++;
59 |     //     });
60 |     //     log(JSON.stringify(results));
61 |     //   },
62 |     //   stream: function(addr, state, duration) {
63 |     //     log(addr+" - " +state.toUpperCase() + "(" + duration + ")");
64 |     //   }
65 |     // });
66 |     
67 |   }
68 |   </script>
69 | </body>
70 | </html>
71 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | lan-js [![Build Status](https://travis-ci.org/jvennix-r7/lan-js.svg?branch=master)](https://travis-ci.org/jvennix-r7/lan-js)
 2 | ===
 3 | 
 4 | Probe LAN devices from a web browser.
 5 | 
 6 | #### Documentation
 7 | 
 8 | See [DOCUMENTATION.md](./DOCUMENTATION.md).
 9 | 
10 | #### Sample code:
11 | 
12 | Scan the following devices on your network, and print any device matches
13 | 
14 |     lan.DeviceScan.start(['192.168.0.1', '192.168.0.2', '192.168.1.1', '10.0.0.1'], {
15 |       found: function(address, fingerprint) {
16 |         console.log("["+address+"] Found device: "+fingerprint);
17 |       },
18 |       complete: function(results) {
19 |         console.log("Scan complete.")
20 |       },
21 |       hostup: function(address) {
22 |         console.log("Host up: "+address);
23 |       }
24 |     });
25 | 
26 | #### Fingerprints
27 | 
28 | The `DeviceScan` class is in charge of scanning for responsive hosts and then looking for fingerprintable images, scripts, or stylesheets served by an HTTP service on that host.
29 | 
30 | A fingerprint is a set of criteria for matching a device. There are three types of fingerprints: images, scripts, and stylesheets.
31 | 
32 |     // image fingerprint
33 |     {
34 |       type: 'image',
35 |       url: '/epsonlogo.gif',
36 |       width: 79,
37 |       height: 28
38 |     }
39 | 
40 |     // style
41 |     {
42 |       type: 'css',
43 |       url: '/style.css',
44 |       html: '<html><div id="x"></div></html>',
45 |       id: 'x',
46 |       styles: { color: 'red' }
47 |     }
48 | 
49 |     // script
50 |     {
51 |       type: 'js',
52 |       url: '/script.js',
53 |       expression: 'LINKSYS_VERSION === 1'
54 |     }
55 | 
56 | #### Development environment:
57 | 
58 | 1. First install [node](http://nodejs.org/).
59 | 2. Install the grunt plugin and run `npm install` in the project root:
60 | 
61 |         $ sudo npm i -g grunt-cli
62 |         $ cd ~/Projects/lan.js/
63 |         $ npm install
64 | 
65 | #### Compiling
66 | 
67 | To compile, from the project root run:
68 | 
69 |     grunt
70 | 
71 | To have grunt "watch" your filesystem and recompile on change, do:
72 | 
73 |     grunt compile:watch
74 | 
75 | #### Running specs:
76 | 
77 | This project includes a number of specs. To run them, simply:
78 | 
79 |     grunt spec
80 | 
81 | To have grunt "watch" your filesystem and run specs on change, do:
82 | 
83 |     grunt spec:watch
84 | 
85 | #### License
86 | 
87 | `lan-js` is released under the [BSD 3-Clause License](http://opensource.org/licenses/BSD-3-Clause).
88 | 
89 | #### Copyright
90 | 
91 | 2006-2015, Rapid7, Inc.
92 | 


--------------------------------------------------------------------------------
/spec/host_probe_spec.js:
--------------------------------------------------------------------------------
 1 | describe("lan.HostProbe", function() {
 2 |   var subject = new lan.HostProbe('192.168.0.1');
 3 | 
 4 |   it("should be defined", function() {
 5 |     expect(lan.HostProbe).toBeDefined();
 6 |   });
 7 | 
 8 |   it("should throw an exception when created with no addresses", function() {
 9 |     expect(function() { new lan.HostProbe(); }).toThrow();
10 |   });
11 | 
12 |   describe("fire(callback)", function() {
13 |     // we put a spec in a var here so we can use it in 2 contexts
14 |     // ensures that the callback parameter eventually is called
15 |     var call_check = function() {
16 |       var opts = { callback: function(){} };
17 |       var probe = new lan.HostProbe('127.0.0.1:9999');
18 |       var ran = false;
19 |       runs(function() {
20 |         probe.fire(function() { ran = true; });
21 |       });
22 |       waitsFor(function() {
23 |         return ran;
24 |       }, lan.HostProbe.TIMEOUT+1);
25 |     };
26 | 
27 |     it("should eventually call the callback parameter", call_check);
28 | 
29 |     describe("on a browser that supports WebSockets", function() {
30 | 
31 |       describe("against a port that WebSockets supports", function() {
32 | 
33 |         it("should eventually call the callback parameter", call_check);
34 | 
35 |         it("should send a WebSockets request", function() {
36 |           var probe = new lan.HostProbe('192.168.0.1:8080');
37 |           spyOn(probe, '_sendWebSocketRequest');
38 |           probe.fire();
39 |           expect(probe._sendWebSocketRequest).toHaveBeenCalled();
40 |         });
41 |       });
42 | 
43 |       describe("against a port that WebSockets does not support", function() {
44 |         it("should eventually call the callback parameter", call_check);
45 | 
46 |         it("should fallback to sending an image request", function() {
47 |           var probe = new lan.HostProbe('192.168.0.1:21');
48 |           spyOn(probe, '_sendImgRequest');
49 |           probe.fire();
50 |           expect(probe._sendImgRequest).toHaveBeenCalled();
51 |         });
52 |       });
53 |     });
54 | 
55 |     describe("on a browser that does not support WebSocket", function() {
56 |       var ws = window.WebSockets;
57 |       beforeEach(function(){ window.WebSockets = null; });
58 |       afterEach(function(){ window.WebSockets = ws; });
59 | 
60 |       it("should eventually call the callback parameter", call_check);
61 | 
62 |       it("should fallback to sending an image request", function() {
63 |         var probe = new lan.HostProbe('192.168.0.1:21');
64 |         spyOn(probe, '_sendImgRequest');
65 |         probe.fire();
66 |         expect(probe._sendImgRequest).toHaveBeenCalled();
67 |       });
68 |     });
69 | 
70 |   });
71 | });
72 | 


--------------------------------------------------------------------------------
/spec/utils_spec.js:
--------------------------------------------------------------------------------
 1 | describe("lan.utils", function() {
 2 |   it("should be defined", function() {
 3 |     expect(lan.utils).toBeDefined();
 4 |   });
 5 | 
 6 |   describe("lan.utils.each()", function() {
 7 |     it("should be defined", function() {
 8 |       expect(lan.utils.each).toBeDefined();
 9 |     });
10 | 
11 |     it("should pass the value of each element of the array to the callback", function() {
12 |       var x = ['a', 'b', 'c'];
13 |       var output = [];
14 |       lan.utils.each(x, function(val, idx) { output.push(val); });
15 |       expect(output).toEqual(x);
16 |     });
17 | 
18 |     it("should pass the index (key) of each element of the array to the callback", function() {
19 |       var x = ['a', 'b', 'c'];
20 |       var output = [];
21 |       lan.utils.each(x, function(val, idx) { output.push(idx); });
22 |       expect(output).toEqual([0, 1, 2]);
23 |     });
24 |   });
25 | 
26 |   describe("lan.utils.merge()", function() {
27 |     it("should be defined", function() {
28 |       expect(lan.utils.merge).toBeDefined();
29 |     });
30 | 
31 |     it("should merge the argument into the callee", function() {
32 |       var x = {a: 1};
33 |       var data = {b: 2};
34 |       lan.utils.merge(x, data);
35 |       expect(x).toEqual({a: 1, b: 2});
36 |     });
37 |   });
38 | 
39 |   describe("lan.utils.createIframe()", function() {
40 |     it("should return an iframe", function() {
41 |       var frame = lan.utils.createIframe();
42 |       expect(frame.tagName).toBe("IFRAME");
43 |     });
44 | 
45 |     it("should return an iframe that is not in the DOM", function(){
46 |       var frame = lan.utils.createIframe();
47 |       expect(frame.parentNode).toBeFalsy(); 
48 |     });
49 | 
50 |     describe("when passed {insert: true}", function() {
51 |       var frame;
52 | 
53 |       afterEach(function() {
54 |         frame.parentNode.removeChild(frame);
55 |       });
56 | 
57 |       it("should return an iframe that has been inserted into the DOM", function(){
58 |         frame = lan.utils.createIframe({insert: true});
59 |         expect(frame.parentNode).toBeTruthy(); 
60 |       });
61 |     });
62 | 
63 |     describe("when passed a data url containing 'HELLO'", function() {
64 |       var data_url = 'data:text/html,<html><body>HELLO</body></html>';
65 | 
66 |       it("should return an iframe with a data URL in its src", function() {
67 |         var frame = lan.utils.createIframe({url: data_url});
68 |         expect(frame.getAttribute('src')).toMatch(/data/);
69 |       });
70 |     });
71 |   });
72 | 
73 |   describe("lan.utils.constants", function() {
74 |     it("should be defined", function() {
75 |       expect(lan.utils.constants).toBeDefined();
76 |     });
77 | 
78 |     it("should not be empty", function() {
79 |       expect(Object.keys(lan.utils.constants).length).toBeGreaterThan(0);
80 |     });
81 |   });
82 | });
83 | 


--------------------------------------------------------------------------------
/examples/dashboard.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 |   <head>
 4 |   	<script src='../build/lan.js'></script>
 5 |     <script>
 6 |       function log(c, s) {
 7 |         c.innerHTML += '<div>'+s+'</div>';
 8 |       }
 9 | 
10 |       lan.IpDiscovery.start(function(error, ip) {
11 |         // if (!ip.match(/192.168.0/))return;
12 |         if (error) return;
13 |         var mask = ip.replace(/\d+$/, '');
14 |         var range = [];
15 | 
16 |         for (var i = 0; i < 256; i++) {
17 |           range.push(mask+i);
18 |         }
19 | 
20 |         var div = document.createElement('div');
21 |         div.setAttribute('style', 'background:#000; color: #fff; font-family:monospace; padding: 5px;padding-bottom:20px;margin-bottom:15px;position:relative;');
22 |         document.body.appendChild(div);
23 |         log(div, '<div class=load style="background-image:url(https://i1.wp.com/cdnjs.cloudflare.com/ajax/libs/fancybox/2.1.5/fancybox_loading.gif);background-position: center bottom; background-repeat:no-repeat;background-size: 12px 12px;position:absolute;bottom: 5px;width:20px;height:20px;"></div>')
24 |         log(div, "<span style='color:#ccc'>Internal IP address detected: "+ip+"</span>");
25 |         log(div, "<span style='color:#ccc'>Scanning "+mask+"0 - "+mask+"255</span>");
26 | 
27 |         // new lan.HostScan(range, {batchSize: 125}).start({
28 |         //   // found: function(address, fingerprint) {
29 |         //   //   log(div, "["+address+"] Found device: "+fingerprint);
30 |         //   // },
31 |         //   // complete: function(results) {
32 |         //   //   log(div, "Scan complete.")
33 |         //   // },
34 |         //   // hostup: function(address) {
35 |         //   //   log(div, "Host up: "+address);
36 |         //   // },
37 |         //   stream: function(addr, state, duration) {
38 |         //     if (state == 'up')
39 |         //       log(div, addr.replace(/:\d+$/, '')+" - " +state.toUpperCase());
40 |         //   },
41 |         //   complete: function() {
42 |         //     log(div, "<span style='color:#0f0'>Scan complete.</span>");
43 |         //     div.querySelector('.load').style.display = 'none';
44 |         //     div.style.paddingBottom = 0;
45 |         //   }
46 |         // });
47 | 
48 | new lan.DeviceScan(range).start({
49 |   found: function(address, fingerprint) {
50 |     log(div, "["+address+"] Found device: "+fingerprint);
51 |   },
52 |   hostup: function(address) {
53 |     log(div, "Host up: "+address);
54 |   },
55 |   // stream: function(addr, state, duration) {
56 |   //   if (state == 'up')
57 |   //     log(div, addr.replace(/:\d+$/, '')+" - " +state.toUpperCase());
58 |   // },
59 |   complete: function() {
60 |     log(div, "<span style='color:#0f0'>Scan complete.</span>");
61 |     div.querySelector('.load').style.display = 'none';
62 |     div.style.paddingBottom = 0;
63 |   }
64 | });
65 |       });
66 |     </script>
67 |   </head>
68 |   <body>
69 | 
70 |   </body>
71 | </html>
72 | 


--------------------------------------------------------------------------------
/src/ip_discovery.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * ip_discovery.js: Attempts to discover your own IP address using HTML5 WebRTC APIs.
  3 |  *
  4 |  * @author joev
  5 |  */
  6 | 
  7 | (function(){
  8 | 
  9 | function discoverIps(opts, callback) {
 10 | 
 11 |   if (typeof opts === 'function') {
 12 |     callback = opts;
 13 |     opts = {};
 14 |   }
 15 | 
 16 |   if (!('waitForNext' in opts)) {
 17 |     opts.waitForNext = false; // ms
 18 |   }
 19 | 
 20 |   /*
 21 |    * based heavily on the beef implementation here:
 22 |    * https://github.com/beefproject/beef/wiki/Module:-Get-Internal-IP-WebRTC
 23 |    */
 24 | 
 25 |   var RTCPeerConnection = window.webkitRTCPeerConnection || window.mozRTCPeerConnection || window.RTCPeerConnection;
 26 |   function run() {
 27 |     var addrs = { "0.0.0.0": false };
 28 |     var pendingTimeout = null;
 29 | 
 30 |     // Establish a connection with ICE / relay servers - in this instance: NONE
 31 |     var rtc = new RTCPeerConnection({iceServers: []});
 32 |     rtc.createDataChannel('', {reliable:false});
 33 | 
 34 |     // Upon an ICE candidate being found
 35 |     // Grep the SDP data for IP address data
 36 |     rtc.onicecandidate = function (evt) {
 37 |       if (evt.candidate) grepSDP("a="+evt.candidate.candidate);
 38 |     };
 39 | 
 40 |     // Create an SDP offer
 41 |     rtc.createOffer(function (offerDesc) {
 42 |       grepSDP(offerDesc.sdp);
 43 |       rtc.setLocalDescription(offerDesc);
 44 |     }, function (e) { callback("SDP Offer Failed"); });
 45 | 
 46 |     function processIPs(newAddr) {
 47 |       if (newAddr in addrs) return;
 48 |       if (!newAddr.match(/^\d+\.\d+\.\d+\.\d+$/)) return;
 49 |       else addrs[newAddr] = true;
 50 | 
 51 |       if (opts.waitForNext) {
 52 |         if (pendingTimeout) clearTimeout(pendingTimeout);
 53 |         pendingTimeout = setTimeout(function() {
 54 |           var displayAddrs = Object.keys(addrs).filter(function (k) { return addrs[k]; });
 55 |           callback(false, displayAddrs);
 56 |         }, opts.waitForNext);
 57 |       } else {
 58 |         callback(false, newAddr);
 59 |       }
 60 |     }
 61 | 
 62 |     function grepSDP(sdp) {
 63 |       var parts, addr, type;
 64 |       var hosts = [];
 65 | 
 66 |       sdp.split('\r\n').forEach(function (line) { // c.f. http://tools.ietf.org/html/rfc4566#page-39
 67 |         if (~line.indexOf("a=candidate")) {     // http://tools.ietf.org/html/rfc4566#section-5.13
 68 |           parts = line.split(' ');              // http://tools.ietf.org/html/rfc5245#section-15.1
 69 |           addr = parts[4];
 70 |           type = parts[7];
 71 |           if (type === 'host') processIPs(addr);
 72 |       } else if (~line.indexOf("c=")) {       // http://tools.ietf.org/html/rfc4566#section-5.7
 73 |           parts = line.split(' ');
 74 |           addr = parts[2];
 75 |           processIPs(addr);
 76 |         }
 77 |       });
 78 |     }
 79 |   }
 80 | 
 81 |   if (RTCPeerConnection) {
 82 |     run();
 83 |   } else {
 84 |     setTimeout(function () { // avoid zalgo's reach
 85 |       callback("RTCPeerConnection is not supported by this browser");
 86 |     });
 87 |   }
 88 | 
 89 | }
 90 | 
 91 | 
 92 | /*
 93 |  * exports
 94 |  */
 95 | lan.utils.merge(lan, {
 96 |   IpDiscovery: {
 97 |     start: discoverIps
 98 |   }
 99 | });
100 | 
101 | }).call(window);


--------------------------------------------------------------------------------
/src/host_scan.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * host_scan.js implements a HTTP timing scanner for LAN discovery.
  3 |  *
  4 |  * By analyzing timing responses, it is possible to get an idea of the
  5 |  * overall network layout.
  6 |  *
  7 |  * WebSockets or img tags are used to probe the local network space.
  8 |  *
  9 |  * @author joev
 10 |  */
 11 | 
 12 | // wrap it all in an outer context to prevent leaks
 13 | (function() {
 14 | 
 15 | // constants
 16 | var BATCH_SIZE = 10;
 17 | var BATCH_DELAY = 1500; // interval to send batch of requests
 18 | 
 19 | // interval (ms) to poll the WebSocket's status attribute
 20 | var WS_CHECK_INTERVAL = 10; // (ms)
 21 | 
 22 | /*
 23 |  * no requests are allowed from browser to any of these ports.
 24 |  * From the WebSockets spec (http://dev.w3.org/html5/websockets/):
 25 |  * If port is a port to which the user agent is configured to block access, then throw
 26 |  * a SECURITY_ERR exception. (User agents typically block access to well-known ports like SMTP.)
 27 |  */
 28 | var WS_BLOCKED_PORTS = [1,7,9,11,13,15,17,19,20,21,22,23,25,37,42,43,53,
 29 |                         77,79,87,95,101,102,103,104,109,110,111,113,115,
 30 |                         117,119,123,135,139,143,179,389,465,512,513,514,
 31 |                         515,526,530,531,532,540,556,563,587,601,636,993,
 32 |                         995,2049,4045,6000];
 33 | 
 34 | // creates a Hash with the BLOCKED_PORTS as keys, for faster lookup
 35 | var WS_BLOCKED_PORTS_OBJ = {};
 36 | lan.utils.each(WS_BLOCKED_PORTS, function(v, k) {
 37 |   WS_BLOCKED_PORTS_OBJ[''+k] = true;
 38 | });
 39 | 
 40 | /*
 41 |  * HostProbe constructor function
 42 |  * @param [String] address the host:port to scan
 43 |  */
 44 | var HostProbe = function(address) {
 45 |   if (!address) throw "HostProbe needs an address param.";
 46 | 
 47 |   /*
 48 |    * sends the TCP request
 49 |    * @param [Function(state, delta)] callback
 50 |    */
 51 |   this.fire = function(callback) {
 52 |     // skip blocked ports
 53 |     var matches = address.match(/\:(\d+)$/) || ['', '80'];
 54 |     var port = parseInt(matches[1], 10);
 55 |     // feature detect and run
 56 |     if ('WebSocket' in window && !this._illegalWebSocketPort(port)) {
 57 |       this._sendWebSocketRequest(callback);
 58 |     } else {
 59 |       this._sendImgRequest(callback);
 60 |     }
 61 |   };
 62 | 
 63 |   /*
 64 |    * @param [Number] port the port to check
 65 |    * @return [Boolean] websockets spec disallows connection on port
 66 |    */
 67 |   this._illegalWebSocketPort = function(port) {
 68 |     return WS_BLOCKED_PORTS_OBJ[''+port] || false;
 69 |   };
 70 | 
 71 |   /*
 72 |    * WebSocket scan works by sending a WebSocket request, then measures
 73 |    * latency after sending to determine if the service is up.
 74 |    * WebSockets are a bit sneakier, since http basic auth will not trigger a popup
 75 |    */
 76 |   this._sendWebSocketRequest = function(callback) {
 77 |     // create the websocket and remember when we started
 78 |     var startTime = new Date();
 79 |     try {
 80 |       var socket = new WebSocket('ws://'+address);
 81 |     } catch (sec_exception) {
 82 |       if (callback) callback('error', 0);
 83 |       return;
 84 |     }
 85 |     // called at a fast interval
 86 |     var check_socket = function() {
 87 |       var delta = (new Date()) - startTime;
 88 |       // check if the port has timed out
 89 |       if (delta > HostProbe.TIMEOUT) {
 90 |         try { socket.close(); } catch(e) {}
 91 |         if (callback) callback('timeout', delta);
 92 |         return;
 93 |       } else if (socket.readyState !== 0) {
 94 |         if (callback) callback('up', delta);
 95 |         return;
 96 |       }
 97 |       setTimeout(check_socket, WS_CHECK_INTERVAL);
 98 |     };
 99 |     // wait a sec, then start the checks
100 |     setTimeout(check_socket, WS_CHECK_INTERVAL);
101 |   };
102 | 
103 |   // Image scan simply sets an <img> src to the address, and waits for a response.
104 |   this._sendImgRequest = function(callback) {
105 |     // create the image object and attempt to load from #src
106 |     var clearme = null; // for holding a timeout ref
107 |     var startTime = new Date();
108 |     var img = new Image();
109 |     var delta = function() { return (new Date()) - startTime; };
110 | 
111 |     var completed = function() {
112 |       if (img) {
113 |         img = null;
114 |         clearTimeout(clearme);
115 |         if (callback) callback('up', delta());
116 |         return;
117 |       }
118 |     };
119 | 
120 |     var checkTimeout = function() {
121 |       if (img) {
122 |         img = null;
123 |         if (callback) callback('timeout', delta());
124 |       }
125 |     };
126 | 
127 |     // if the request takes to long, report 'timeout' state
128 |     clearme = setTimeout(checkTimeout, HostProbe.TIMEOUT);
129 |     // trigger the request
130 |     img.onload = img.onerror = completed; // TODO: ensure this works in IE.
131 |     img.src = window.location.protocol + '//' + address;
132 |   };
133 | };
134 | 
135 | /*
136 |  * HostProbe static constants
137 |  */
138 | HostProbe.TIMEOUT = 2000; // 2s
139 | 
140 | /*
141 |  * HostScan constructor function
142 |  * @param [Array<String>, String] addresses the host:port(s) to scan
143 |  * @param [Object] opts the options hash
144 |  * @option opts [Number] batchSize the number of requests per batch, defaults to 10
145 |  * @option opts [Number] batchDelay the delay between batches, defaults to 1500
146 |  */
147 | var HostScan = function(addresses, opts) {
148 |   if (!addresses) throw "HostScan requests addresses param.";
149 |   if (addresses.constructor != Array) addresses = [addresses];
150 |   opts = opts || {};
151 |   var responses = []; // used to build responses parameter for 'complete' callback to #start
152 |   var batchSize = opts.batchSize || BATCH_SIZE;
153 |   var batchDelay = opts.batchDelay || BATCH_DELAY;
154 | 
155 |   // starts sending requests to the addresses in #addresses
156 |   // @param [Object] opts the options hash
157 |   // @option opts [Function(results)] complete gets called at end of scan
158 |   // @option opts [Function(address, state, deltat)] stream gets called on every result
159 |   this.start = function(opts) {
160 |     opts = opts || {};
161 | 
162 |     // run in batches
163 |     var batchIdx = 0;
164 |     var startTime = new Date();
165 | 
166 |     // sends the probes
167 |     var sendProbe = function(i) {
168 |       var addrIdx = batchIdx * batchSize + i;
169 |       if (addrIdx >= addresses.length) return;
170 |       var addr = addresses[addrIdx];
171 | 
172 |       var bidx = batchIdx; // local closure
173 |       setTimeout(function() {
174 |         var probe = new HostProbe(addr);
175 |         probe.fire(function(state, duration) {
176 |           if (opts.stream) opts.stream(addr, state, duration);
177 |           responses.push({ address: addr, state: state, duration: duration });
178 |           if (responses.length >= addresses.length) {
179 |             if (opts.complete) {
180 |               opts.complete(responses, (new Date())-startTime);
181 |               opts.complete = null; // don't call this again :)
182 |             }
183 |           }
184 |         });
185 |       }, bidx * batchDelay);
186 |     };
187 | 
188 |     // run the loop
189 |     while (batchIdx * batchSize < addresses.length) {
190 |       for (var k = 0; k < batchSize; k++) {
191 |         sendProbe(k);
192 |       }
193 |       batchIdx++;
194 |     }
195 |   };
196 | };
197 | 
198 | /*
199 |  * HostScan static methods
200 |  */
201 | 
202 | /*
203 |  * @param [Array<String>] addresses IPs/hostnames to scan
204 |  * @param [Object] opts the options hash
205 |  * @option opts [Function(resultsObject)] complete the complete callback (called once at end)
206 |  * @option opts [Function(singleResult)] stream the update callback (called on every check)
207 |  */
208 | HostScan.start = function(addresses, opts) {
209 |   new HostScan(addresses).start(opts);
210 | };
211 | 
212 | // // DEBUG CODE: how to invoke the HostScan class
213 | // new lan.HostScan(['192.168.1.1:80', '192.168.1.1:8080']).start({
214 | //   complete: function(responses, duration) {
215 | //     console.log('complete callback: '+duration);
216 | //     var results = {};
217 | //     lan.utils.each(responses, function(response) {
218 | //       results[response.state] = results[response.state] || 0;
219 | //       results[response.state]++;
220 | //     });
221 | //     console.log(results);
222 | //   },
223 | //   stream: function(addr, state, duration) {
224 | //     console.log(addr+" - " +state.toUpperCase());
225 | //   }
226 | // });
227 | 
228 | // var scan_ports = function(ip, start, end) {
229 | //   if (!start || !end || start > end) throw "Argument error";
230 | 
231 | //   var addrs = []; // holds ip:port strings
232 | //   while (start <= end) addrs.push(ip+':'+start++);
233 | 
234 | //   new lan.HostScan(addrs).start({
235 | //     complete: function(responses, duration) {
236 | //       console.log('complete callback: '+duration);
237 | //       var results = {};
238 | //       lan.utils.each(responses, function(response) {
239 | //         results[response.state] = results[response.state] || 0;
240 | //         results[response.state]++;
241 | //       });
242 | //       console.log(results);
243 | //     },
244 | //     stream: function(addr, state, duration) {
245 | //       console.log(addr+" - " +state.toUpperCase() + "(" + duration + ")");
246 | //     }
247 | //   });
248 | // }
249 | // scan_ports('localhost', 2950, 3005)
250 | 
251 | // exports
252 | lan.utils.merge(lan, {
253 |   HostScan: HostScan,
254 |   HostProbe: HostProbe
255 | });
256 | 
257 | }).call(window);
258 | 


--------------------------------------------------------------------------------
/src/device_scan.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * device_scan.js: Look for known devices on a network by using various
  3 |  * HTTP fingerprints (xdomain images, CSS styles, and <script> globals).
  4 |  *
  5 |  * @author joev
  6 |  */
  7 | 
  8 | (function(){
  9 | 
 10 | /*
 11 |  * ImageProbe checks if the target address responds with an image of
 12 |  * a particular width and height.
 13 |  *
 14 |  * @param [Object] opts the options object
 15 |  * @options opts [String] url the url to the image
 16 |  * @options opts [String] base the base url, defaults to null for relative path
 17 |  * @options opts [Number] width the expected width of the image
 18 |  * @options opts [Number] height the expected height of the image
 19 |  */
 20 | var ImageProbe = function(opts) {
 21 |   var _this = this; // used to bind methods to constructor's `this`
 22 |   var _img = document.createElement('img');
 23 |   _img.setAttribute('style', lan.utils.constants.HIDDEN_STYLE);
 24 |   document.body.appendChild(_img);
 25 | 
 26 |   var _url = opts.url;
 27 |   if (opts.base) {
 28 |     _url = opts.base + _url;
 29 |   }
 30 | 
 31 |   /*
 32 |    * Sends the request for the image, then checks expected dimensions (if specified)
 33 |    * @param [Function(statusBool, probe)] callback
 34 |    */
 35 |   this.fire = function(callback) {
 36 |     _img.onload = function() {
 37 |       if (opts.width || opts.height) { // user specified explicit dimensions
 38 |         // ensure width/height match expected dimensions
 39 |         callback((!opts.width  || _img.width  === opts.width) &&
 40 |                  (!opts.height || _img.height === opts.height), _this);
 41 |       } else {
 42 |         // just make sure *something* loaded.
 43 |         callback(true, _this);
 44 |       }
 45 |       // cleanup after ourselves
 46 |       _this.cleanup();
 47 |     };
 48 |     _img.onerror = function() {
 49 |       callback(false, _this);
 50 |       _this.cleanup();
 51 |     };
 52 |     _img.src = _url; // fire the request!
 53 |   };
 54 | 
 55 |   // removes DOM elements and events, aborting the request immediately
 56 |   this.cleanup = function() {
 57 |     _img.onerror = _img.onload = null;
 58 |     if (_img) {
 59 |       if (_img.parentNode) { _img.parentNode.removeChild(_img); }
 60 |       _img = null;
 61 |     }
 62 |   };
 63 | };
 64 | 
 65 | /*
 66 |  * CSSProbe checks if the target address responds with a CSS stylesheet
 67 |  * containing a particular rule. It works by creating a new <iframe> and
 68 |  * loading the xdomain stylesheet into the frame, then checking the .style
 69 |  * of different elements.
 70 |  *
 71 |  * @param [Object] opts the options object
 72 |  * @options opts [String] url the url to the image
 73 |  * @options opts [String] html the markup to render inside the frame and test for a style
 74 |  * @options opts [String] id the id of the DOM element to test
 75 |  * @options opts [Object] styles map of CSS properties and values to match
 76 |  */
 77 | var CSSProbe = function(opts) {
 78 |   // private variables
 79 |   var _this     = this;  // used to bind methods
 80 |   var _callback = null;  // used to hold on to the callback fn
 81 |   var _timer    = null;  // used to hold the setInterval timer
 82 |   var _frame    = null;
 83 | 
 84 |   // initialization
 85 |   _frame = lan.utils.createIframe();
 86 |   _frame.contentDocument.write('<html>'+opts.html+'</html>');
 87 |   document.body.appendChild(_frame);
 88 | 
 89 |   /*
 90 |    * Requests the stylesheet in an <iframe>, then checks expected styles
 91 |    * @param [Function(statusBool, probe)] callback
 92 |    */
 93 |   this.fire = function(callback) {
 94 |     _callback = callback; // remember me
 95 |     var link = document.createElement('link');
 96 |     link.setAttribute('href', opts.url);
 97 |     // trigger the request
 98 |     _frame.contentDocument.body.appendChild(link);
 99 |     // start checking for an update
100 |     _timer = setInterval(_this._poll, _this.constructor.POLL_INTERVAL);
101 |   };
102 | 
103 |   // removes DOM elements, intervals, and fn refs, aborting the request immediately
104 |   this.cleanup = function() {
105 |     if (_frame) {
106 |       if (_frame.parentNode) { _frame.parentNode.removeChild(_frame); }
107 |       _frame = null;
108 |     }
109 |     if (_timer) { clearInterval(_timer); _timer = null; }
110 |     _callback = null;
111 |   };
112 | 
113 |   // Private method called repeatedly to check for the style in the iframe
114 |   this._poll = function() {
115 |     var el = _frame.contentDocument.getElementById(opts.id);
116 |     if (el) {
117 |       for (var prop in styles) {
118 |         if (el.style[prop] !== styles[prop]) {
119 |           return;
120 |         }
121 |       }
122 |       if (_callback) _callback(true, this);
123 |       _this.cleanup();
124 |     }
125 |   };
126 | };
127 | 
128 | /*
129 |  * CSSProbe constants
130 |  */
131 | CSSProbe.POLL_INTERVAL = 10;
132 | 
133 | /*
134 |  * JSProbe checks if the target address responds with valid javascript
135 |  * that causes some expression to evaluate to `true`. It works by creating a
136 |  * new <iframe> and loading the xdomain <script> into the frame, then checking
137 |  * the frame's window object for the new vars.
138 |  *
139 |  * @param [Object] opts the options object
140 |  * @options opts [String] url the url to the script
141 |  * @options opts [String] global the JS global to check for
142 |  */
143 | var JSProbe = function(opts) {
144 |   var _frame = null;
145 |   var _this  = this;
146 |   _frame = lan.utils.createIframe();
147 | 
148 |   /*
149 |    * Requests the script in an <iframe>, then checks expected styles
150 |    * @param [Function(statusBool, probe)] callback
151 |    */
152 |   this.fire = function(callback) {
153 |     var script = document.createElement('script');
154 |     script.setAttribute('type', 'text/javascript');
155 | 
156 |     script.onload = function() {
157 |       var found = true;
158 |       if (opts.expression) {
159 |         /*jshint -W061 */
160 |         if (_frame.contentWindow.eval(opts.expression)) {
161 |         /*jshint +W061 */
162 |           found = false;
163 |         }
164 |       }
165 |       if (callback) callback(found, _this);
166 |       _this.cleanup();
167 |     };
168 |     script.onerror = function() {
169 |       if (callback) callback(false, _this);
170 |       _this.cleanup();
171 |     };
172 | 
173 |     script.setAttribute('src', opts.url);
174 |     _frame.contentDocument.body.appendChild(script);
175 |   };
176 | 
177 | 
178 |   // removes DOM elements, intervals, and fn refs, aborting the request immediately
179 |   this.cleanup = function() {
180 |     if (_frame) {
181 |       if (_frame.parentNode) { _frame.parentNode.removeChild(_frame); }
182 |       _frame = null;
183 |     }
184 |   };
185 | };
186 | 
187 | /*
188 |  * JSProbe constants
189 |  */
190 | JSProbe.POLL_INTERVAL = 10;
191 | 
192 | /*
193 |  * A Fingerprint represents a single device check
194 |  * @param [String] type img|css|js
195 |  * @param [Hash] device the device information
196 |  */
197 | var DeviceFingerprint = function(type, device, fingerprint) {
198 |   lan.utils.merge(this, fingerprint);
199 |   lan.utils.merge(this, device);
200 | 
201 |   /*
202 |    * Starts the Fingerprint request
203 |    * @param [String] base the https:// or http:// base URL
204 |    * @param [Function(statusBoolean)] callback
205 |    */
206 |   this.check = function(opts, callback) {
207 |     var Probe = this.constructor.PROBES[type];
208 |     if (!Probe) {
209 |       if (callback) callback(false);
210 |       console.log("Error: invalid type '"+(type||'')+"'");
211 |       return false;
212 |     } else {
213 |       new Probe(lan.utils.merge(fingerprint, { base: opts.base })).fire(callback);
214 |     }
215 |   };
216 | 
217 | 
218 |   /*
219 |    * Patch toString() for a nice debug display
220 |    * @return [String] serialized representation
221 |   */
222 |   this.toString = function() {
223 |     return (this.make || "") + " " + (this.model || "");
224 |   };
225 | };
226 | 
227 | /*
228 |  * Fingerprint static constants and variables
229 |  */
230 | DeviceFingerprint.PROBES = {
231 |   image: ImageProbe,
232 |   css:   CSSProbe,
233 |   js:    JSProbe
234 | };
235 | 
236 | /*
237 |  * DeviceScan constructor
238 |  * @param [Array<String>] addresses IPs to scan
239 |  */
240 | var DeviceScan = function(addresses) {
241 |   if (!addresses) throw "DeviceScan requests addresses param.";
242 |   if (addresses.constructor != Array) addresses = [addresses];
243 | 
244 |   /*
245 |    * Looks for known devices in the addresses array.
246 |    * - First, tcp probe requests are sent to the IP:port addresses.
247 |    * - Then, a series of HTTP probes are sent: images of known length, known CSS styles, known JS globals
248 |    * - Everytime a device is found, the :found callback is invoked
249 |    * - At the end of the scan, the :complete callback is invoked
250 |    * @param [Object] opts the options object
251 |    * @option opts [Array<Object>] devices a set of devices and HTTP fingerprints to attempt (see db.js)
252 |    * @option opts [Function(address, device)] found called when a device is successfully fingerprinted
253 |    * @option opts [Function(address, device)] failed called when a device fails a fingerprint
254 |    * @option opts [Function(address, state, deltat)] hostup called when a host is discovered up
255 |    * @option opts [Function(address, state, deltat)] hostdown called when a host is not responsive
256 |    * @option opts [Function(results)] complete called when the scan is over
257 |    */
258 |   this.start = function(opts) {
259 |     opts = opts || {};
260 | 
261 |     var devices = opts.devices || (lan.db && lan.db.devices) || [];
262 |     var fingerprintDatabase = [];
263 |     lan.utils.each(devices, function(device) {
264 |       lan.utils.each(device.fingerprints, function(fingerprint) {
265 |         fingerprintDatabase.push(new DeviceFingerprint(fingerprint.type, device, fingerprint));
266 |       });
267 |     });
268 | 
269 |     var scan = new lan.HostScan(addresses);
270 |     scan.start({
271 |       stream: function(address, state, deltat) {
272 |         if (state == 'up') {
273 |           if (opts.hostup) {
274 |             opts.hostup(address, state, deltat);
275 |           }
276 |           // try every probe in the database
277 |           lan.utils.each(fingerprintDatabase, function(fingerprint, i) {
278 |             fingerprint.check({base: 'http://'+address }, function(probeState) {
279 |               if (probeState && opts.found) {
280 |                 opts.found(address, fingerprint);
281 |               } else if (!probeState && opts.failed) {
282 |                 opts.failed(address, fingerprint);
283 |               }
284 |             });
285 |           });
286 |         } else {
287 |           if (opts.hostdown) {
288 |             opts.hostdown(address, state, deltat);
289 |           }
290 |         }
291 |       },
292 |       complete: function(results) {
293 |         if (opts.complete) opts.complete(results);
294 |       }
295 |     });
296 |   };
297 | };
298 | 
299 | /*
300 |  * DeviceScan static methods
301 |  */
302 | 
303 | /*
304 |  * @param [Array<String>] addresses IPs/hostnames (no ports!) to scan
305 |  * @param [Object] opts the options hash
306 |  * @option opts [Function(resultsObject)] complete the complete callback (called once at end)
307 |  * @option opts [Function(singleResult)] update the update callback (called on every check)
308 |  */
309 | DeviceScan.start = function(addresses, opts) {
310 |   new DeviceScan(addresses).start(opts);
311 | };
312 | 
313 | /*
314 |  * exports
315 |  */
316 | lan.utils.merge(lan, {
317 |   DeviceScan: DeviceScan,
318 |   DeviceFingerprint: DeviceFingerprint
319 | });
320 | 
321 | }).call(window);
322 | 


--------------------------------------------------------------------------------
/src/db.js:
--------------------------------------------------------------------------------
   1 | /*
   2 |  * devices.js - a database of <img> fingerprints from the web interfaces of
   3 |  * popular routers and other LAN devices.
   4 |  *
   5 |  * MIT license.
   6 |  * @author joev
   7 |  */
   8 | (function(){
   9 | 
  10 | // set up namespaces
  11 | this.lan = this.lan || {};
  12 | this.lan.db = this.lan.db || {};
  13 | 
  14 | // Most of this database came from the jslanscanner project (https://code.google.com/p/jslanscanner).
  15 | // Big thanks to Gareth Heyes (thespanner.co.uk) for creating the database
  16 | // and allowing me to relicense it under MIT.
  17 | // I'm still deciding what to do with this exactly.
  18 | 
  19 | this.lan.db.devices = [
  20 |   {
  21 |     make: "Cisco",
  22 |     model: "Switch",
  23 |     fingerprints: [
  24 |       {
  25 |         type: "image",
  26 |         url: "/images/cisco_logo_header.png",
  27 |         width: 62,
  28 |         height: 33
  29 |       }
  30 |     ]
  31 |   },
  32 |   {
  33 |     make: "2Wire",
  34 |     model: "1000 Series",
  35 |     fingerprints:[
  36 |       {
  37 |         type: "image",
  38 |         url: "/base/web/def/def/images/nav_sl_logo.gif"
  39 |       }
  40 |     ]
  41 |   }, {
  42 |     make: "Polycom",
  43 |     model: "Unknown",
  44 |     fingerprints:[
  45 |       {
  46 |         type: "image",
  47 |         url: "/images/logo.png",
  48 |         width: 190,
  49 |         height: 56
  50 |       }
  51 |     ]
  52 |   }, {
  53 |     make: 'Epson',
  54 |     model: 'EpsonNet WebAssist',
  55 |     fingerprints: [
  56 |       {
  57 |         type: 'image',
  58 |         url: '/epsonlogo.gif',
  59 |         width: 79,
  60 |         height: 28
  61 |       }
  62 |     ]
  63 |   }, {
  64 |     make: 'DLink',
  65 |     model: 'dgl4100',
  66 |     fingerprints: [
  67 |       {
  68 |         type: 'image',
  69 |         url: '/html/images/dgl4100.jpg'
  70 |       }
  71 |     ]
  72 |   }, {
  73 |     make: 'DLink',
  74 |     model: 'dgl4300',
  75 |     fingerprints: [
  76 |       {
  77 |         type: 'image',
  78 |         url: '/html/images/dgl4300.jpg'
  79 |       }
  80 |     ]
  81 |   }, {
  82 |     make: 'DLink',
  83 |     model: 'di524',
  84 |     fingerprints: [
  85 |       {
  86 |         type: 'image',
  87 |         url: '/html/images/di524.jpg'
  88 |       }
  89 |     ]
  90 |   }, {
  91 |     make: "DLink",
  92 |     model: "di624",
  93 |     fingerprints:[
  94 |       {
  95 |         type: "image",
  96 |         url: "/html/images/di624.jpg"
  97 |       }
  98 |     ]
  99 |   }, {
 100 |     make: "DLink",
 101 |     model: "di624s",
 102 |     fingerprints:[
 103 |       {
 104 |         type: "image",
 105 |         url: "/html/images/di624s.jpg"
 106 |       }
 107 |     ]
 108 |   }, {
 109 |     make: "DLink",
 110 |     model: "di724gu",
 111 |     fingerprints:[
 112 |       {
 113 |         type: "image",
 114 |         url: "/html/images/di724gu.jpg"
 115 |       }
 116 |     ]
 117 |   }, {
 118 |     make: "DLink",
 119 |     model: "dilb604",
 120 |     fingerprints:[
 121 |       {
 122 |         type: "image",
 123 |         url: "/html/images/dilb604.jpg"
 124 |       }
 125 |     ]
 126 |   }, {
 127 |     make: "DLink",
 128 |     model: "dir130",
 129 |     fingerprints:[
 130 |       {
 131 |         type: "image",
 132 |         url: "/html/images/dir130.jpg"
 133 |       }
 134 |     ]
 135 |   }, {
 136 |     make: "DLink",
 137 |     model: "dir330",
 138 |     fingerprints:[
 139 |       {
 140 |         type: "image",
 141 |         url: "/html/images/dir330.jpg"
 142 |       }
 143 |     ]
 144 |   }, {
 145 |     make: "DLink",
 146 |     model: "dir450",
 147 |     fingerprints:[
 148 |       {
 149 |         type: "image",
 150 |         url: "/html/images/dir450.jpg"
 151 |       }
 152 |     ]
 153 |   }, {
 154 |     make: "DLink",
 155 |     model: "dir451",
 156 |     fingerprints:[
 157 |       {
 158 |         type: "image",
 159 |         url: "/html/images/dir451.jpg"
 160 |       }
 161 |     ]
 162 |   }, {
 163 |     make: "DLink",
 164 |     model: "dir615",
 165 |     fingerprints:[
 166 |       {
 167 |         type: "image",
 168 |         url: "/html/images/dir615.jpg"
 169 |       }
 170 |     ]
 171 |   }, {
 172 |     make: "DLink",
 173 |     model: "dir625",
 174 |     fingerprints:[
 175 |       {
 176 |         type: "image",
 177 |         url: "/html/images/dir625.jpg"
 178 |       }
 179 |     ]
 180 |   }, {
 181 |     make: "DLink",
 182 |     model: "dir635",
 183 |     fingerprints:[
 184 |       {
 185 |         type: "image",
 186 |         url: "/html/images/dir635.jpg"
 187 |       }
 188 |     ]
 189 |   }, {
 190 |     make: "DLink",
 191 |     model: "dir655",
 192 |     fingerprints:[
 193 |       {
 194 |         type: "image",
 195 |         url: "/html/images/dir655.jpg"
 196 |       }
 197 |     ]
 198 |   }, {
 199 |     make: "DLink",
 200 |     model: "dir660",
 201 |     fingerprints:[
 202 |       {
 203 |         type: "image",
 204 |         url: "/html/images/dir660.jpg"
 205 |       }
 206 |     ]
 207 |   }, {
 208 |     make: "DLink",
 209 |     model: "ebr2310",
 210 |     fingerprints:[
 211 |       {
 212 |         type: "image",
 213 |         url: "/html/images/ebr2310.jpg"
 214 |       }
 215 |     ]
 216 |   }, {
 217 |     make: "DLink",
 218 |     model: "kr1",
 219 |     fingerprints:[
 220 |       {
 221 |         type: "image",
 222 |         url: "/html/images/kr1.jpg"
 223 |       }
 224 |     ]
 225 |   }, {
 226 |     make: "DLink",
 227 |     model: "tmg5240",
 228 |     fingerprints:[
 229 |       {
 230 |         type: "image",
 231 |         url: "/html/images/tmg5240.jpg"
 232 |       }
 233 |     ]
 234 |   }, {
 235 |     make: "DLink",
 236 |     model: "wbr1310",
 237 |     fingerprints:[
 238 |       {
 239 |         type: "image",
 240 |         url: "/html/images/wbr1310.jpg"
 241 |       }
 242 |     ]
 243 |   }, {
 244 |     make: "DLink",
 245 |     model: "wbr2310",
 246 |     fingerprints:[
 247 |       {
 248 |         type: "image",
 249 |         url: "/html/images/wbr2310.jpg"
 250 |       }
 251 |     ]
 252 |   }, {
 253 |     make: "DLink",
 254 |     model: "dsl604",
 255 |     fingerprints:[
 256 |       {
 257 |         type: "image",
 258 |         url: "/html/images/dsl604.jpg"
 259 |       }
 260 |     ]
 261 |   }, {
 262 |     make: "DLink",
 263 |     model: "dsl2320b",
 264 |     fingerprints:[
 265 |       {
 266 |         type: "image",
 267 |         url: "/html/images/dsl2320b.jpg"
 268 |       }
 269 |     ]
 270 |   }, {
 271 |     make: "DLink",
 272 |     model: "dsl2540b",
 273 |     fingerprints:[
 274 |       {
 275 |         type: "image",
 276 |         url: "/html/images/dsl2540b.jpg"
 277 |       }
 278 |     ]
 279 |   }, {
 280 |     make: "DLink",
 281 |     model: "dsl2640b",
 282 |     fingerprints:[
 283 |       {
 284 |         type: "image",
 285 |         url: "/html/images/dsl2640b.jpg"
 286 |       }
 287 |     ]
 288 |   }, {
 289 |     make: "DLink",
 290 |     model: "dsl302g",
 291 |     fingerprints:[
 292 |       {
 293 |         type: "image",
 294 |         url: "/html/images/dsl302g.jpg"
 295 |       }
 296 |     ]
 297 |   }, {
 298 |     make: "DLink",
 299 |     model: "dsl502g",
 300 |     fingerprints:[
 301 |       {
 302 |         type: "image",
 303 |         url: "/html/images/dsl502g.jpg"
 304 |       }
 305 |     ]
 306 |   }, {
 307 |     make: "DLink",
 308 |     model: "dgl3420",
 309 |     fingerprints:[
 310 |       {
 311 |         type: "image",
 312 |         url: "/html/images/dgl3420.jpg"
 313 |       }
 314 |     ]
 315 |   }, {
 316 |     make: "DLink",
 317 |     model: "dwl2100ap",
 318 |     fingerprints:[
 319 |       {
 320 |         type: "image",
 321 |         url: "/html/images/dwl2100ap.jpg"
 322 |       }
 323 |     ]
 324 |   }, {
 325 |     make: "DLink",
 326 |     model: "dwl2130ap",
 327 |     fingerprints:[
 328 |       {
 329 |         type: "image",
 330 |         url: "/html/images/dwl2130ap.jpg"
 331 |       }
 332 |     ]
 333 |   }, {
 334 |     make: "DLink",
 335 |     model: "dwl2200ap",
 336 |     fingerprints:[
 337 |       {
 338 |         type: "image",
 339 |         url: "/html/images/dwl2200ap.jpg"
 340 |       }
 341 |     ]
 342 |   }, {
 343 |     make: "DLink",
 344 |     model: "dwl2230ap",
 345 |     fingerprints:[
 346 |       {
 347 |         type: "image",
 348 |         url: "/html/images/dwl2230ap.jpg"
 349 |       }
 350 |     ]
 351 |   }, {
 352 |     make: "DLink",
 353 |     model: "dwl2700ap",
 354 |     fingerprints:[
 355 |       {
 356 |         type: "image",
 357 |         url: "/html/images/dwl2700ap.jpg"
 358 |       }
 359 |     ]
 360 |   }, {
 361 |     make: "DLink",
 362 |     model: "dwl3200ap",
 363 |     fingerprints:[
 364 |       {
 365 |         type: "image",
 366 |         url: "/html/images/dwl3200ap.jpg"
 367 |       }
 368 |     ]
 369 |   }, {
 370 |     make: "DLink",
 371 |     model: "dwl7100ap",
 372 |     fingerprints:[
 373 |       {
 374 |         type: "image",
 375 |         url: "/html/images/dwl7100ap.jpg"
 376 |       }
 377 |     ]
 378 |   }, {
 379 |     make: "DLink",
 380 |     model: "dwl7130ap",
 381 |     fingerprints:[
 382 |       {
 383 |         type: "image",
 384 |         url: "/html/images/dwl7130ap.jpg"
 385 |       }
 386 |     ]
 387 |   }, {
 388 |     make: "DLink",
 389 |     model: "dwl7200ap",
 390 |     fingerprints:[
 391 |       {
 392 |         type: "image",
 393 |         url: "/html/images/dwl7200ap.jpg"
 394 |       }
 395 |     ]
 396 |   }, {
 397 |     make: "DLink",
 398 |     model: "dwl7230ap",
 399 |     fingerprints:[
 400 |       {
 401 |         type: "image",
 402 |         url: "/html/images/dwl7230ap.jpg"
 403 |       }
 404 |     ]
 405 |   }, {
 406 |     make: "DLink",
 407 |     model: "dwl7700ap",
 408 |     fingerprints:[
 409 |       {
 410 |         type: "image",
 411 |         url: "/html/images/dwl7700ap.jpg"
 412 |       }
 413 |     ]
 414 |   }, {
 415 |     make: "DLink",
 416 |     model: "dwl8200ap",
 417 |     fingerprints:[
 418 |       {
 419 |         type: "image",
 420 |         url: "/html/images/dwl8200ap.jpg"
 421 |       }
 422 |     ]
 423 |   }, {
 424 |     make: "DLink",
 425 |     model: "dwl8220ap",
 426 |     fingerprints:[
 427 |       {
 428 |         type: "image",
 429 |         url: "/html/images/dwl8220ap.jpg"
 430 |       }
 431 |     ]
 432 |   }, {
 433 |     make: "DLink",
 434 |     model: "dwlag132",
 435 |     fingerprints:[
 436 |       {
 437 |         type: "image",
 438 |         url: "/html/images/dwlag132.jpg"
 439 |       }
 440 |     ]
 441 |   }, {
 442 |     make: "DLink",
 443 |     model: "dwlag530",
 444 |     fingerprints:[
 445 |       {
 446 |         type: "image",
 447 |         url: "/html/images/dwlag530.jpg"
 448 |       }
 449 |     ]
 450 |   }, {
 451 |     make: "DLink",
 452 |     model: "dwlag660",
 453 |     fingerprints:[
 454 |       {
 455 |         type: "image",
 456 |         url: "/html/images/dwlag660.jpg"
 457 |       }
 458 |     ]
 459 |   }, {
 460 |     make: "DLink",
 461 |     model: "dwlag700ap",
 462 |     fingerprints:[
 463 |       {
 464 |         type: "image",
 465 |         url: "/html/images/dwlag700ap.jpg"
 466 |       }
 467 |     ]
 468 |   }, {
 469 |     make: "DLink",
 470 |     model: "dwlg120",
 471 |     fingerprints:[
 472 |       {
 473 |         type: "image",
 474 |         url: "/html/images/dwlg120.jpg"
 475 |       }
 476 |     ]
 477 |   }, {
 478 |     make: "DLink",
 479 |     model: "dwlg122",
 480 |     fingerprints:[
 481 |       {
 482 |         type: "image",
 483 |         url: "/html/images/dwlg122.jpg"
 484 |       }
 485 |     ]
 486 |   }, {
 487 |     make: "DLink",
 488 |     model: "dwlg132",
 489 |     fingerprints:[
 490 |       {
 491 |         type: "image",
 492 |         url: "/html/images/dwlg132.jpg"
 493 |       }
 494 |     ]
 495 |   }, {
 496 |     make: "DLink",
 497 |     model: "dwlg510",
 498 |     fingerprints:[
 499 |       {
 500 |         type: "image",
 501 |         url: "/html/images/dwlg510.jpg"
 502 |       }
 503 |     ]
 504 |   }, {
 505 |     make: "DLink",
 506 |     model: "dwlg520",
 507 |     fingerprints:[
 508 |       {
 509 |         type: "image",
 510 |         url: "/html/images/dwlg520.jpg"
 511 |       }
 512 |     ]
 513 |   }, {
 514 |     make: "DLink",
 515 |     model: "dwlg520m",
 516 |     fingerprints:[
 517 |       {
 518 |         type: "image",
 519 |         url: "/html/images/dwlg520m.jpg"
 520 |       }
 521 |     ]
 522 |   }, {
 523 |     make: "DLink",
 524 |     model: "dwlg550",
 525 |     fingerprints:[
 526 |       {
 527 |         type: "image",
 528 |         url: "/html/images/dwlg550.jpg"
 529 |       }
 530 |     ]
 531 |   }, {
 532 |     make: "DLink",
 533 |     model: "dwlg630",
 534 |     fingerprints:[
 535 |       {
 536 |         type: "image",
 537 |         url: "/html/images/dwlg630.jpg"
 538 |       }
 539 |     ]
 540 |   }, {
 541 |     make: "DLink",
 542 |     model: "dwlg650",
 543 |     fingerprints:[
 544 |       {
 545 |         type: "image",
 546 |         url: "/html/images/dwlg650.jpg"
 547 |       }
 548 |     ]
 549 |   }, {
 550 |     make: "DLink",
 551 |     model: "dwlg650m",
 552 |     fingerprints:[
 553 |       {
 554 |         type: "image",
 555 |         url: "/html/images/dwlg650m.jpg"
 556 |       }
 557 |     ]
 558 |   }, {
 559 |     make: "DLink",
 560 |     model: "dwlg680",
 561 |     fingerprints:[
 562 |       {
 563 |         type: "image",
 564 |         url: "/html/images/dwlg680.jpg"
 565 |       }
 566 |     ]
 567 |   }, {
 568 |     make: "DLink",
 569 |     model: "dwlg700ap",
 570 |     fingerprints:[
 571 |       {
 572 |         type: "image",
 573 |         url: "/html/images/dwlg700ap.jpg"
 574 |       }
 575 |     ]
 576 |   }, {
 577 |     make: "DLink",
 578 |     model: "dwlg710",
 579 |     fingerprints:[
 580 |       {
 581 |         type: "image",
 582 |         url: "/html/images/dwlg710.jpg"
 583 |       }
 584 |     ]
 585 |   }, {
 586 |     make: "DLink",
 587 |     model: "dwlg730ap",
 588 |     fingerprints:[
 589 |       {
 590 |         type: "image",
 591 |         url: "/html/images/dwlg730ap.jpg"
 592 |       }
 593 |     ]
 594 |   }, {
 595 |     make: "DLink",
 596 |     model: "dwlg820",
 597 |     fingerprints:[
 598 |       {
 599 |         type: "image",
 600 |         url: "/html/images/dwlg820.jpg"
 601 |       }
 602 |     ]
 603 |   }, {
 604 |     make: "DLink",
 605 |     model: "wda1320",
 606 |     fingerprints:[
 607 |       {
 608 |         type: "image",
 609 |         url: "/html/images/wda1320.jpg"
 610 |       }
 611 |     ]
 612 |   }, {
 613 |     make: "DLink",
 614 |     model: "wda2320",
 615 |     fingerprints:[
 616 |       {
 617 |         type: "image",
 618 |         url: "/html/images/wda2320.jpg"
 619 |       }
 620 |     ]
 621 |   }, {
 622 |     make: "DLink",
 623 |     model: "wna1330",
 624 |     fingerprints:[
 625 |       {
 626 |         type: "image",
 627 |         url: "/html/images/wna1330.jpg"
 628 |       }
 629 |     ]
 630 |   }, {
 631 |     make: "DLink",
 632 |     model: "wna2330",
 633 |     fingerprints:[
 634 |       {
 635 |         type: "image",
 636 |         url: "/html/images/wna2330.jpg"
 637 |       }
 638 |     ]
 639 |   }, {
 640 |     make: "DLink",
 641 |     model: "wua1340",
 642 |     fingerprints:[
 643 |       {
 644 |         type: "image",
 645 |         url: "/html/images/wua1340.jpg"
 646 |       }
 647 |     ]
 648 |   }, {
 649 |     make: "DLink",
 650 |     model: "wua2340",
 651 |     fingerprints:[
 652 |       {
 653 |         type: "image",
 654 |         url: "/html/images/wua2340.jpg"
 655 |       }
 656 |     ]
 657 |   }, {
 658 |     make: "DLink",
 659 |     model: "DSL502T",
 660 |     fingerprints:[
 661 |       {
 662 |         type: "image",
 663 |         url: "/html/images/help_p.jpg"
 664 |       }
 665 |     ]
 666 |   }, {
 667 |     make: "DLink",
 668 |     model: "DSL524T",
 669 |     fingerprints:[
 670 |       {
 671 |         type: "image",
 672 |         url: "/html/images/device.gif"
 673 |       }
 674 |     ]
 675 |   }, {
 676 |     make: "Linksys",
 677 |     model: "WRT54GL",
 678 |     fingerprints:[
 679 |       {
 680 |         type: "image",
 681 |         url: "/WRT56GL.gif"
 682 |       }
 683 |     ]
 684 |   }, {
 685 |     make: "Linksys",
 686 |     model: "WRT54GC",
 687 |     fingerprints:[
 688 |       {
 689 |         type: "image",
 690 |         url: "/UI_Linksys.gif"
 691 |       }
 692 |     ]
 693 |   }, {
 694 |     make: "Linksys",
 695 |     model: "WRT54G",
 696 |     fingerprints:[
 697 |       {
 698 |         type: "image",
 699 |         url: "/WRT54G.gif"
 700 |       }
 701 |     ]
 702 |   }, {
 703 |     make: "Linksys",
 704 |     model: "WRT54GS",
 705 |     fingerprints:[
 706 |       {
 707 |         type: "image",
 708 |         url: "/UILinksys.gif"
 709 |       }
 710 |     ]
 711 |   }, {
 712 |     make: 'Linksys',
 713 |     model: 'WRT100',
 714 |     auth: 'basic',
 715 |     fingerprints: [
 716 |       {
 717 |         type: 'image',
 718 |         url: '/logo.gif', // FIXME!
 719 |         width: 800,
 720 |         height: 20
 721 |       }
 722 |     ]
 723 |   }, {
 724 |     make: 'Linksys',
 725 |     model: 'WRT110',
 726 |     auth: 'basic',
 727 |     fingerprints: [
 728 |       {
 729 |         type: 'image',
 730 |         url: '/logo.gif', // FIXME
 731 |         width: 800,
 732 |         height: 300
 733 |       }
 734 |     ]
 735 |   }, {
 736 |     make: 'Linksys',
 737 |     model: 'WRT120N',
 738 |     auth: 'basic',
 739 |     fingerprints: [
 740 |       {
 741 |         type: 'image',
 742 |         url: '/logo.gif', // FIXME
 743 |         width: 800,
 744 |         height: 300
 745 |       }
 746 |     ]
 747 |   }, {
 748 |     make: 'Motorola',
 749 |     model: 'SURFboard Gateway SBG6580',
 750 |     auth: 'ip',
 751 |     fingerprints: [
 752 |       {
 753 |         type: 'image',
 754 |         url: '/logo_new.gif',
 755 |         width: 176,
 756 |         height: 125
 757 |       }
 758 |     ]
 759 |   }, {
 760 |     make: "Netgear",
 761 |     model: "CG814WG",
 762 |     fingerprints:[
 763 |       {
 764 |         type: "image",
 765 |         url: "/images/../settingsCG814WG.gif"
 766 |       }
 767 |     ]
 768 |   }, {
 769 |     make: "Netgear",
 770 |     model: "CM212",
 771 |     fingerprints:[
 772 |       {
 773 |         type: "image",
 774 |         url: "/images/../settingsCM212.gif"
 775 |       }
 776 |     ]
 777 |   }, {
 778 |     make: "Netgear",
 779 |     model: "DG632",
 780 |     fingerprints:[
 781 |       {
 782 |         type: "image",
 783 |         url: "/images/../settingsDG632.gif"
 784 |       }
 785 |     ]
 786 |   }, {
 787 |     make: "Netgear",
 788 |     model: "DG632B",
 789 |     fingerprints:[
 790 |       {
 791 |         type: "image",
 792 |         url: "/images/../settingsDG632B.gif"
 793 |       }
 794 |     ]
 795 |   }, {
 796 |     make: "Netgear",
 797 |     model: "DG814",
 798 |     fingerprints:[
 799 |       {
 800 |         type: "image",
 801 |         url: "/images/../settingsDG814.gif"
 802 |       }
 803 |     ]
 804 |   }, {
 805 |     make: "Netgear",
 806 |     model: "DG824M",
 807 |     fingerprints:[
 808 |       {
 809 |         type: "image",
 810 |         url: "/images/../settingsDG824M.gif"
 811 |       }
 812 |     ]
 813 |   }, {
 814 |     make: "Netgear",
 815 |     model: "DG834",
 816 |     fingerprints:[
 817 |       {
 818 |         type: "image",
 819 |         url: "/images/../settingsDG834.gif"
 820 |       }
 821 |     ]
 822 |   }, {
 823 |     make: "Netgear",
 824 |     model: "DG834B",
 825 |     fingerprints:[
 826 |       {
 827 |         type: "image",
 828 |         url: "/images/../settingsDG834B.gif"
 829 |       }
 830 |     ]
 831 |   }, {
 832 |     make: "Netgear",
 833 |     model: "DG834G",
 834 |     fingerprints:[
 835 |       {
 836 |         type: "image",
 837 |         url: "/images/../settingsDG834G.gif"
 838 |       }
 839 |     ]
 840 |   }, {
 841 |     make: "Netgear",
 842 |     model: "DG834GB",
 843 |     fingerprints:[
 844 |       {
 845 |         type: "image",
 846 |         url: "/images/../settingsDG834GB.gif"
 847 |       }
 848 |     ]
 849 |   }, {
 850 |     make: "Netgear",
 851 |     model: "DG834GT",
 852 |     fingerprints:[
 853 |       {
 854 |         type: "image",
 855 |         url: "/images/../settingsDG834GT.gif"
 856 |       }
 857 |     ]
 858 |   }, {
 859 |     make: "Netgear",
 860 |     model: "DG834GTB",
 861 |     fingerprints:[
 862 |       {
 863 |         type: "image",
 864 |         url: "/images/../settingsDG834GTB.gif"
 865 |       }
 866 |     ]
 867 |   }, {
 868 |     make: "Netgear",
 869 |     model: "DG834GV",
 870 |     fingerprints:[
 871 |       {
 872 |         type: "image",
 873 |         url: "/images/../settingsDG834GV.gif"
 874 |       }
 875 |     ]
 876 |   }, {
 877 |     make: "Netgear",
 878 |     model: "dg834N",
 879 |     fingerprints:[
 880 |       {
 881 |         type: "image",
 882 |         url: "/images/../settingsdg834N.gif"
 883 |       }
 884 |     ]
 885 |   }, {
 886 |     make: "Netgear",
 887 |     model: "DG834PN",
 888 |     fingerprints:[
 889 |       {
 890 |         type: "image",
 891 |         url: "/images/../settingsDG834PN.gif"
 892 |       }
 893 |     ]
 894 |   }, {
 895 |     make: "Netgear",
 896 |     model: "DGFV338",
 897 |     fingerprints:[
 898 |       {
 899 |         type: "image",
 900 |         url: "/images/../settingsDGFV338.gif"
 901 |       }
 902 |     ]
 903 |   }, {
 904 |     make: "Netgear",
 905 |     model: "DM111P",
 906 |     fingerprints:[
 907 |       {
 908 |         type: "image",
 909 |         url: "/images/../settingsDM111P.gif"
 910 |       }
 911 |     ]
 912 |   }, {
 913 |     make: "Netgear",
 914 |     model: "DM602",
 915 |     fingerprints:[
 916 |       {
 917 |         type: "image",
 918 |         url: "/images/../settingsDM602.gif"
 919 |       }
 920 |     ]
 921 |   }, {
 922 |     make: "Netgear",
 923 |     model: "FM114P",
 924 |     fingerprints:[
 925 |       {
 926 |         type: "image",
 927 |         url: "/images/../settingsFM114P.gif"
 928 |       }
 929 |     ]
 930 |   }, {
 931 |     make: "Netgear",
 932 |     model: "FR114P",
 933 |     fingerprints:[
 934 |       {
 935 |         type: "image",
 936 |         url: "/images/../settingsFR114P.gif"
 937 |       }
 938 |     ]
 939 |   }, {
 940 |     make: "Netgear",
 941 |     model: "FR114W",
 942 |     fingerprints:[
 943 |       {
 944 |         type: "image",
 945 |         url: "/images/../settingsFR114W.gif"
 946 |       }
 947 |     ]
 948 |   }, {
 949 |     make: "Netgear",
 950 |     model: "FR314",
 951 |     fingerprints:[
 952 |       {
 953 |         type: "image",
 954 |         url: "/images/../settingsFR314.gif"
 955 |       }
 956 |     ]
 957 |   }, {
 958 |     make: "Netgear",
 959 |     model: "FR318",
 960 |     fingerprints:[
 961 |       {
 962 |         type: "image",
 963 |         url: "/images/../settingsFR318.gif"
 964 |       }
 965 |     ]
 966 |   }, {
 967 |     make: "Netgear",
 968 |     model: "FR328S",
 969 |     fingerprints:[
 970 |       {
 971 |         type: "image",
 972 |         url: "/images/../settingsFR328S.gif"
 973 |       }
 974 |     ]
 975 |   }, {
 976 |     make: "Netgear",
 977 |     model: "FV318",
 978 |     fingerprints:[
 979 |       {
 980 |         type: "image",
 981 |         url: "/images/../settingsFV318.gif"
 982 |       }
 983 |     ]
 984 |   }, {
 985 |     make: "Netgear",
 986 |     model: "FVG318",
 987 |     fingerprints:[
 988 |       {
 989 |         type: "image",
 990 |         url: "/images/../settingsFVG318.gif"
 991 |       }
 992 |     ]
 993 |   }, {
 994 |     make: "Netgear",
 995 |     model: "FVL328",
 996 |     fingerprints:[
 997 |       {
 998 |         type: "image",
 999 |         url: "/images/../settingsFVL328.gif"
1000 |       }
1001 |     ]
1002 |   }, {
1003 |     make: "Netgear",
1004 |     model: "FVM318",
1005 |     fingerprints:[
1006 |       {
1007 |         type: "image",
1008 |         url: "/images/../settingsFVM318.gif"
1009 |       }
1010 |     ]
1011 |   }, {
1012 |     make: "Netgear",
1013 |     model: "FVS114",
1014 |     fingerprints:[
1015 |       {
1016 |         type: "image",
1017 |         url: "/images/../settingsFVS114.gif"
1018 |       }
1019 |     ]
1020 |   }, {
1021 |     make: "Netgear",
1022 |     model: "FVS124G",
1023 |     fingerprints:[
1024 |       {
1025 |         type: "image",
1026 |         url: "/images/../settingsFVS124G.gif"
1027 |       }
1028 |     ]
1029 |   }, {
1030 |     make: "Netgear",
1031 |     model: "FVS318",
1032 |     fingerprints:[
1033 |       {
1034 |         type: "image",
1035 |         url: "/images/../settingsFVS318.gif"
1036 |       }
1037 |     ]
1038 |   }, {
1039 |     make: "Netgear",
1040 |     model: "FVS328",
1041 |     fingerprints:[
1042 |       {
1043 |         type: "image",
1044 |         url: "/images/../settingsFVS328.gif"
1045 |       }
1046 |     ]
1047 |   }, {
1048 |     make: "Netgear",
1049 |     model: "FVS338",
1050 |     fingerprints:[
1051 |       {
1052 |         type: "image",
1053 |         url: "/images/../settingsFVS338.gif"
1054 |       }
1055 |     ]
1056 |   }, {
1057 |     make: "Netgear",
1058 |     model: "FVX538",
1059 |     fingerprints:[
1060 |       {
1061 |         type: "image",
1062 |         url: "/images/../settingsFVX538.gif"
1063 |       }
1064 |     ]
1065 |   }, {
1066 |     make: "Netgear",
1067 |     model: "FWAG114",
1068 |     fingerprints:[
1069 |       {
1070 |         type: "image",
1071 |         url: "/images/../settingsFWAG114.gif"
1072 |       }
1073 |     ]
1074 |   }, {
1075 |     make: "Netgear",
1076 |     model: "FWG114P",
1077 |     fingerprints:[
1078 |       {
1079 |         type: "image",
1080 |         url: "/images/../settingsFWG114P.gif"
1081 |       }
1082 |     ]
1083 |   }, {
1084 |     make: "Netgear",
1085 |     model: "GA302T",
1086 |     fingerprints:[
1087 |       {
1088 |         type: "image",
1089 |         url: "/images/../settingsGA302T.gif"
1090 |       }
1091 |     ]
1092 |   }, {
1093 |     make: "Netgear",
1094 |     model: "GA311",
1095 |     fingerprints:[
1096 |       {
1097 |         type: "image",
1098 |         url: "/images/../settingsGA311.gif"
1099 |       }
1100 |     ]
1101 |   }, {
1102 |     make: "Netgear",
1103 |     model: "GA511",
1104 |     fingerprints:[
1105 |       {
1106 |         type: "image",
1107 |         url: "/images/../settingsGA511.gif"
1108 |       }
1109 |     ]
1110 |   }, {
1111 |     make: "Netgear",
1112 |     model: "GA620",
1113 |     fingerprints:[
1114 |       {
1115 |         type: "image",
1116 |         url: "/images/../settingsGA620.gif"
1117 |       }
1118 |     ]
1119 |   }, {
1120 |     make: "Netgear",
1121 |     model: "GA621",
1122 |     fingerprints:[
1123 |       {
1124 |         type: "image",
1125 |         url: "/images/../settingsGA621.gif"
1126 |       }
1127 |     ]
1128 |   }, {
1129 |     make: "Netgear",
1130 |     model: "GA622T",
1131 |     fingerprints:[
1132 |       {
1133 |         type: "image",
1134 |         url: "/images/../settingsGA622T.gif"
1135 |       }
1136 |     ]
1137 |   }, {
1138 |     make: "Netgear",
1139 |     model: "HE102",
1140 |     fingerprints:[
1141 |       {
1142 |         type: "image",
1143 |         url: "/images/../settingsHE102.gif"
1144 |       }
1145 |     ]
1146 |   }, {
1147 |     make: "Netgear",
1148 |     model: "HR314",
1149 |     fingerprints:[
1150 |       {
1151 |         type: "image",
1152 |         url: "/images/../settingsHR314.gif"
1153 |       }
1154 |     ]
1155 |   }, {
1156 |     make: "Netgear",
1157 |     model: "JFS516",
1158 |     fingerprints:[
1159 |       {
1160 |         type: "image",
1161 |         url: "/images/../settingsJFS516.gif"
1162 |       }
1163 |     ]
1164 |   }, {
1165 |     make: "Netgear",
1166 |     model: "JFS524",
1167 |     fingerprints:[
1168 |       {
1169 |         type: "image",
1170 |         url: "/images/../settingsJFS524.gif"
1171 |       }
1172 |     ]
1173 |   }, {
1174 |     make: "Netgear",
1175 |     model: "JFS524F",
1176 |     fingerprints:[
1177 |       {
1178 |         type: "image",
1179 |         url: "/images/../settingsJFS524F.gif"
1180 |       }
1181 |     ]
1182 |   }, {
1183 |     make: "Netgear",
1184 |     model: "JGS516",
1185 |     fingerprints:[
1186 |       {
1187 |         type: "image",
1188 |         url: "/images/../settingsJGS516.gif"
1189 |       }
1190 |     ]
1191 |   }, {
1192 |     make: "Netgear",
1193 |     model: "JGS524",
1194 |     fingerprints:[
1195 |       {
1196 |         type: "image",
1197 |         url: "/images/../settingsJGS524.gif"
1198 |       }
1199 |     ]
1200 |   }, {
1201 |     make: "Netgear",
1202 |     model: "JGS524F",
1203 |     fingerprints:[
1204 |       {
1205 |         type: "image",
1206 |         url: "/images/../settingsJGS524F.gif"
1207 |       }
1208 |     ]
1209 |   }, {
1210 |     make: "Netgear",
1211 |     model: "KWGR614",
1212 |     fingerprints:[
1213 |       {
1214 |         type: "image",
1215 |         url: "/images/../settingsKWGR614.gif"
1216 |       }
1217 |     ]
1218 |   }, {
1219 |     make: "Netgear",
1220 |     model: "ME101",
1221 |     fingerprints:[
1222 |       {
1223 |         type: "image",
1224 |         url: "/images/../settingsME101.gif"
1225 |       }
1226 |     ]
1227 |   }, {
1228 |     make: "Netgear",
1229 |     model: "ME102",
1230 |     fingerprints:[
1231 |       {
1232 |         type: "image",
1233 |         url: "/images/../settingsME102.gif"
1234 |       }
1235 |     ]
1236 |   }, {
1237 |     make: "Netgear",
1238 |     model: "ME103",
1239 |     fingerprints:[
1240 |       {
1241 |         type: "image",
1242 |         url: "/images/../settingsME103.gif"
1243 |       }
1244 |     ]
1245 |   }, {
1246 |     make: "Netgear",
1247 |     model: "MR314",
1248 |     fingerprints:[
1249 |       {
1250 |         type: "image",
1251 |         url: "/images/../settingsMR314.gif"
1252 |       }
1253 |     ]
1254 |   }, {
1255 |     make: "Netgear",
1256 |     model: "MR814",
1257 |     fingerprints:[
1258 |       {
1259 |         type: "image",
1260 |         url: "/images/../settingsMR814.gif"
1261 |       }
1262 |     ]
1263 |   }, {
1264 |     make: "Netgear",
1265 |     model: "RH340",
1266 |     fingerprints:[
1267 |       {
1268 |         type: "image",
1269 |         url: "/images/../settingsRH340.gif"
1270 |       }
1271 |     ]
1272 |   }, {
1273 |     make: "Netgear",
1274 |     model: "RH348",
1275 |     fingerprints:[
1276 |       {
1277 |         type: "image",
1278 |         url: "/images/../settingsRH348.gif"
1279 |       }
1280 |     ]
1281 |   }, {
1282 |     make: "Netgear",
1283 |     model: "RM356",
1284 |     fingerprints:[
1285 |       {
1286 |         type: "image",
1287 |         url: "/images/../settingsRM356.gif"
1288 |       }
1289 |     ]
1290 |   }, {
1291 |     make: "Netgear",
1292 |     model: "RO318",
1293 |     fingerprints:[
1294 |       {
1295 |         type: "image",
1296 |         url: "/images/../settingsRO318.gif"
1297 |       }
1298 |     ]
1299 |   }, {
1300 |     make: "Netgear",
1301 |     model: "RP114",
1302 |     fingerprints:[
1303 |       {
1304 |         type: "image",
1305 |         url: "/images/../settingsRP114.gif"
1306 |       }
1307 |     ]
1308 |   }, {
1309 |     make: "Netgear",
1310 |     model: "RP334",
1311 |     fingerprints:[
1312 |       {
1313 |         type: "image",
1314 |         url: "/images/../settingsRP334.gif"
1315 |       }
1316 |     ]
1317 |   }, {
1318 |     make: "Netgear",
1319 |     model: "RP614",
1320 |     fingerprints:[
1321 |       {
1322 |         type: "image",
1323 |         url: "/images/../settingsRP614.gif"
1324 |       }
1325 |     ]
1326 |   }, {
1327 |     make: "Netgear",
1328 |     model: "RT311",
1329 |     fingerprints:[
1330 |       {
1331 |         type: "image",
1332 |         url: "/images/../settingsRT311.gif"
1333 |       }
1334 |     ]
1335 |   }, {
1336 |     make: "Netgear",
1337 |     model: "RT314",
1338 |     fingerprints:[
1339 |       {
1340 |         type: "image",
1341 |         url: "/images/../settingsRT314.gif"
1342 |       }
1343 |     ]
1344 |   }, {
1345 |     make: "Netgear",
1346 |     model: "RT328",
1347 |     fingerprints:[
1348 |       {
1349 |         type: "image",
1350 |         url: "/images/../settingsRT328.gif"
1351 |       }
1352 |     ]
1353 |   }, {
1354 |     make: "Netgear",
1355 |     model: "RT338",
1356 |     fingerprints:[
1357 |       {
1358 |         type: "image",
1359 |         url: "/images/../settingsRT338.gif"
1360 |       }
1361 |     ]
1362 |   }, {
1363 |     make: "Netgear",
1364 |     model: "WAB102",
1365 |     fingerprints:[
1366 |       {
1367 |         type: "image",
1368 |         url: "/images/../settingsWAB102.gif"
1369 |       }
1370 |     ]
1371 |   }, {
1372 |     make: "Netgear",
1373 |     model: "WAG102",
1374 |     fingerprints:[
1375 |       {
1376 |         type: "image",
1377 |         url: "/images/../settingsWAG102.gif"
1378 |       }
1379 |     ]
1380 |   }, {
1381 |     make: "Netgear",
1382 |     model: "WAG302",
1383 |     fingerprints:[
1384 |       {
1385 |         type: "image",
1386 |         url: "/images/../settingsWAG302.gif"
1387 |       }
1388 |     ]
1389 |   }, {
1390 |     make: "Netgear",
1391 |     model: "WAGL102",
1392 |     fingerprints:[
1393 |       {
1394 |         type: "image",
1395 |         url: "/images/../settingsWAGL102.gif"
1396 |       }
1397 |     ]
1398 |   }, {
1399 |     make: "Netgear",
1400 |     model: "WAGR614",
1401 |     fingerprints:[
1402 |       {
1403 |         type: "image",
1404 |         url: "/images/../settingsWAGR614.gif"
1405 |       }
1406 |     ]
1407 |   }, {
1408 |     make: "Netgear",
1409 |     model: "WG102",
1410 |     fingerprints:[
1411 |       {
1412 |         type: "image",
1413 |         url: "/images/../settingsWG102.gif"
1414 |       }
1415 |     ]
1416 |   }, {
1417 |     make: "Netgear",
1418 |     model: "WG111",
1419 |     fingerprints:[
1420 |       {
1421 |         type: "image",
1422 |         url: "/images/../settingsWG111.gif"
1423 |       }
1424 |     ]
1425 |   }, {
1426 |     make: "Netgear",
1427 |     model: "WG111T",
1428 |     fingerprints:[
1429 |       {
1430 |         type: "image",
1431 |         url: "/images/../settingsWG111T.gif"
1432 |       }
1433 |     ]
1434 |   }, {
1435 |     make: "Netgear",
1436 |     model: "WG302",
1437 |     fingerprints:[
1438 |       {
1439 |         type: "image",
1440 |         url: "/images/../settingsWG302.gif"
1441 |       }
1442 |     ]
1443 |   }, {
1444 |     make: "Netgear",
1445 |     model: "WG311",
1446 |     fingerprints:[
1447 |       {
1448 |         type: "image",
1449 |         url: "/images/../settingsWG311.gif"
1450 |       }
1451 |     ]
1452 |   }, {
1453 |     make: "Netgear",
1454 |     model: "WG602",
1455 |     fingerprints:[
1456 |       {
1457 |         type: "image",
1458 |         url: "/images/../settingsWG602.gif"
1459 |       }
1460 |     ]
1461 |   }, {
1462 |     make: "Netgear",
1463 |     model: "WGE101",
1464 |     fingerprints:[
1465 |       {
1466 |         type: "image",
1467 |         url: "/images/../settingsWGE101.gif"
1468 |       }
1469 |     ]
1470 |   }, {
1471 |     make: "Netgear",
1472 |     model: "WGE111",
1473 |     fingerprints:[
1474 |       {
1475 |         type: "image",
1476 |         url: "/images/../settingsWGE111.gif"
1477 |       }
1478 |     ]
1479 |   }, {
1480 |     make: "Netgear",
1481 |     model: "WGL102",
1482 |     fingerprints:[
1483 |       {
1484 |         type: "image",
1485 |         url: "/images/../settingsWGL102.gif"
1486 |       }
1487 |     ]
1488 |   }, {
1489 |     make: "Netgear",
1490 |     model: "WGM124",
1491 |     fingerprints:[
1492 |       {
1493 |         type: "image",
1494 |         url: "/images/../settingsWGM124.gif"
1495 |       }
1496 |     ]
1497 |   }, {
1498 |     make: "Netgear",
1499 |     model: "WGR101",
1500 |     fingerprints:[
1501 |       {
1502 |         type: "image",
1503 |         url: "/images/../settingsWGR101.gif"
1504 |       }
1505 |     ]
1506 |   }, {
1507 |     make: "Netgear",
1508 |     model: "WGR614",
1509 |     fingerprints:[
1510 |       {
1511 |         type: "image",
1512 |         url: "/images/../settingsWGR614.gif"
1513 |       }
1514 |     ]
1515 |   }, {
1516 |     make: "Netgear",
1517 |     model: "WGT624",
1518 |     fingerprints:[
1519 |       {
1520 |         type: "image",
1521 |         url: "/images/../settingsWGT624.gif"
1522 |       }
1523 |     ]
1524 |   }, {
1525 |     make: "Netgear",
1526 |     model: "WGT624SC",
1527 |     fingerprints:[
1528 |       {
1529 |         type: "image",
1530 |         url: "/images/../settingsWGT624SC.gif"
1531 |       }
1532 |     ]
1533 |   }, {
1534 |     make: "Netgear",
1535 |     model: "WGT634U",
1536 |     fingerprints:[
1537 |       {
1538 |         type: "image",
1539 |         url: "/images/../settingsWGT634U.gif"
1540 |       }
1541 |     ]
1542 |   }, {
1543 |     make: "Netgear",
1544 |     model: "WGU624",
1545 |     fingerprints:[
1546 |       {
1547 |         type: "image",
1548 |         url: "/images/../settingsWGU624.gif"
1549 |       }
1550 |     ]
1551 |   }, {
1552 |     make: "Netgear",
1553 |     model: "WGX102",
1554 |     fingerprints:[
1555 |       {
1556 |         type: "image",
1557 |         url: "/images/../settingsWGX102.gif"
1558 |       }
1559 |     ]
1560 |   }, {
1561 |     make: "Netgear",
1562 |     model: "WN121T",
1563 |     fingerprints:[
1564 |       {
1565 |         type: "image",
1566 |         url: "/images/../settingsWN121T.gif"
1567 |       }
1568 |     ]
1569 |   }, {
1570 |     make: "Netgear",
1571 |     model: "WN311B",
1572 |     fingerprints:[
1573 |       {
1574 |         type: "image",
1575 |         url: "/images/../settingsWN311B.gif"
1576 |       }
1577 |     ]
1578 |   }, {
1579 |     make: "Netgear",
1580 |     model: "WN311T",
1581 |     fingerprints:[
1582 |       {
1583 |         type: "image",
1584 |         url: "/images/../settingsWN311T.gif"
1585 |       }
1586 |     ]
1587 |   }, {
1588 |     make: "Netgear",
1589 |     model: "WN511B",
1590 |     fingerprints:[
1591 |       {
1592 |         type: "image",
1593 |         url: "/images/../settingsWN511B.gif"
1594 |       }
1595 |     ]
1596 |   }, {
1597 |     make: "Netgear",
1598 |     model: "WN511T",
1599 |     fingerprints:[
1600 |       {
1601 |         type: "image",
1602 |         url: "/images/../settingsWN511T.gif"
1603 |       }
1604 |     ]
1605 |   }, {
1606 |     make: "Netgear",
1607 |     model: "WN802T",
1608 |     fingerprints:[
1609 |       {
1610 |         type: "image",
1611 |         url: "/images/../settingsWN802T.gif"
1612 |       }
1613 |     ]
1614 |   }, {
1615 |     make: "Netgear",
1616 |     model: "WNR834B",
1617 |     fingerprints:[
1618 |       {
1619 |         type: "image",
1620 |         url: "/images/../settingsWNR834B.gif"
1621 |       }
1622 |     ]
1623 |   }, {
1624 |     make: "Netgear",
1625 |     model: "WNR834M",
1626 |     fingerprints:[
1627 |       {
1628 |         type: "image",
1629 |         url: "/images/../settingsWNR834M.gif"
1630 |       }
1631 |     ]
1632 |   }, {
1633 |     make: "Netgear",
1634 |     model: "WNR854T",
1635 |     fingerprints:[
1636 |       {
1637 |         type: "image",
1638 |         url: "/images/../settingsWNR854T.gif"
1639 |       }
1640 |     ]
1641 |   }, {
1642 |     make: "Netgear",
1643 |     model: "WPN802",
1644 |     fingerprints:[
1645 |       {
1646 |         type: "image",
1647 |         url: "/images/../settingsWPN802.gif"
1648 |       }
1649 |     ]
1650 |   }, {
1651 |     make: "Netgear",
1652 |     model: "WPN824",
1653 |     fingerprints:[
1654 |       {
1655 |         type: "image",
1656 |         url: "/images/../settingsWPN824.gif"
1657 |       }
1658 |     ]
1659 |   }, {
1660 |     make: "Netgear",
1661 |     model: "XM128",
1662 |     fingerprints:[
1663 |       {
1664 |         type: "image",
1665 |         url: "/images/../settingsXM128.gif"
1666 |       }
1667 |     ]
1668 |   }, {
1669 |     make: "Sitecom",
1670 |     model: "WL114",
1671 |     fingerprints:[
1672 |       {
1673 |         type: "image",
1674 |         url: "/slogo.gif"
1675 |       }
1676 |     ]
1677 |   }, {
1678 |     make: "SurfinBird",
1679 |     model: "313",
1680 |     fingerprints:[
1681 |       {
1682 |         type: "image",
1683 |         url: "/images/help_p.gif"
1684 |       }
1685 |     ]
1686 |   }, {
1687 |     make: "SMC",
1688 |     model: "7004ABR",
1689 |     fingerprints:[
1690 |       {
1691 |         type: "image",
1692 |         url: "/images/logo.gif"
1693 |       }
1694 |     ]
1695 |   }, {
1696 |     make: "Thomson",
1697 |     model: "Cable Modem A801",
1698 |     fingerprints:[
1699 |       {
1700 |         type: "image",
1701 |         url: "/images/thomson.gif"
1702 |       }
1703 |     ]
1704 |   }, {
1705 |     make: "Vigor",
1706 |     model: "2600V",
1707 |     fingerprints:[
1708 |       {
1709 |         type: "image",
1710 |         url: "/images/logo1.jpg"
1711 |       }
1712 |     ]
1713 |   }, {
1714 |     make: "ZyXEL",
1715 |     model: "Prestige 660H61",
1716 |     fingerprints:[
1717 |       {
1718 |         type: "image",
1719 |         url: "/dslroutery/imgshop/full/NETZ1431.jpg"
1720 |       }
1721 |     ]
1722 |   }, {
1723 |     make: "ZyXEL",
1724 |     model: "Zywall",
1725 |     fingerprints:[
1726 |       {
1727 |         type: "image",
1728 |         url: "/images/Logo.gif"
1729 |       }
1730 |     ]
1731 |   }
1732 | ];
1733 | 
1734 | this.lan.db.manufacturers = {
1735 |   Cisco: {
1736 | 
1737 |   },
1738 |   Linksys: {
1739 |     default_addresses: [
1740 |       '192.168.0.1', '192.168.1.1'
1741 |     ]
1742 |   },
1743 |   Dlink: {
1744 |     default_addresses: [
1745 |       '192.168.1.30',
1746 |       '192.168.1.50'
1747 |     ]
1748 |   },
1749 |   Motorola: {
1750 |     default_addresses: [
1751 |       '192.168.0.1'
1752 |     ]
1753 |   },
1754 |   Thomson: {
1755 | 
1756 |   }
1757 | };
1758 | 
1759 | }).call(window);
1760 | 


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