+
+
+
+
+
+
+
+
+
+
+
+
+
+
Local Network Any Permission
+
Granted Permissions
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Digest / None Digest / TLS Kerberos / None Kerberos / TLS Auth / Security
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Warning: Some power actions may result in data loss and may disconnect the desktop, terminal or disk redirection sessions.
+
+
+
+
+
+
Primary display Secondary display Third display Consent Display
+
+
+
+
+
+
+ RLE8, Color Fast
+ RLE16, Color
+ RLE4G, Gray Fastest
+ RLE8G, Gray Fast
+ RAW8, Color Slow
+ RAW16, Color Very Slow
+
+
Image Encoding
+
+
+
+
+
Software KVM
+
+
+ 50%
+ 40%
+ 30%
+ 20%
+ 10%
+ 5%
+ 1%
+
+
Quality
+
+
+
+ 100%
+ 87.5%
+ 75%
+ 62.5%
+ 50%
+ 37.5%
+ 25%
+ 12.5%
+
+
Scaling
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ WPA2 PSK
+
+ WPA PSK
+
+
+
+
Authentication
+
+
+
+ CCMP-AES
+ TKIP-RC4
+ WEP
+ None
+
+
Encryption
+
+
+
+
+
+
+
+
+
+
+
+ Version 1
+ Version 2
+ Version 3
+ Version 4
+
+
Setup.bin version
+
+
+
+ Records will not be consumed
+ Records will be consumed
+
+
Record consumption
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Use encryption. The file will contain Intel® AMT credentials, saving using a password may help protect this data.
+
+
+
+
+
+
+
+
+
+
+
+ This will save the entire state of Intel® AMT for this machine into file. Passwords will not be saved, but some sensitive data may be included.
+
+
+
+
+
+
+
+
+
+ Disabled
+ Disabled, DHCP update
+ Enabled
+
+
Dynamic DNS client
+
+
+
+
+
+
+
+
+
+
+
+ Power up
+ Power cycle
+ Power down
+ Reset
+ OS Wake from Standby
+ OS Power Saving
+ Set boot options
+
+
Remote Command
+
+
+
+
+ None
+ Force CD/DVD Boot
+ Force PXE Boot
+ Force Hard Disk Boot
+ Force Diagnostic Boot
+
+
Boot Source
+
+
+
+ None
+ Index 1
+ Index 2
+ Index 3
+ Index 4
+
+
Boot Media Index
+
+
+
+ Boot to floppy
+ Boot to CDROM
+
+
IDER Boot Device
+
+
+
+ System Default
+ Quiet
+ Verbose
+ Blank Screen
+
+
Verbocity
+
+
+
+
WARNING: TLS is not used, password will be sent in the clear.
+
+
+
+
+
+
+
+
+
+
+
Wake date (year-month-day)
+
+
+
+
+
Wake time (hour:min:sec)
+
+
+
+
+
Interval (days-hours-min)
+
+
+
+
+ Keep alarm
+ Delete on completion
+
+
+
After wake
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mesh256.png b/mesh256.png
new file mode 100644
index 0000000..7b91526
Binary files /dev/null and b/mesh256.png differ
diff --git a/mesh256s.png b/mesh256s.png
new file mode 100644
index 0000000..fafd359
Binary files /dev/null and b/mesh256s.png differ
diff --git a/mesh32s.png b/mesh32s.png
new file mode 100644
index 0000000..31bac9c
Binary files /dev/null and b/mesh32s.png differ
diff --git a/meshcentral-server-0.2.0.js b/meshcentral-server-0.2.0.js
new file mode 100644
index 0000000..d07d321
--- /dev/null
+++ b/meshcentral-server-0.2.0.js
@@ -0,0 +1,286 @@
+/**
+* @description MeshCentral2 communication using websocket
+* @author Ylian Saint-Hilaire
+* @version v0.2.0a
+*/
+
+// Construct a MeshCentral2 communication object
+var CreateMeshCentralServer = function (host, port, path, username, password, token, certhash) {
+ var obj = {};
+ obj.host = host;
+ obj.port = port;
+ obj.path = path;
+ obj.username = username;
+ obj.password = password;
+ obj.token = token;
+ obj.certhash = certhash;
+ //obj.proxy = proxy;
+ //obj.proxyPort = 80;
+ obj.socket = null;
+ obj.socketState = 0;
+ obj.net = require('net');
+ obj.tls = require('tls');
+ obj.crypto = require('crypto');
+ obj.constants = require('constants');
+ obj.xtlsoptions = null;
+ obj.accumulator = "";
+ obj.accopcodes = 0;
+ obj.acclen = -1;
+ obj.accmask = false;
+ obj.meshes = {};
+ obj.computerlist = [];
+ obj.userinfo = null;
+ obj.xtlsCertificate = null;
+ obj.xtlsFingerprint = null;
+ obj.meshServerConnect = true;
+
+ // Events
+ obj.onStateChange = null;
+ obj.onNodeChange = null;
+
+ /*
+ // Parse the proxy
+ if (obj.proxy == '') { proxy = null; }
+ if (obj.proxy.indexOf(':') > 0) {
+ obj.proxyPort = parseInt(obj.proxy.substring(obj.proxy.indexOf(':') + 1));
+ obj.proxy = obj.proxy.substring(0, obj.proxy.indexOf(':'));
+ if (isNaN(obj.proxyPort)) { obj.proxy = null; obj.proxyPort = 0; }
+ }
+ */
+
+ // Called to initiate a websocket connection to the server
+ obj.connect = function () {
+ obj.socketState = 1;
+ if (obj.onStateChange != null) { obj.onStateChange(obj, obj.socketState); }
+ obj.accumulator = "";
+ obj.accopcodes = 0;
+ obj.acclen = -1;
+ obj.accmask = false;
+ obj.xtlsFingerprint = null;
+ if (obj.certhash == null) {
+ obj.socket = new obj.net.Socket();
+ obj.socket.setEncoding('binary');
+ obj.socket.connect(obj.port, obj.host, obj.xxOnSocketConnected);
+ } else {
+ //console.log('Connecting to wss://' + obj.host + ':' + obj.port + obj.path);
+ obj.socket = obj.tls.connect(obj.port, obj.host, { rejectUnauthorized: false }, _OnSocketConnected);
+ obj.socket.setEncoding('binary');
+ }
+ obj.socket.on('data', _OnSocketData);
+ obj.socket.on('close', _OnSocketClosed);
+ obj.socket.on('error', _OnSocketClosed);
+ }
+
+ obj.disconnect = function () { _OnSocketClosed("UserDisconnect"); }
+ obj.send = function (obj) { _Send(obj); }
+
+ // Called when the socket is connected, we still need to do work to get the websocket connected
+ function _OnSocketConnected() {
+ if (obj.socket == null) return;
+ // Check if this is really the MeshServer we want to connect to
+ obj.xtlsCertificate = obj.socket.getPeerCertificate();
+ obj.xtlsFingerprint = obj.xtlsCertificate.fingerprint.split(':').join('').toLowerCase();
+ if (obj.xtlsFingerprint != obj.certhash.split(':').join('').toLowerCase()) { _OnSocketClosed('HashMatchFail'); return; }
+
+ // If a authentication token is provided, place it in the login URL
+ var urlExtras = '';
+ if (obj.token != null) { urlExtras = '&token=' + obj.token; }
+
+ // Send the websocket switching header
+ obj.socket.write(new Buffer('GET ' + obj.path + '?user=' + encodeURIComponent(obj.username) + '&pass=' + encodeURIComponent(obj.password) + urlExtras + " HTTP/1.1\r\nHost: " + obj.host + "\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nSec-WebSocket-Version: 13\r\n\r\n", "binary"));
+ }
+
+ // Called when socket data is received from the server
+ function _OnSocketData(e) {
+ obj.accumulator += e;
+ if (obj.socketState == 1) {
+ // Look for the HTTP header response
+ var i = obj.accumulator.indexOf('\r\n\r\n');
+ if (i >= 0) {
+ var header = parseHttpHeader(obj.accumulator.substring(0, i));
+ if ((header != null) && (header._Path == '101')) {
+ // Success
+ obj.accumulator = obj.accumulator.substring(i + 4);
+ obj.socketState = 2;
+ if (obj.onStateChange != null) { obj.onStateChange(obj, obj.socketState); }
+ //console.log('websocket connected');
+ } else {
+ // Fail
+ _OnSocketClosed();
+ }
+ }
+ }
+ if (obj.socketState >= 2) {
+ // Parse WebSocket data
+ //console.log('ACC(' + obj.accumulator.length + '):' + obj.accumulator);
+ while (_parseWsData() != 0) { }
+ }
+ };
+
+ // Parses websocket data from a socket connection, returns the number of bytes consumed.
+ function _parseWsData() {
+ if (obj.acclen == -1) {
+ // Look for a websocket header
+ if (obj.accumulator.length < 2) return 0;
+ var headsize = 2;
+ obj.accopcodes = obj.accumulator.charCodeAt(0);
+ obj.accmask = ((obj.accumulator.charCodeAt(1) & 0x80) != 0)
+ obj.acclen = (obj.accumulator.charCodeAt(1) & 0x7F);
+ if (obj.acclen == 126) {
+ if (obj.accumulator.length < 4) return 0;
+ headsize = 4;
+ obj.acclen = ReadShort(obj.accumulator, 2);
+ }
+ else if (obj.acclen == 127) {
+ if (obj.accumulator.length < 10) return 0;
+ headsize = 10;
+ obj.acclen = ReadInt(obj.accumulator, 6);
+ }
+ if (obj.accmask == true) {
+ // TODO: Do unmasking here.
+ headsize += 4;
+ }
+ //console.log('FIN: ' + ((obj.accopcodes & 0x80) != 0) + ', OP: ' + (obj.accopcodes & 0x0F) + ', LEN: ' + obj.acclen + ', MASK: ' + obj.accmask);
+ obj.accumulator = obj.accumulator.substring(headsize);
+ return headsize;
+ } else {
+ // Read the data
+ if (obj.accumulator.length < obj.acclen) return 0;
+ _OnWebSocketMessage(((obj.accopcodes & 0x80) != 0), (obj.accopcodes & 0x0F), obj.accumulator.substring(0, obj.acclen));
+ obj.accumulator = obj.accumulator.substring(obj.acclen);
+ var out = obj.acclen;
+ obj.acclen = -1;
+ return out;
+ }
+ }
+
+ // Called when the a command is received from the server
+ function _OnWebSocketMessage(fin, op, data) {
+ //console.log('FIN: ' + fin + ', OP: ' + op + ', LEN: ' + data.length, ': ' + data);
+ if (op == 8) { _OnSocketClosed('RemoteDisconnect'); return; } // Close the connection
+ if (op != 1) { return; } // We only process text frames
+
+ // Parse the incoming JSON command
+ var message = null;
+ try { message = JSON.parse(data); } catch (ex) { return; }
+ if (message == null) return;
+
+ // Process the command
+ switch (message.action) {
+ case 'close': {
+ _OnSocketClosed(message.cause, message.msg);
+ break;
+ }
+ case 'serverinfo': {
+ // We got server information, confirm good login.
+ obj.socketState = 3;
+ if (obj.onStateChange != null) { obj.onStateChange(obj, obj.socketState); }
+ _Send({ 'action': 'meshes' });
+ break;
+ }
+ case 'userinfo': {
+ obj.userinfo = message.userinfo;
+ break;
+ }
+ case 'meshes': {
+ for (var m in message.meshes) { obj.meshes[message.meshes[m]._id] = message.meshes[m]; }
+ _Send({ 'action': 'nodes' });
+ break;
+ }
+ case 'nodes': {
+ obj.computerlist.splice(0, obj.computerlist.length); // Clear list
+ for (var m in message.nodes) {
+ if (!obj.meshes[m]) { console.log('Invalid mesh (1): ' + m); continue; }
+ for (var n in message.nodes[m]) {
+ // Build the ComputerList
+ var no = message.nodes[m][n];
+ if (no.intelamt) {
+ //console.log(no.intelamt);
+ var pmode = 0;
+ if ((no.intelamt.flags & 4) != 0) { pmode = 1; } // ACM
+ if ((no.intelamt.flags & 2) != 0) { pmode = 2; } // CCM
+ var computer = { checked: false, h: Math.random(), host: no.host, icon: no.icon, name: no.name, pmode: pmode, pstate: no.intelamt.state, tags: obj.meshes[m].name, ver: no.intelamt.ver, tls: no.intelamt.tls, conn: no.conn, _id: message.nodes[m][n]._id };
+ obj.computerlist.push(computer);
+ }
+ }
+ }
+ // Event node change
+ if (obj.onNodeChange != null) { obj.onNodeChange(this); }
+ break;
+ }
+ case 'event': {
+ switch (message.event.action) {
+ case 'changenode': {
+ for (var i in obj.computerlist) {
+ if (obj.computerlist[i]._id == message.event.nodeid) {
+ var no = message.event.node;
+ var computer = obj.computerlist[i];
+ computer.host = no.host;
+ computer.icon = no.icon;
+ computer.name = no.name;
+ computer.pstate = no.intelamt.state;
+ computer.pmode = 1; // 1 = ACM, 2 = CCM
+ if (obj.meshes[no.meshid]) { computer.tags = obj.meshes[no.meshid].name; }
+ computer.ver = no.intelamt.ver;
+ computer.tls = no.intelamt.tls;
+ if (obj.onNodeChange != null) { obj.onNodeChange(this, computer); }
+ }
+ }
+ break;
+ }
+ case 'nodeconnect': {
+ for (var i in obj.computerlist) {
+ if (obj.computerlist[i]._id == message.event.nodeid) {
+ var computer = obj.computerlist[i];
+ computer.conn = message.event.conn;
+ if (obj.onNodeChange != null) { obj.onNodeChange(this, computer); }
+ }
+ }
+ break;
+ }
+ }
+ break;
+ }
+ }
+ }
+
+ // Called when the socket is closed
+ function _OnSocketClosed(cause, msg) {
+ if (obj.socketState == 0) return;
+ obj.socketState = 0;
+ if (obj.onStateChange != null) { obj.onStateChange(obj, obj.socketState, cause, msg); }
+ if (obj.socket != null) { try { obj.socket.end(); } catch (ex) { } obj.socket = null; }
+ obj.meshes = {};
+ obj.userinfo = null;
+ obj.computerlist = [];
+ //console.log('closed');
+ }
+
+ // Called to send websocket data to the server
+ function _Send(object) {
+ if (obj.socketState < 2) { return; }
+ var data = new Buffer(JSON.stringify(object), "binary");
+ var header = String.fromCharCode(129); // 129 is default full fragment op code
+ if (data.length < 126) { header += String.fromCharCode(data.length); }
+ else if (data.length < 65536) { header += String.fromCharCode(126) + ShortToStr(data.length); }
+ else { header += String.fromCharCode(127) + ShortToInt(0) + ShortToInt(data.length); }
+ try { obj.socket.write(new Buffer(header + data, 'binary')); } catch (e) { }
+ }
+
+ // Parse the data and return the decoded HTTP header if present.
+ function parseHttpHeader(data) {
+ var lines = data.split('\r\n');
+ if (lines.length < 1) return null;
+ var values = {}, directive = lines[0].split(' ');
+ if (directive.length < 3) return null;
+ values['_Action'] = directive[0];
+ values['_Path'] = directive[1];
+ values['_Protocol'] = directive[2];
+ for (i in lines) { if (i == 0) continue; var j = lines[i].indexOf(':'); if (j > 0) { values[lines[i].substring(0, j).trim()] = lines[i].substring(j + 1).trim(); } }
+ if (values['Content-Length']) { values['Content-Length'] = parseInt(values['Content-Length']); }
+ return values;
+ }
+
+ return obj;
+}
+
diff --git a/output/Firmware-Large.gz b/output/Firmware-Large.gz
new file mode 100644
index 0000000..7a70c0b
Binary files /dev/null and b/output/Firmware-Large.gz differ
diff --git a/output/Firmware-Medium.gz b/output/Firmware-Medium.gz
new file mode 100644
index 0000000..df0d446
Binary files /dev/null and b/output/Firmware-Medium.gz differ
diff --git a/output/Firmware-Small.gz b/output/Firmware-Small.gz
new file mode 100644
index 0000000..87cbfa7
Binary files /dev/null and b/output/Firmware-Small.gz differ
diff --git a/output/index.htm b/output/index.htm
new file mode 100644
index 0000000..6a7d049
--- /dev/null
+++ b/output/index.htm
@@ -0,0 +1,50840 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
MeshCommander
+
+
+
+
+ Loading...
+
+
+
+
+
+
+
+
No known computers
+
Get started by
adding computers or drag & dropping
a computer list file in this window.
+
+
+
+
+
+
+
+
+
+
+
Intel® AMT USB Setup.bin Manager
+
Get started by
creating a new file,
opening an existing one
or drag & dropping a setup.bin file in this window.
+
+
+
+
+
+
+
+
+
Certificate Manager
+
Certificates play an important role in all sorts of Intel® AMT security tasks: TLS network authentication,
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Floppy, blocks are 512 bytes.
+
+
+
+
CDROM, blocks are 2048 bytes.
+
+
+
+
+
+
+
+
+
+
+
+
Loading...
+
+
+
System Status
+
+
+
Hardware Information
+
+
+
Event Log
+
+
+
Network Settings
+
+
+
User Accounts
+
+
+
+
Serial-over-LAN Terminal
+
+
+
Intel® AMT Redirection port or Serial-over-LAN feature is disabled, click here to enable it.
+
+
+
Remote computer is not powered on, click here to issue a power command.
+
+
+
+
+
+
+
Intel® AMT Redirection port or KVM feature is disabled, click here to enable it.
+
+
+
Remote computer is not powered on, click here to issue a power command.
+
+
+
+
+
Audit Log
+
+
+
Security Settings
+
+
+
Internet Settings
+
+
+
System Defense
+
+
+
Agent Presence
+
+
+
Script Editor
+
+
+
+
Script
+
+
+
Compiled Script
+
+
+
Variables
+
+
+
Console
+
+
+
+
Storage
+
+
+
Event Subscriptions
+
+
+
Wake Alarms
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Local Network Any Permission
+
Granted Permissions
+
+
+
+
+
+
+
+
+
+
+
+
+
Digest / None Digest / TLS Kerberos / None Kerberos / TLS Auth / Security
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Warning: Some power actions may result in data loss and may disconnect the desktop, terminal or disk redirection sessions.
+
+
+
+
+
+
Primary display Secondary display Third display Consent Display
+
+
+
+
+
+ RLE8, Color Fast
+ RLE16, Color
+ RLE4G, Gray Fastest
+ RLE8G, Gray Fast
+ RAW8, Color Slow
+ RAW16, Color Very Slow
+
+
Image Encoding
+
+
+
+
Software KVM
+
+
+ 50%
+ 40%
+ 30%
+ 20%
+ 10%
+ 5%
+ 1%
+
+
Quality
+
+
+
+ 100%
+ 87.5%
+ 75%
+ 62.5%
+ 50%
+ 37.5%
+ 25%
+ 12.5%
+
+
Scaling
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ WPA2 PSK
+
+ WPA PSK
+
+
+
+
Authentication
+
+
+
+ CCMP-AES
+ TKIP-RC4
+ WEP
+ None
+
+
Encryption
+
+
+
+
+
+
+
+
+
+ Version 1
+ Version 2
+ Version 3
+ Version 4
+
+
Setup.bin version
+
+
+
+ Records will not be consumed
+ Records will be consumed
+
+
Record consumption
+
+
+
+
+
+
+
+
+
+
+
Use encryption. The file will contain Intel® AMT credentials, saving using a password may help protect this data.
+
+
+
+
+
+
+
+
+ This will save the entire state of Intel® AMT for this machine into file. Passwords will not be saved, but some sensitive data may be included.
+
+
+
+
+
+
+
+ Disabled
+ Disabled, DHCP update
+ Enabled
+
+
Dynamic DNS client
+
+
+
+
+
+
+
+
+
+ Power up
+ Power cycle
+ Power down
+ Reset
+ OS Wake from Standby
+ OS Power Saving
+ Set boot options
+
+
Remote Command
+
+
+
+
+ None
+ Force CD/DVD Boot
+ Force PXE Boot
+ Force Hard Disk Boot
+ Force Diagnostic Boot
+
+
Boot Source
+
+
+
+ None
+ Index 1
+ Index 2
+ Index 3
+ Index 4
+
+
Boot Media Index
+
+
+
+ Boot to floppy
+ Boot to CDROM
+
+
IDER Boot Device
+
+
+
+ System Default
+ Quiet
+ Verbose
+ Blank Screen
+
+
Verbocity
+
+
+
WARNING: TLS is not used, password will be sent in the clear.
+
+
+
+
+
+
+
+
Wake date (year-month-day)
+
+
+
+
+
Wake time (hour:min:sec)
+
+
+
+
+
Interval (days-hours-min)
+
+
+
+
+ Keep alarm
+ Delete on completion
+
+
+
After wake
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..0025bab
--- /dev/null
+++ b/package.json
@@ -0,0 +1,18 @@
+{
+ "name": "MeshCommander",
+ "version": "0.4.4",
+ "description": "Intel(R) Active Management Technology console tool",
+ "main": "index-nw.html",
+ "author": "Intel Corporation",
+ "keywords": [ "Intel", "Intel AMT", "Active Management Technology", "Remote Management", "Hardware Management", "Manageability Commander" ],
+ "single-instance": false,
+ "window": {
+ "icon": "favicon.png",
+ "toolbar": false,
+ "frame": true,
+ "width": 970,
+ "min_width": 970,
+ "height": 760,
+ "min_height": 640
+ }
+}
\ No newline at end of file
diff --git a/readme.md b/readme.md
new file mode 100644
index 0000000..c0dde3a
--- /dev/null
+++ b/readme.md
@@ -0,0 +1,59 @@
+MeshCommander
+=============
+
+For more information, [visit MeshCommander.com/meshcommander](https://www.meshcommander.com/meshcommander).
+
+MeshCommander is a Intel(R) Active Management Technology (Intel(R) AMT) remote management tool. It's feature rich and includes a built-in remote desktop viewer for Hardware-KVM, a Serial-over-LAN terminal, IDER-Redirection support and much more. MeshCommander is built on web technologies and runs on many plaforms. In addition to being available as a stand-alone tool, MeshCommander was built to be very space efficient to that it can be uploaded into Intel AMT flash space to have it served diretly from the Intel AMT web serve. There are different ways to install and use MeshCommander.
+
+Windows Installation
+--------------------
+
+On Windows, simply go to [MeshCommander.com/meshcommander](https://www.meshcommander.com/meshcommander) and download and install the MSI installer.
+
+
+NPM Installation
+-----------------
+
+On Windows, Linux and MacOS, you can install MeshCommander from the Node Package Manager (NPM). Once you have NodeJS installed on your computer, you can do:
+
+```
+ mkdir meshcommander
+ cd meshcommander
+ npm install meshcommander
+ node meshcommander
+```
+
+This will start a small web server on port 3000 that you can access using a browser to use MeshCommander at http://127.0.0.1:3000.
+
+
+Firmware Installation
+---------------------
+
+For Intel AMT 11.6 and higher, you can load MeshCommander directly into Intel AMT storage flash space. Depending on the activation mode, MeshCommander can replace the default Intel AMT web page on HTTP/16992 or HTTPS/16993 making the built-in web site much more capable. On Windows, you can download the [firmware installer here](https://www.meshcommander.com/meshcommander/firmware). On other platforms, you can use [MeshCMD](https://www.meshcommander.com/meshcommander/meshcmd) to load MeshCommander into Intel AMT.
+
+
+MeshCMD Installation
+--------------------
+
+On Windows and Linux, you can download [MeshCMD](https://www.meshcommander.com/meshcommander/meshcmd), a command line tool for performing many Intel AMT management operations. Included in that tool is MeshCommander. You can start it up by running:
+
+```
+ meshcmd meshcommander
+```
+
+Like the NPM version, this will start an HTTP web server on port 3000. You can then access http://127.0.0.1:3000 from any browser to access MeshCommander.
+
+
+Tutorials
+---------
+
+There are plenty of [tutorial videos here](https://www.meshcommander.com/meshcommander/tutorials).
+
+Introduction to MeshCommander.
+[](https://www.youtube.com/watch?v=k7xVkZSVY0E)
+
+
+License
+-------
+
+This software is licensed under [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0).
diff --git a/scriptblocks.txt b/scriptblocks.txt
new file mode 100644
index 0000000..6b26f04
--- /dev/null
+++ b/scriptblocks.txt
@@ -0,0 +1,947 @@
+{
+ "blocks": {
+ "_start": {
+ "name": "Start",
+ "desc": "Starting Block",
+ "code": "print \"Script Started\""
+ },
+ "_end": {
+ "name": "End",
+ "desc": "Ending Block",
+ "code": ":end\r\njump :SkipPullSystemStatus PullSystemStatus \"!=\" 1\r\nPullSystemStatus\r\n:SkipPullSystemStatus\r\njump :SkipPullEventLog PullEventLog \"!=\" 1\r\nPullEventLog\r\n:SkipPullEventLog\r\njump :SkipPullAuditLog PullAuditLog \"!=\" 1\r\nPullAuditLog\r\n:SkipPullAuditLog\r\njump :SkipPullCertificates PullCertificates \"!=\" 1\r\nPullCertificates\r\n:SkipPullCertificates\r\njump :SkipPullWatchdog PullWatchdog \"!=\" 1\r\nPullWatchdog\r\n:SkipPullWatchdog\r\njump :SkipPullSystemDefense PullSystemDefense \"!=\" 1\r\nPullSystemDefense\r\n:SkipPullSystemDefense\r\njump :SkipPullHardware PullHardware \"!=\" 1\r\nPullHardware\r\n:SkipPullHardware\r\njump :SkipPullUserInfo PullUserInfo \"!=\" 1\r\nPullUserInfo\r\n:SkipPullUserInfo\r\njump :SkipPullRemoteAccess PullRemoteAccess \"!=\" 1\r\nPullRemoteAccess\r\n:SkipPullRemoteAccess\r\njump :SkipPullEventSubscriptions PullEventSubscriptions \"!=\" 1\r\npulleventsubscriptions\r\n:SkipPullEventSubscriptions\r\nprint \"Script Completed\""
+ },
+ "AMT-Accounts-AddDigestUser": {
+ "name": "Accounts - Add Digest User",
+ "desc": "Add a new digest user account to Intel AMT",
+ "code": "# Get the DigestRealm\r\njump :SkipDigestRealm-%%%~%%% DigestRealm \"!=\"\r\nprint \"Fetching digest realm...\"\r\nsplit ws_general_query \"*AMT_GeneralSettings\" ,\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset DigestRealm wsman_answer.AMT_GeneralSettings.response.DigestRealm\r\n:SkipDigestRealm-%%%~%%%\r\n\r\n# Create account\r\nset AccountName \"%%%name%%%\"\r\nset AccountPass \"%%%password%%%\"\r\nset digest \"{AccountName}:{DigestRealm}:{AccountPass}\"\r\nmd5 digestmd5 digest\r\nbtoa digestmd5 digestmd5\r\njsonparse wsargs \"%7B %22DigestUsername%22:%22{AccountName}%22, %22DigestPassword%22:%22{digestmd5}%22, %22AccessPermission%22:%%%accessPermission%%%, %22Realms%22:[%%%realms%%%] %7D\"\r\nwsexec \"AMT_AuthorizationService\" \"AddUserAclEntryEx\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nprint \"Account {AccountName} create: {AMT_AuthorizationService.Body.ReturnValueStr}\"\r\n\r\nset PullUserInfo 1\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%",
+ "vars": {
+ "name": {
+ "name": "Name",
+ "desc": "Name of the user account to create",
+ "type": 1,
+ "maxlength": 30,
+ "value": ""
+ },
+ "password": {
+ "name": "Password",
+ "desc": "Password of the user account to create",
+ "type": 4,
+ "maxlength": 30,
+ "value": ""
+ },
+ "accessPermission": {
+ "name": "Access Permission",
+ "desc": "Set account to be local, remote or both",
+ "type": 3,
+ "values": {
+ "0": "Local only",
+ "1": "Network only",
+ "2": "All (Local & Network)"
+ },
+ "value": "2"
+ },
+ "realms": {
+ "name": "Realms",
+ "desc": "Set account permissions",
+ "type": 5,
+ "values": {
+ "2": "Redirection",
+ "3": "PT Administration",
+ "4": "Hardware Asset",
+ "5": "Remote Control",
+ "6": "Storage",
+ "7": "Event Manager",
+ "8": "Storage Admin",
+ "9": "Agent Presence Local",
+ "10": "Agent Presence Remote",
+ "11": "Circuit Breaker",
+ "12": "Network Time",
+ "13": "General Information",
+ "14": "Firmware Update",
+ "15": "EIT",
+ "16": "LocalUN",
+ "17": "Endpoint Access Control",
+ "18": "Endpoint Access Control Admin",
+ "19": "Event Log Reader",
+ "20": "Audit Log",
+ "21": "ACL Realm",
+ "24": "Local System"
+ },
+ "value": [ "3" ]
+ }
+ }
+ },
+ "AMT-Accounts-RemoveDigestUser": {
+ "name": "Accounts - Remove Digest User",
+ "desc": "Remove a digest user account from Intel AMT",
+ "code": "set ToggleAccount \"%%%name%%%\"\r\n\r\n# Fetch all of the account handles\r\nprint \"Fetching account handles...\"\r\njsonparse wsargs \"%7B %22StartIndex%22:1 %7D\"\r\nwsexec \"AMT_AuthorizationService\" \"EnumerateUserAclEntries\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset AccountHandles AMT_AuthorizationService.Body.Handles\r\nset wsargs\r\nset AMT_AuthorizationService\r\nset wsman_result\r\nset wsman_result_str\r\nlength AccountHandlesCount AccountHandles\r\n\r\n# Get all of the account information\r\nprint \"Fetching all account information...\"\r\nset i 0\r\n:fetchAccountLoop-%%%~%%%\r\nset fetchHandle AccountHandles.{i}\r\njsonparse wsargs \"%7B %22Handle%22:{fetchHandle} %7D\"\r\nwsexec \"AMT_AuthorizationService\" \"GetAclEnabledState\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset AccountEnabled{i} AMT_AuthorizationService.Body.Enabled\r\nwsexec \"AMT_AuthorizationService\" \"GetUserAclEntryEx\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset AccountName{i} AMT_AuthorizationService.Body.DigestUsername\r\nset AccountAccess{i} AMT_AuthorizationService.Body.AccessPermission\r\nset AccountRealms{i} AMT_AuthorizationService.Body.Realms\r\nadd i i 1\r\njump :fetchAccountLoop-%%%~%%% i \"<\" AccountHandlesCount\r\nset AMT_AuthorizationService\r\nset fetchHandle\r\nset wsargs\r\n\r\n# Search for a matching account\r\nprint \"Searching accounts...\"\r\nset i 0\r\n:searchAccountLoop-%%%~%%%\r\nset searchHandle AccountHandles.{i}\r\njump :foundAccount AccountName{i} \"=\" ToggleAccount\r\nadd i i 1\r\njump :searchAccountLoop-%%%~%%% i \"<\" AccountHandlesCount\r\njump :end-%%%~%%%\r\n\r\n# Account found, delete it\r\n:foundAccount\r\nprint \"Account {ToggleAccount} found at index {i}, deleting it...\"\r\nset deleteHandle AccountHandles.{i}\r\njsonparse wsargs \"%7B %22Handle%22:{deleteHandle} %7D\"\r\nwsexec \"AMT_AuthorizationService\" \"RemoveUserAclEntry\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nprint \"Done, account {ToggleAccount} deleted.\"\r\nset PullUserInfo 1\r\njump :end-%%%~%%%\r\n\r\n# End of script\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%",
+ "vars": {
+ "name": {
+ "name": "Name",
+ "desc": "Name of the user account to remove",
+ "type": 1,
+ "maxlength": 30,
+ "value": ""
+ }
+ }
+ },
+ "AMT-Accounts-AddKerberosUser": {
+ "name": "Accounts - Add Kerberos User",
+ "desc": "Add a new kerberos user account to Intel AMT",
+ "code": "# Set kerberos sid value as a byte array string\r\nset KerberosUserString \"%%%sid%%%\"\r\nGetSidByteArray x KerberosUserString\r\nbtoa KerberosUserSid x\r\njsonparse wsargs \"%7B%22KerberosUserSid%22:%22{KerberosUserSid}%22,%22AccessPermission%22:%%%accessPermission%%%,%22Realms%22:[%%%realms%%%]%7D\"\r\nwsexec \"AMT_AuthorizationService\" \"AddUserAclEntryEx\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nprint \"Account {KerberosUserString} return value: {AMT_AuthorizationService.Body.ReturnValueStr}\"\r\n\r\nset PullUserInfo 1\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%",
+ "vars": {
+ "sid": {
+ "name": "Sid",
+ "desc": "The Security ID (SID) of the user account to create",
+ "type": 1,
+ "maxlength": 45,
+ "value": ""
+ },
+ "accessPermission": {
+ "name": "Access Permission",
+ "desc": "Set account to be local, remote or both",
+ "type": 3,
+ "values": {
+ "0": "Local only",
+ "1": "Network only",
+ "2": "All (Local & Network)"
+ },
+ "value": "2"
+ },
+ "realms": {
+ "name": "Realms",
+ "desc": "Set account permissions",
+ "type": 5,
+ "values": {
+ "2": "Redirection",
+ "3": "PT Administration",
+ "4": "Hardware Asset",
+ "5": "Remote Control",
+ "6": "Storage",
+ "7": "Event Manager",
+ "8": "Storage Admin",
+ "9": "Agent Presence Local",
+ "10": "Agent Presence Remote",
+ "11": "Circuit Breaker",
+ "12": "Network Time",
+ "13": "General Information",
+ "14": "Firmware Update",
+ "15": "EIT",
+ "16": "LocalUN",
+ "17": "Endpoint Access Control",
+ "18": "Endpoint Access Control Admin",
+ "19": "Event Log Reader",
+ "20": "Audit Log",
+ "21": "ACL Realm",
+ "24": "Local System"
+ },
+ "value": [ "3" ]
+ }
+ }
+ },
+ "AMT-Accounts-RemoveKerberosUser": {
+ "name": "Accounts - Remove Kerberos User",
+ "desc": "Remove a digest user account from Intel AMT",
+ "code": "GetSidByteArray ToggleAccount \"%%%sid%%%\"\r\nbtoa ToggleAccount ToggleAccount\r\n# Fetch all of the account handles\r\nprint \"Fetching account handles...\"\r\njsonparse wsargs \"%7B %22StartIndex%22:1 %7D\"\r\nwsexec \"AMT_AuthorizationService\" \"EnumerateUserAclEntries\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset AccountHandles AMT_AuthorizationService.Body.Handles\r\nset wsargs\r\nset AMT_AuthorizationService\r\nset wsman_result\r\nset wsman_result_str\r\nlength AccountHandlesCount AccountHandles\r\n\r\n# Get all of the account information\r\nprint \"Fetching all account information...\"\r\nset i 0\r\n:fetchAccountLoop-%%%~%%%\r\nset fetchHandle AccountHandles.{i}\r\njsonparse wsargs \"%7B %22Handle%22:{fetchHandle} %7D\"\r\nwsexec \"AMT_AuthorizationService\" \"GetAclEnabledState\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset AccountEnabled{i} AMT_AuthorizationService.Body.Enabled\r\nwsexec \"AMT_AuthorizationService\" \"GetUserAclEntryEx\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset AccountName{i} AMT_AuthorizationService.Body.KerberosUserSid\r\nset AccountAccess{i} AMT_AuthorizationService.Body.AccessPermission\r\nset AccountRealms{i} AMT_AuthorizationService.Body.Realms\r\nadd i i 1\r\njump :fetchAccountLoop-%%%~%%% i \"<\" AccountHandlesCount\r\nset AMT_AuthorizationService\r\nset fetchHandle\r\nset wsargs\r\n\r\n# Search for a matching account\r\nprint \"Searching accounts...\"\r\nset i 0\r\n:searchAccountLoop-%%%~%%%\r\nset searchHandle AccountHandles.{i}\r\njump :foundAccount AccountName{i} \"=\" ToggleAccount\r\nadd i i 1\r\njump :searchAccountLoop-%%%~%%% i \"<\" AccountHandlesCount\r\njump :end-%%%~%%%\r\n\r\n# Account found, delete it\r\n:foundAccount\r\nprint \"Account %%%sid%%% found at index {i}, deleting it...\"\r\nset deleteHandle AccountHandles.{i}\r\njsonparse wsargs \"%7B %22Handle%22:{deleteHandle} %7D\"\r\nwsexec \"AMT_AuthorizationService\" \"RemoveUserAclEntry\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nprint \"Done, account %%%sid%%% deleted.\"\r\nset PullUserInfo 1\r\njump :end-%%%~%%%\r\n\r\n# End of script\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%",
+ "vars": {
+ "sid": {
+ "name": "Sid",
+ "desc": "Sid of the user account to remove",
+ "type": 1,
+ "maxlength": 45,
+ "value": ""
+ }
+ }
+ },
+ "AMT-Accounts-PrintAll": {
+ "name": "Accounts - Print Users",
+ "desc": "Display all digest user accounts from Intel AMT",
+ "code": "# Fetch all of the account handles\r\nprint \"Fetching account handles...\"\r\njsonparse wsargs \"%7B %22StartIndex%22:1 %7D\"\r\nwsexec \"AMT_AuthorizationService\" \"EnumerateUserAclEntries\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset AccountHandles AMT_AuthorizationService.Body.Handles\r\nset wsargs\r\nset AMT_AuthorizationService\r\nset wsman_result\r\nset wsman_result_str\r\nlength AccountHandlesCount AccountHandles\r\n\r\n# Get all of the account information\r\nprint \"Fetching all account information...\"\r\nset i 0\r\n:fetchAccountLoop-%%%~%%%\r\nset fetchHandle AccountHandles.{i}\r\njsonparse wsargs \"%7B %22Handle%22:{fetchHandle} %7D\"\r\nwsexec \"AMT_AuthorizationService\" \"GetAclEnabledState\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset AccountEnabled{i} AMT_AuthorizationService.Body.Enabled\r\nwsexec \"AMT_AuthorizationService\" \"GetUserAclEntryEx\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nprint \"AMT-ACCOUNT: {AMT_AuthorizationService.Body.DigestUsername}, {AMT_AuthorizationService.Body.AccessPermission}, [{AMT_AuthorizationService.Body.Realms}]\"\r\nadd i i 1\r\njump :fetchAccountLoop-%%%~%%% i \"<\" AccountHandlesCount\r\nset AMT_AuthorizationService\r\nset fetchHandle\r\nset wsargs\r\n\r\n# End of script\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%"
+ },
+ "Basic-Add": {
+ "name": "Basic - Add",
+ "desc": "Add a value to a given variable",
+ "code": "add %%%var%%% %%%var%%% %%%value%%%",
+ "vars": {
+ "var": {
+ "name": "Name",
+ "desc": "Name of the variable to add to",
+ "type": 1,
+ "maxlength": 20,
+ "value": "SampleVariable"
+ },
+ "value": {
+ "name": "Value",
+ "desc": "Value to add to the variable",
+ "type": 1,
+ "value": "1"
+ }
+ }
+ },
+ "Basic-Disconnect": {
+ "name": "Basic - Disconnect",
+ "desc": "Disconnect from Intel AMT",
+ "code": "Disconnect"
+ },
+ "Basic-JumpLabel": {
+ "name": "Basic - Jump Target",
+ "desc": "Set a jump label. Other blocks can jump here.",
+ "code": ":%%%label%%%",
+ "vars": {
+ "label": {
+ "name": "Label",
+ "desc": "Name of the jump target label",
+ "type": 1,
+ "maxlength": 50,
+ "value": "SampleLabel"
+ }
+ }
+ },
+ "Basic-Jump": {
+ "name": "Basic - Jump",
+ "desc": "Jump to a given label",
+ "code": "jump :%%%label%%%",
+ "vars": {
+ "label": {
+ "name": "Label",
+ "desc": "Name of the jump target label",
+ "type": 1,
+ "maxlength": 50,
+ "value": "SampleLabel"
+ }
+ }
+ },
+ "Basic-JumpIf": {
+ "name": "Basic - Jump if",
+ "desc": "Jump to a given label if the condition is met",
+ "code": "jump :%%%label%%% %%%arg1%%% \"%%%comparator%%%\" %%%arg2%%%",
+ "vars": {
+ "label": {
+ "name": "Label",
+ "desc": "Name of the jump target label",
+ "type": 1,
+ "maxlength": 50,
+ "value": "SampleLabel"
+ },
+ "arg1": {
+ "name": "arg1",
+ "desc": "First variable to compare, use \"x\" for a string",
+ "type": 1,
+ "value": ""
+ },
+ "comparator": {
+ "name": "Comparator",
+ "desc": "How to compare both arguments",
+ "type": 3,
+ "values": {
+ "=": "=",
+ "!=": "!=",
+ "<": "<",
+ ">": ">",
+ "<=": "<=",
+ ">=": ">="
+ },
+ "value": "="
+ },
+ "arg2": {
+ "name": "arg2",
+ "desc": "Second variable to compare, use \"x\" for a string",
+ "type": 1,
+ "value": ""
+ }
+ }
+ },
+ "Basic-Print": {
+ "name": "Basic - Print",
+ "desc": "Print a string to the console",
+ "code": "print \"%%%printstring%%%\"",
+ "vars": {
+ "printstring": {
+ "name": "Value",
+ "desc": "String that will be printed to console, use urlescaping for special chars and use {x} to print variable x.",
+ "type": 1,
+ "value": "Sample String"
+ }
+ }
+ },
+ "Basic-ScriptSpeed": {
+ "name": "Basic - Script Speed",
+ "desc": "Set the speed of the script",
+ "code": "scriptspeed %%%delay%%%",
+ "vars": {
+ "delay": {
+ "name": "Delay",
+ "desc": "The delay in millisecond between execution of each script step. 200ms is 5 steps per second.",
+ "type": 2,
+ "maxlength": 4,
+ "value": 200
+ }
+ }
+ },
+ "Basic-Set": {
+ "name": "Basic - Set",
+ "desc": "Set a variable to a given value",
+ "code": "set %%%var%%% %%%value%%%",
+ "vars": {
+ "var": {
+ "name": "Name",
+ "desc": "Name of the variable to set",
+ "type": 1,
+ "maxlength": 20,
+ "value": "SampleVariable"
+ },
+ "value": {
+ "name": "Value",
+ "desc": "The new value to set to the variable",
+ "type": 1,
+ "value": "0"
+ }
+ }
+ },
+ "AMT-Event-RemoveAllSubscription": {
+ "name": "Event - Remove All Subscriptions",
+ "desc": "Remove all subscriptions.",
+ "vars": { },
+ "code": "# Fetch all of subscriptions handles\nprint \"Deleting all event subscriptions...\"\nsplit ws_query \"CIM_ListenerDestination,CIM_FilterCollectionSubscription\" \",\"\nwsbatchenum \"wsman_answer\" ws_query\njump :error-%%%~%%% wsman_result \"!=\" 200\nlength i wsman_answer.CIM_ListenerDestination.responses\n:loop-%%%~%%%\njump :end-%%%~%%% i \"<=\" 0\nsubstract i i 1\nprint \"Delete {i}\"\nset name wsman_answer.CIM_ListenerDestination.responses.{i}.Name\nset filter wsman_answer.CIM_FilterCollectionSubscription.responses.{i}.Filter.ReferenceParameters.SelectorSet.Selector.Value\njsonparse r \"%7B%22Filter%22:%22
http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_FilterCollection {filter} %22, %22Handler%22:%22
http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ListenerDestinationWSManagement CIM_ListenerDestinationWSMAN {name} CIM_ComputerSystem Intel(r) AMT %22%7D\"\nwsunsubscribe \"CIM_FilterCollectionSubscription\" r\nprint \"Result: {wsman_result}\"\njump :loop-%%%~%%% i \"!=\" 0\n# End of script\njump :end-%%%~%%%\n:error-%%%~%%%\nprint \"Call failed: {wsman_result_str}\"\n:end-%%%~%%%\nset i\nset r\nset name\nset filter\nset ws_query\nset wsman_answer\nset PullEventSubscriptions 1\n##!BLOCK!##"
+ },
+ "AMT-Event-AddSubscription": {
+ "name": "Event - Add Subscription",
+ "desc": "Add a subscription event to Intel AMT.",
+ "vars": {
+ "SubscriptionType": {
+ "name": "Type",
+ "desc": "Type of subscription",
+ "type": "3",
+ "value": "Push",
+ "values": {
+ "Push": "Push",
+ "PushWithAck": "Push with ACK"
+ }
+ },
+ "SubscriptionFilter": {
+ "name": "Filter",
+ "desc": "Event filter, only the selected event types will be sent.",
+ "type": "3",
+ "value": "1",
+ "values": {
+ "0": "ME Presence Events",
+ "1": "User Notification",
+ "2": "All Events",
+ "3": "Platform Events",
+ "4": "Core Platform Events",
+ "5": "Features",
+ "6": "System Firmware Progress Events"
+ }
+ },
+ "SubscriptionUrl": {
+ "name": "URL",
+ "desc": "URL used to send events to.",
+ "type": "1",
+ "maxlength": "255",
+ "value": "http://"
+ },
+ "SubscriptionArgs": {
+ "name": "Arguments",
+ "desc": "Extra arguments sent when sending the event.",
+ "type": "1",
+ "maxlength": "255",
+ "value": ""
+ }
+ },
+ "code": "print \"Adding subscription: %%%SubscriptionUrl%%%\"\nsplit filters \"Intel(r) AMT:ME Presence,Intel(r) AMT:User,Intel(r) AMT:All,Intel(r) AMT:Platform,Intel(r) AMT:CorePlatform,Intel(r) AMT:Features,Intel(r) AMT:FW ProgressEvents\" \",\"\nset filter filters.%%%SubscriptionFilter%%%\njsonparse subfilter \"%7B%22InstanceID%22:%22{filter}%22%7D\"\nwssubscribe \"CIM_FilterCollection\" \"%%%SubscriptionType%%%\" \"%%%SubscriptionUrl%%%\" subfilter \"%%%SubscriptionArgs%%%\"\n\n# End of script\njump :end-%%%~%%%\n:error-%%%~%%%\nprint \"Call failed: {wsman_result_str}\"\n:end-%%%~%%%\nset filters\nset filter\nset subfilter\nset PullEventSubscriptions 1\n"
+ },
+ "AMT-General-SetUserConsent": {
+ "name": "General - Set User Consent",
+ "desc": "Set the Intel AMT user consent mode",
+ "code": "split ws_optIn_query \"*IPS_OptInService\" ,\r\nwsbatchenum \"wsman_answer\" ws_optIn_query\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset wsman_answer.IPS_OptInService.response.OptInRequired %%%consentMode%%%\r\nwsput \"IPS_OptInService\" wsman_answer.IPS_OptInService.response\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset PullSystemStatus 1\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\n",
+ "vars": {
+ "consentMode": {
+ "name": "Consent Mode",
+ "desc": "Intel AMT user consent mode",
+ "type": 3,
+ "values": {
+ "0": "Not Required",
+ "1": "Required for KVM only",
+ "0xFFFFFFFF": "Always Required"
+ },
+ "value": "0"
+ }
+ }
+ },
+ "AMT-General-ActiveFeatures": {
+ "name": "General - Set Active Features",
+ "desc": "Set the Intel AMT active features",
+ "code": "split ws_optIn_query \"*AMT_RedirectionService\" ,\r\nwsbatchenum \"wsman_answer\" ws_optIn_query\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset wsman_answer.AMT_RedirectionService.response.ListenerEnabled \"%%%listenerEnabled%%%\"\r\nset wsman_answer.AMT_RedirectionService.response.EnabledState \"%%%enabledState%%%\"\r\njsonparse wsargs \"%7B %22RequestedState%22:%22%%%enabledState%%%%22 %7D\"\r\nwsexec \"AMT_RedirectionService\" \"RequestStateChange\" wsargs\r\nwsput \"AMT_RedirectionService\" wsman_answer.AMT_RedirectionService.response\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset PullSystemStatus \"1\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\n",
+ "vars": {
+ "listenerEnabled": {
+ "name": "Redirection Port",
+ "desc": "Enable or disable the Intel AMT redirection port (TCP:16993/16995)",
+ "type": 3,
+ "values": {
+ "true": "Enabled",
+ "false": "Disabled"
+ },
+ "value": "true"
+ },
+ "enabledState": {
+ "name": "SOL/IDER Feature",
+ "desc": "Enable or disable the Intel AMT Serial-over-LAN and IDER features",
+ "type": 3,
+ "values": {
+ "32768": "Disabled",
+ "32769": "IDER only",
+ "32770": "Serial-over-LAN only",
+ "32771": "IDER & SOL enabled"
+ },
+ "value": "32771"
+ }
+ }
+ },
+ "AMT-General-GetCoreVersion": {
+ "name": "General - Get Version",
+ "desc": "Retrieves the Intel AMT release version, prints it to the console and stores it in variable AmtCoreVersion",
+ "code": "split ws_general_query \"CIM_SoftwareIdentity\"\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\nset i 0\r\nset arr wsman_answer.CIM_SoftwareIdentity.responses\r\nlength arr_len arr\r\n:loop-%%%~%%%\r\nset curInstanceId arr.{i}.InstanceID\r\njump :AmtCoreVersionFound-%%%~%%% curInstanceId \"=\" \"AMT FW Core Version\"\r\nadd i i 1\r\njump :loop-%%%~%%% i \"<\" arr_len\r\nprint \"Error: Intel AMT version was not found\"\r\njump :end-%%%~%%%\r\n:AmtCoreVersionFound-%%%~%%%\r\nset AmtCoreVersion arr.{i}.VersionString\r\nprint \"Intel AMT version: {AmtCoreVersion}\"\r\n:end-%%%~%%%\r\nset arr\r\nset arr_len\r\nset curInstanceId\r\nset i\r\nset ws_general_query\r\nset wsman_answer\r\nset wsman_result"
+ },
+ "AMT-General-GetPlatformType": {
+ "name": "General - Get Platform Type",
+ "desc": "Retrieves the platfrom type of the target, prints it to the console and stores it in variable PlatformType",
+ "code": "jsonparse sysTypeHmap \"%7B%2232%22:%22Desktop%22,%2233%22:%22Notebook%22%7D\"\r\nsplit ws_general_query \"CIM_ComputerSystem\"\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\nset i -1\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\ngetitem i wsman_answer.CIM_ComputerSystem.responses \"ElementName\" \"Managed System\"\r\njump :amtCoreError-%%%~%%% i \"<\" 0\r\nset i wsman_answer.CIM_ComputerSystem.responses.{i}.Dedicated\r\nset PlatformType sysTypeHmap.{i}\r\nprint \"Platform Type: {PlatformType}\"\r\njump :end-%%%~%%%\r\n:amtCoreError-%%%~%%%\r\nprint \"Error: couldn't find CIM_ComputerSystem.ElementName = %22Managed System%22\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"WSMAN call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\nset i\r\nset ws_general_query\r\nset wsman_answer\r\nset wsman_result\r\nset wsman_result_str\r\nset sysTypeHmap"
+ },
+ "AMT-General-GetProvState": {
+ "name": "General - Get Provisisoning State",
+ "desc": "Retrieves the current Provisioning State of Intel AMT, prints it to the console and stores it in variable AmtProvState",
+ "code": "jsonparse provStateHmap \"%7B%220%22:%22Pre%22,%221%22:%22In%22,%222%22:%22Post%22%7D\"\r\nsplit ws_general_query \"*AMT_SetupAndConfigurationService\"\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset key wsman_answer.AMT_SetupAndConfigurationService.response.ProvisioningState\r\nset AmtProvState provStateHmap.{key}\r\nadd AmtProvState AmtProvState \"-Provisioning\"\r\nprint \"Intel AMT Provisioning State: {AmtProvState}\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"WSMAN call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\nset ws_general_query\r\nset wsman_answer\r\nset wsman_result\r\nset wsman_result_str\r\nset provStateHmap\r\nset key"
+ },
+ "AMT-General-GetProvMode": {
+ "name": "General - Get Provisisoning Mode",
+ "desc": "Retrieves the current Provisioning Mode of Intel AMT, prints it to the console and stores it in variable AmtProvMode",
+ "code": "jsonparse provModeHmap \"%7B%221%22:%22Admin%20Control%20Mode%20(ACM)%22,%222%22:%22Reserved1%22,%223%22:%22Client%20Control%20Mode%20(CCM)%22,%224%22:%22Reserved2%22%7D\"\r\nsplit ws_general_query \"*AMT_SetupAndConfigurationService\"\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset key wsman_answer.AMT_SetupAndConfigurationService.response.ProvisioningMode\r\nset AmtProvMode provModeHmap.{key}\r\nprint \"Intel AMT Provisioning Mode: {AmtProvMode}\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"WSMAN call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\nset ws_general_query\r\nset wsman_answer\r\nset wsman_result\r\nset wsman_result_str\r\nset provModeHmap\r\nset key"
+ },
+ "AMT-General-PrintUserConsent": {
+ "name": "General - Print User Consent",
+ "desc": "Display the Intel AMT user consent mode",
+ "code": "jsonparse OptInStateEnum \"%7B%220%22:%22Not Required%22,%221%22:%22Required for KVM only%22,%224294967295%22:%22Always Required%22%7D\"\r\nsplit ws_optIn_query \"*IPS_OptInService\" ,\r\nwsbatchenum \"wsman_answer\" ws_optIn_query\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nprint \"User Consent mode: {OptInStateEnum.{wsman_answer.IPS_OptInService.response.OptInRequired}}\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\n"
+ },
+ "AMT-General-SetHostname": {
+ "name": "General - Set Hostname",
+ "desc": "Set the Intel AMT KVM feature to enabled or disabled",
+ "code": "split ws_general_query \"*AMT_GeneralSettings\" ,\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset wsman_answer.AMT_GeneralSettings.response.HostName \"%%%hostname%%%\"\r\nset wsman_answer.AMT_GeneralSettings.response.DomainName \"%%%domainname%%%\"\r\nwsput \"AMT_GeneralSettings\" wsman_answer.AMT_GeneralSettings.response\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset PullSystemStatus \"1\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\n",
+ "vars": {
+ "hostname": {
+ "name": "Hostname",
+ "desc": "The hostname Intel AMT will use while in Sx state",
+ "type": 1,
+ "maxlength": 30,
+ "value": ""
+ },
+ "domainname": {
+ "name": "Domain",
+ "desc": "The domain name Intel AMT will use while in Sx state",
+ "type": 1,
+ "maxlength": 30,
+ "value": ""
+ }
+ }
+ },
+ "AMT-General-SetPingResponse": {
+ "name": "General - Set Ping Response",
+ "desc": "Set the Intel AMT response to ICMP and RMCP ping requests",
+ "code": "split ws_general_query \"*AMT_GeneralSettings\" ,\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\njump :error-2 wsman_result \"!=\" 200\r\nset wsman_answer.AMT_GeneralSettings.response.PingResponseEnabled \"%%%icmpPingResponse%%%\"\r\nset wsman_answer.AMT_GeneralSettings.response.RmcpPingResponseEnabled \"%%%rmcpPingResponse%%%\"\r\nwsput \"AMT_GeneralSettings\" wsman_answer.AMT_GeneralSettings.response\r\njump :error-2 wsman_result \"!=\" 200\r\nset PullSystemStatus \"1\"\r\njump :end-2\r\n:error-2\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-2\r\n",
+ "vars": {
+ "icmpPingResponse": {
+ "name": "ICMP Ping",
+ "desc": "Enable or disable the Intel AMT response to ICMP ping",
+ "type": 3,
+ "values": {
+ "true": "Enabled",
+ "false": "Disabled"
+ },
+ "value": "true"
+ },
+ "rmcpPingResponse": {
+ "name": "RMCP Ping",
+ "desc": "Enable or disable the Intel AMT response to RMCP ping",
+ "type": 3,
+ "values": {
+ "true": "Enabled",
+ "false": "Disabled"
+ },
+ "value": "true"
+ }
+ }
+ },
+ "AMT-General-GetAmtUuid": {
+ "name": "General - Get UUID",
+ "desc": "Retrieves the Intel AMT UUID, prints it to the console and stores it in variable AmtUuid",
+ "code": "split ws_general_query \"CIM_ComputerSystem\"\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\nset i -1\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\ngetitem i wsman_answer.CIM_ComputerSystem.responses \"ElementName\" \"Managed System\"\r\njump :amtCoreError-%%%~%%% i \"<\" 0\r\nset AmtUuid wsman_answer.CIM_ComputerSystem.responses.{i}.OtherIdentifyingInfo\r\nprint \"Intel AMT UUID: {AmtUuid}\"\r\njump :end-%%%~%%%\r\n:amtCoreError-%%%~%%%\r\nprint \"Error: couldn't find CIM_ComputerSystem.ElementName = %22Managed System%22\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"WSMAN call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\nset i\r\nset ws_general_query\r\nset wsman_answer\r\nset wsman_result"
+ },
+ "AMT-KVM-SetState": {
+ "name": "KVM - Set State",
+ "desc": "Set the Intel AMT KVM feature to enabled or disabled",
+ "code": "jsonparse wsargs \"%7B %22RequestedState%22:%22%%%kvmEnabled%%%%22 %7D\"\r\nwsexec \"CIM_KVMRedirectionSAP\" \"RequestStateChange\" wsargs\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset PullSystemStatus \"1\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\n",
+ "vars": {
+ "kvmEnabled": {
+ "name": "KVM State",
+ "desc": "Enable or disable the Intel AMT KVM feature",
+ "type": 3,
+ "values": {
+ "2": "Enabled",
+ "3": "Disabled"
+ },
+ "value": "2"
+ }
+ }
+ },
+ "AMT-KVM-SetSessionTimeout": {
+ "name": "KVM - Set Session Timeout",
+ "desc": "Set the Intel AMT KVM session timeout",
+ "vars": {
+ "kvmTimeout": {
+ "name": "KVM Timeout",
+ "desc": "Intel AMT KVM session timeout in minutes",
+ "type": "2",
+ "value": "4"
+ }
+ },
+ "code": "split ws_general_query \"*IPS_KVMRedirectionSettingData\" ,\nwsbatchenum \"wsman_answer\" ws_general_query\njump :error-%%%~%%% wsman_result \"!=\" 200\nset wsman_answer.IPS_KVMRedirectionSettingData.response.SessionTimeout \"%%%kvmTimeout%%%\"\nwsput \"IPS_KVMRedirectionSettingData\" wsman_answer.IPS_KVMRedirectionSettingData.response\njump :error-%%%~%%% wsman_result \"!=\" 200\nset PullSystemStatus \"1\"\njump :end-%%%~%%%\n:error-%%%~%%%\nprint \"Call failed: {wsman_result_str}\"\n:end-%%%~%%%\n\n"
+ },
+ "AMT-Network-DetectWiredNic": {
+ "name": "Network - Wired NIC",
+ "desc": "Detects if the platfrom has a wired Intel AMT network interface controller (NIC), logs to the console and stores the result in WiredAmtNic",
+ "code": "split ws_general_query \"CIM_EthernetPort\"\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\nset i -1\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\ngetitem i wsman_answer.CIM_EthernetPort.responses \"DeviceID\" \"Intel(r) AMT Ethernet Port 0\"\r\njump :amtCoreError-%%%~%%% i \"<\" 0\r\nset WiredAmtNic \"true\"\r\nprint \"Wired AMT NIC found: true\"\r\njump :end-%%%~%%%\r\n:amtCoreError-%%%~%%%\r\nprint \"Wired AMT NIC found: false\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"WSMAN call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\nset i\r\nset ws_general_query\r\nset wsman_answer\r\nset wsman_result"
+ },
+ "AMT-Network-DetectWifiNic": {
+ "name": "Network - Wireless NIC",
+ "desc": "Detects if the platfrom has a WiFi interface, logs to the console and stores the result in WiFiAmtNic",
+ "code": "split ws_general_query \"CIM_EthernetPort\"\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\nset i -1\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\ngetitem i wsman_answer.CIM_EthernetPort.responses \"DeviceID\" \"Intel(r) AMT Ethernet Port 1\"\r\njump :amtCoreError-%%%~%%% i \"<\" 0\r\nset WiFiAmtNic \"true\"\r\nprint \"WiFi AMT NIC found: true\"\r\njump :end-%%%~%%%\r\n:amtCoreError-%%%~%%%\r\nprint \"Wifi AMT NIC found: false\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"WSMAN call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\nset i\r\nset ws_general_query\r\nset wsman_answer\r\nset wsman_result"
+ },
+ "AMT-Network-GetAmtFqdn": {
+ "name": "Network - Get FQDN",
+ "desc": "Retrieves the FQDN of Intel AMT, prints it to the console and stores it in variable AmtFqdn",
+ "code": "split ws_general_query \"*AMT_GeneralSettings\"\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset AmtFqdn wsman_answer.AMT_GeneralSettings.response.HostName\r\nadd AmtFqdn AmtFqdn \".\"\r\nadd AmtFqdn AmtFqdn wsman_answer.AMT_GeneralSettings.response.DomainName\r\nprint \"Intel AMT FQDN: {AmtFqdn}\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"WSMAN call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\nset ws_general_query\r\nset wsman_answer\r\nset wsman_result"
+ },
+ "AMT-Network-AddEnvDetection": {
+ "name": "Network - Set Environment Detection",
+ "desc": "Configures the DNS information that will be used by Intel AMT to dynamically determine the network it is operating in",
+ "code": "# *** Validate user input ***\r\nprint \"Parsing block parameters\"\r\njump :EMPTY_DETECTIONSTR-%%%~%%% \"%%%DetectionStrings%%%\" \"=\" \"\"\r\nsplit arrDetectionStrings \"%%%DetectionStrings%%%\" \",\"\r\nsplit arrDetectionIPv6LocalPrefixes \"%%%DetectionIPv6LocalPrefixes%%%\" \",\"\r\nprint \"Setting Environment Detection\"\r\nsplit ws_general_query \"*AMT_EnvironmentDetectionSettingData\" \",\"\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\nset envDetectionInstance wsman_answer.AMT_EnvironmentDetectionSettingData.response\r\njump :DetectionStringsDefined-%%%~%%% envDetectionInstance.DetectionStrings \"!=\"\r\nset envDetectionInstance.DetectionStrings arrDetectionStrings\r\njump :SET_IPV6_PREFIX-%%%~%%%\r\n:DetectionStringsDefined-%%%~%%%\r\nadd arrDetectionStrings \",\" arrDetectionStrings\r\nadd envDetectionInstance.DetectionStrings envDetectionInstance.DetectionStrings arrDetectionStrings\r\nmaketoarray envDetectionInstance.DetectionStrings envDetectionInstance.DetectionStrings\r\nlength arrDetectionStringsLen envDetectionInstance.DetectionStrings\r\njump :INVALID_LEN_DetectionStrings-%%%~%%% arrDetectionStringsLen \">\" \"5\"\r\n:SET_IPV6_PREFIX-%%%~%%%\r\njump :IPv6StringsDefined-%%%~%%% envDetectionInstance.DetectionIPv6LocalPrefixes \"!=\"\r\njump :EMPTY_IPV6PRFX \"%%%DetectionIPv6LocalPrefixes%%%\" \"=\" \"\" \r\nset envDetectionInstance.DetectionIPv6LocalPrefixes arrDetectionIPv6LocalPrefixes\r\njump :CALL_WSPUT-%%%~%%%\r\n:IPv6StringsDefined-%%%~%%%\r\nadd arrDetectionIPv6LocalPrefixes \",\" arrDetectionIPv6LocalPrefixes\r\nadd envDetectionInstance.DetectionIPv6LocalPrefixes envDetectionInstance.DetectionIPv6LocalPrefixes arrDetectionIPv6LocalPrefixes\r\nmaketoarray envDetectionInstance.DetectionIPv6LocalPrefixes envDetectionInstance.DetectionIPv6LocalPrefixes\r\n:EMPTY_IPV6PRFX\r\nlength arrDetectionIPv6LocalPrefixesLen envDetectionInstance.DetectionIPv6LocalPrefixes\r\njump :INVALID_LEN_DetectionIPv6LocalPrefixes-%%%~%%% arrDetectionIPv6LocalPrefixesLen \">\" \"5\"\r\n:CALL_WSPUT-%%%~%%%\r\nwsput \"AMT_EnvironmentDetectionSettingData\" envDetectionInstance\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nprint \"Environment Detection set successfully\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"ERROR: WSMAN call failed: {wsman_result_str}\"\r\njump :end-%%%~%%%\r\n:INVALID_LEN_DetectionStrings-%%%~%%%\r\nprint \"ERROR: detection strings count must be at most 5\"\r\njump :end-%%%~%%%\r\n:INVALID_LEN_DetectionIPv6LocalPrefixes-%%%~%%%\r\nprint \"ERROR: IPv6 prefixes count must be at most 5\"\r\njump :end-%%%~%%%\r\n:EMPTY_DETECTIONSTR-%%%~%%%\r\nprint \"ERROR: %22Detection Strings%22 field cannot be empty, aborting operation...\"\r\n:end-%%%~%%%\r\n set PullRemoteAccess \"1\"\r\nset AMT_EnvironmentDetectionSettingData\r\nset arrDetectionIPv6LocalPrefixes\r\nset arrDetectionStrings\r\nset envDetectionInstance\r\nset ws_general_query\r\nset wsman_answer \r\nset wsman_result",
+ "vars": {
+ "DetectionStrings": {
+ "name": "Detection Strings",
+ "desc": "A comma separated list of up to 4 strings to use in the environment detection algorithm (e.g. intel.com,contoso.com)",
+ "type": 1,
+ "maxlength": 255,
+ "value": ""
+ },
+ "DetectionIPv6LocalPrefixes": {
+ "name": "IPv6 Local Prefixes",
+ "desc": "A comma separated list of IPv6 local prefixes (strings) to use independently of or in conjunction with Detection Strings. (e.g. 1234::/64,4321::/46)",
+ "type": 1,
+ "maxlength": 255,
+ "value": ""
+ }
+ }
+ },
+ "AMT-Network-ClearEnvDetection": {
+ "name": "Network - Clear Environment Detection",
+ "desc": "Clears the DNS information that is used by Intel AMT to dynamically determine the network it is operating in",
+ "vars": { },
+ "code": "split ws_general_query \"*AMT_EnvironmentDetectionSettingData\" \",\"\nwsbatchenum \"wsman_answer\" ws_general_query\nset envDetectionInstance wsman_answer.AMT_EnvironmentDetectionSettingData.response\nset envDetectionInstance.DetectionStrings undefined\nwsput \"AMT_EnvironmentDetectionSettingData\" envDetectionInstance\njump :error-%%%~%%% wsman_result \"==\" 200\nprint \"Cleared environment detection\"\njump :end-%%%~%%%\n:error-%%%~%%%\nprint \"ERROR: WSMAN call failed: {wsman_result_str}\"\njump :end-%%%~%%%\n:end-%%%~%%%\nset envDetectionInstance\nset ws_general_query\nset AMT_EnvironmentDetectionSettingData\nset PullRemoteAccess \"1\"\nset wsman_answer \nset wsman_result\n"
+ },
+ "AMT-SetBoot-PowerAction": {
+ "name": "Power - Power Action",
+ "desc": "Perform an Intel AMT power action",
+ "code": "set ManagedElementXml \"%3CAddress xmlns=\\%22http://schemas.xmlsoap.org/ws/2004/08/addressing\\%22%3Ehttp://schemas.xmlsoap.org/ws/2004/08/addressing%3C/Address%3E%3CReferenceParameters xmlns=\\%22http://schemas.xmlsoap.org/ws/2004/08/addressing\\%22%3E%3CResourceURI xmlns=\\%22http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd\\%22%3Ehttp://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ComputerSystem%3C/ResourceURI%3E%3CSelectorSet xmlns=\\%22http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd\\%22%3E%3CSelector Name=\\%22CreationClassName\\%22%3ECIM_ComputerSystem%3C/Selector%3E%3CSelector Name=\\%22Name\\%22%3EManagedSystem%3C/Selector%3E%3C/SelectorSet%3E%3C/ReferenceParameters%3E\"\r\njsonparse wsargs \"%7B %22PowerState%22:%22%%%powerAction%%%%22, %22ManagedElement%22:%22{ManagedElementXml}%22 %7D\"\r\nset ManagedElementXml\r\nwsexec \"CIM_PowerManagementService\" \"RequestPowerStateChange\" wsargs\r\nset wsargs\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nset PullSystemStatus \"1\"\r\nprint \"Power action completed\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\n",
+ "vars": {
+ "powerAction": {
+ "name": "Power Action",
+ "desc": "Indicate the power action to perform",
+ "type": 3,
+ "values": {
+ "2": "Power on",
+ "5": "Power cycle",
+ "8": "Power down",
+ "10": "Reset"
+ },
+ "value": "2"
+ }
+ }
+ },
+ "AMT-Power-SetBootSettings": {
+ "name": "Power - Set Boot Settings",
+ "desc": "Set next boot parameters",
+ "code": "split ws_general_query \"*AMT_BootSettingData\"\nwsbatchenum \"wsman_answer\" ws_general_query\njump :error-%%%~%%% wsman_result \"!=\" 200\nset bootoptions wsman_answer.AMT_BootSettingData.response\nset bootoptions.BIOSSetup \"%%%bootBiosSetup%%%\"\nset bootoptions.UseSOL \"%%%bootSerialOverLan%%%\"\nwsput \"AMT_BootSettingData\" bootoptions\nset AMT_BootSettingData\njump :error-%%%~%%% wsman_result \"!=\" 200\njump :end-%%%~%%%\n:error-%%%~%%%\nprint \"WSMAN call failed: {wsman_result_str}\"\n:end-%%%~%%%\nset ws_general_query\nset wsman_answer\nset wsman_result\nset wsman_result_str\n#set bootoptions\n\n",
+ "vars": {
+ "bootBiosSetup": {
+ "name": "BIOS Setup",
+ "desc": "On next boot go to BIOS setup screen",
+ "type": "3",
+ "value": "false",
+ "values": {
+ "true": "Enabled",
+ "false": "Disabled"
+ }
+ },
+ "bootSerialOverLan": {
+ "name": "Serial-over-LAN",
+ "desc": "Enable Serial-over-LAN on next boot",
+ "type": "3",
+ "value": "false",
+ "values": {
+ "true": "Enabled",
+ "false": "Disabled"
+ }
+ }
+ }
+ },
+ "AMT-Power-GetBootSettings": {
+ "name": "Power - Get Boot Settings",
+ "desc": "Get next boot parameters",
+ "code": "split ws_general_query \"*AMT_BootSettingData\"\nwsbatchenum \"wsman_answer\" ws_general_query\njump :error-%%%~%%% wsman_result \"!=\" 200\nset bootoptions wsman_answer.AMT_BootSettingData.response\nprint bootoptions\nset AMT_BootSettingData\njump :error-%%%~%%% wsman_result \"!=\" 200\njump :end-%%%~%%%\n:error-%%%~%%%\nprint \"WSMAN call failed: {wsman_result_str}\"\n:end-%%%~%%%\nset ws_general_query\nset wsman_answer\nset wsman_result\nset wsman_result_str\n#set bootoptions\n",
+ "vars": { }
+ },
+ "AMT-RemoteAccess-AddMpsServerFqdnCert": {
+ "name": "Remote - Add MPS FQDN/Cert",
+ "desc": "Add a new CIRA server (MPS) using the server's hostname and authentication using certificate",
+ "code": "# Get the input from user for the CN to look for\r\n# Get available certificates\r\nsplit ws_general_query \"AMT_PublicKeyCertificate\" ,\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\nlength wsman_ans_length wsman_answer.AMT_PublicKeyCertificate.responses\r\nset i 0\r\n:loop_ans-%%%~%%%\r\n# Get the current subject name\r\nset curSubject wsman_answer.AMT_PublicKeyCertificate.responses.{i}.Subject\r\nIndexOf pos curSubject \"CN=%%%CN%%%\" \r\njump :cnFound-%%%~%%% pos \">=\" 0\r\nadd i i 1\r\njump :loop_ans-%%%~%%% i \"<\" wsman_ans_length\r\njump :cnNotFound-%%%~%%%\r\n:cnFound-%%%~%%%\r\n# Set the reference to the certificate\r\nset certInstanceId wsman_answer.AMT_PublicKeyCertificate.responses.{i}.InstanceID\r\nset certHandle \"%3CAddress%20xmlns=%22http://schemas.xmlsoap.org/ws/2004/08/addressing%22%3Ehttp://schemas.xmlsoap.org/ws/2004/08/addressing%3C/Address%3E%3CReferenceParameters%20xmlns=%22http://schemas.xmlsoap.org/ws/2004/08/addressing%22%3E%3CResourceURI%20xmlns=%22http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd%22%3Ehttp://intel.com/wbem/wscim/1/amt-schema/1/AMT_PublicKeyCertificate%3C/ResourceURI%3E%3CSelectorSet%20xmlns=%22http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd%22%3E%3CSelector%20Name=%22InstanceID%22%3E{certInstanceId}%3C/Selector%3E%3C/SelectorSet%3E%3C/ReferenceParameters%3E\"\r\n# Set method parameters\r\njsonparse wsargs \"%7B%22AccessInfo%22:%22%%%FQDN%%%%22,%22InfoFormat%22:%22201%22,%22Port%22:%%%Port%%%,%22AuthMethod%22:%221%22%7D\"\r\nset wsargs.Certificate certHandle\r\n# Execute call to AddMpServer\r\nwsexec \"AMT_RemoteAccessService\" \"AddMpServer\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nprint \"Management Prescence Server (MPS) successfully added to the Intel(R) AMT Subsystem\"\r\nset PullRemoteAccess 1\r\njump :end-%%%~%%%\r\n:cnNotFound-%%%~%%%\r\nprint \"Couldn't find a certificate matching the value of CN=%%%CN%%%\"\r\n:error-%%%~%%%\r\nprint \"Call failed with error {wsman_result}\"\r\n:end-%%%~%%%\r\nset AMT_RemoteAccessService\r\nset certHandle\r\nset curSubject\r\nset i\r\nset pos\r\nset ws_general_query\r\nset wsargs\r\nset wsman_answer\r\nset wsman_result\r\nset wsman_result_str\r\nset certInstanceId\r\nset wsman_ans_length",
+ "vars": {
+ "FQDN": {
+ "name": "MPS Hostname",
+ "desc": "The Fully Qualified Domain Name of the MPS to add",
+ "type": 1,
+ "maxlength": 255,
+ "value": ""
+ },
+ "Port": {
+ "name": "Port Number",
+ "desc": "The MPS server port number",
+ "type": 2,
+ "maxlength": 5,
+ "value": ""
+ },
+ "CN": {
+ "name": "Certificate CN",
+ "desc": "The common name of the authentication certificate",
+ "type": 1,
+ "maxlength": 100,
+ "value": ""
+ }
+ }
+ },
+ "AMT-RemoteAccess-AddMpsServerFqdnUpa": {
+ "name": "Remote - Add MPS FQDN/User",
+ "desc": "Add a new CIRA server (MPS) using the server's hostname authentication using username/password",
+ "code": "# Set method parameters\r\njsonparse wsargs \"%7B%22AccessInfo%22:%22%%%FQDN%%%%22,%22InfoFormat%22:201,%22Port%22:%%%Port%%%,%22AuthMethod%22:2,%22Username%22:%22%%%username%%%%22,%22Password%22:%22%%%password%%%%22%7D\"\r\n# Execute call to AddMpServer\r\nwsexec \"AMT_RemoteAccessService\" \"AddMpServer\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nprint \"Management Prescence Server (MPS) successfully added to the Intel(R) AMT Subsystem\"\r\nset PullRemoteAccess 1\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\nset AMT_RemoteAccessService\r\nset certHandle\r\nset curSubject\r\nset i\r\nset pos\r\nset ws_general_query\r\nset wsargs\r\nset wsman_answer\r\nset wsman_result\r\nset wsman_result_str\r\nset certInstanceId\r\nset wsman_ans_length",
+ "vars": {
+ "FQDN": {
+ "name": "MPS Hostname",
+ "desc": "The Fully Qualified Domain Name of the MPS to add",
+ "type": 1,
+ "maxlength": 255,
+ "value": ""
+ },
+ "Port": {
+ "name": "Port Number",
+ "desc": "The MPS server port number",
+ "type": 2,
+ "maxlength": 5,
+ "value": ""
+ },
+ "username": {
+ "name": "Username",
+ "desc": "A Username to be used for the connection with the MPS",
+ "type": 1,
+ "maxlength": 16,
+ "value": ""
+ },
+ "password": {
+ "name": "Password",
+ "desc": "The Password matching the username above",
+ "type": 4,
+ "maxlength": 16,
+ "value": ""
+ }
+ }
+ },
+ "AMT-RemoteAccess-AddMpsIpCertServer": {
+ "name": "Remote - Add MPS IP/Cert",
+ "desc": "Add a new CIRA server (MPS) using the server's IP address and authentication using certificate",
+ "code": "# Get the input from user for the CN to look for\r\n# Get available certificates\r\nsplit ws_general_query \"AMT_PublicKeyCertificate\" ,\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\nlength wsman_ans_length wsman_answer.AMT_PublicKeyCertificate.responses\r\nset i 0\r\n:loop_ans-%%%~%%%\r\n# Get the current subject name\r\nset curSubject wsman_answer.AMT_PublicKeyCertificate.responses.{i}.Subject\r\nIndexOf pos curSubject \"CN=%%%CN%%%\" \r\njump :cnFound-%%%~%%% pos \">=\" 0\r\nadd i i 1\r\njump :loop_ans-%%%~%%% i \"<\" wsman_ans_length\r\njump :cnNotFound-%%%~%%%\r\n:cnFound-%%%~%%%\r\n# Set the reference to the certificate\r\nset certInstanceId wsman_answer.AMT_PublicKeyCertificate.responses.{i}.InstanceID\r\nset certHandle \"%3CAddress%20xmlns=%22http://schemas.xmlsoap.org/ws/2004/08/addressing%22%3Ehttp://schemas.xmlsoap.org/ws/2004/08/addressing%3C/Address%3E%3CReferenceParameters%20xmlns=%22http://schemas.xmlsoap.org/ws/2004/08/addressing%22%3E%3CResourceURI%20xmlns=%22http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd%22%3Ehttp://intel.com/wbem/wscim/1/amt-schema/1/AMT_PublicKeyCertificate%3C/ResourceURI%3E%3CSelectorSet%20xmlns=%22http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd%22%3E%3CSelector%20Name=%22InstanceID%22%3E{certInstanceId}%3C/Selector%3E%3C/SelectorSet%3E%3C/ReferenceParameters%3E\"\r\n# Set method parameters\r\njsonparse wsargs \"%7B%22AccessInfo%22:%22%%%IP%%%%22,%22InfoFormat%22:%223%22,%22Port%22:%%%Port%%%,%22AuthMethod%22:%221%22%7D\"\r\nset wsargs.Certificate certHandle\r\nset wsargs.CN \"%%%ServerName%%%\"\r\n# Execute call to AddMpServer\r\nwsexec \"AMT_RemoteAccessService\" \"AddMpServer\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nprint \"Management Prescence Server (MPS) successfully added to the Intel(R) AMT Subsystem\"\r\nset PullRemoteAccess 1\r\njump :end-%%%~%%%\r\n:cnNotFound-%%%~%%%\r\nprint \"Couldn't find a certificate matching the value of CN=%%%CN%%%\"\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\nset AMT_RemoteAccessService\r\nset certHandle\r\nset curSubject\r\nset i\r\nset pos\r\nset ws_general_query\r\nset wsargs\r\nset wsman_answer\r\nset wsman_result\r\nset wsman_result_str\r\nset certInstanceId\r\nset wsman_ans_length",
+ "vars": {
+ "IP": {
+ "name": "IPv4 Address",
+ "desc": "The IPv4 address of the MPS server",
+ "type": 1,
+ "maxlength": 255,
+ "value": ""
+ },
+ "Port": {
+ "name": "Port Number",
+ "desc": "The MPS server port number",
+ "type": 2,
+ "maxlength": 5,
+ "value": ""
+ },
+ "ServerName": {
+ "name": "Server Name",
+ "desc": "The server name, this must be the exact Common Name in the MPS server certificate",
+ "type": 1,
+ "maxlength": 255,
+ "value": ""
+ },
+ "CN": {
+ "name": "Certificate CN",
+ "desc": "The common name of the authentication certificate",
+ "type": 1,
+ "maxlength": 100,
+ "value": ""
+ }
+ }
+ },
+ "AMT-RemoteAccess-AddMpsIpUpa": {
+ "name": "Remote - Add MPS IP/User",
+ "desc": "Add a new CIRA server (MPS) using the servers IP address and authenticating using a username/password",
+ "code": "# Set method parameters\r\njsonparse wsargs \"%7B%22AccessInfo%22:%22%%%IP%%%%22,%22InfoFormat%22:%223%22,%22Port%22:%%%Port%%%,%22AuthMethod%22:%222%22,%22Username%22:%22%%%username%%%%22,%22Password%22:%22%%%password%%%%22%7D\"\r\nset wsargs.CN \"%%%ServerName%%%\"\r\n# Execute call to AddMpServer\r\nwsexec \"AMT_RemoteAccessService\" \"AddMpServer\" wsargs \"\"\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nprint \"Management Prescence Server (MPS) successfully added to the Intel(R) AMT Subsystem\"\r\nset PullRemoteAccess 1\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"Call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\nset AMT_RemoteAccessService\r\nset wsargs\r\nset wsman_answer\r\nset wsman_result\r\nset wsman_result_str\r\nset wsman_ans_length",
+ "vars": {
+ "IP": {
+ "name": "IPv4 Address",
+ "desc": "The IPv4 address of the MPS server",
+ "type": 1,
+ "maxlength": 255,
+ "value": ""
+ },
+ "Port": {
+ "name": "Port Number",
+ "desc": "The MPS server port number",
+ "type": 2,
+ "maxlength": 5,
+ "value": ""
+ },
+ "ServerName": {
+ "name": "Server Name",
+ "desc": "The server name, this must be the exact Common Name in the MPS server certificate",
+ "type": 1,
+ "maxlength": 255,
+ "value": ""
+ },
+ "username": {
+ "name": "Username",
+ "desc": "A Username to be used for the connection with the MPS",
+ "type": 1,
+ "maxlength": 16,
+ "value": ""
+ },
+ "password": {
+ "name": "Password",
+ "desc": "The Password matching the username above",
+ "type": 4,
+ "maxlength": 16,
+ "value": ""
+ }
+ }
+ },
+ "AMT-RemoteAccess-Remove-MPS": {
+ "name": "Remote - Remove MPS",
+ "desc": "Remove MPS identified by its IP/FQDN and port",
+ "code": "split ws_general_query \"AMT_ManagementPresenceRemoteSAP\" ,\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\nset i 0\r\nset arr wsman_answer.AMT_ManagementPresenceRemoteSAP.responses\r\nLength arr_len arr\r\n:loop-%%%~%%%\r\nset curAccessInfo arr.{i}.AccessInfo\r\nadd curAccessInfo curAccessInfo \":\"\r\nadd curAccessInfo curAccessInfo arr.{i}.Port\r\njump :mpsFound-%%%~%%% curAccessInfo \"=\" \"%%%AccessInfo%%%:%%%Port%%%\"\r\nadd i i 1\r\njump :loop-%%%~%%% i \"<\" arr_len\r\nprint \"No MPS was found matching the input parameters\"\r\njump :end-%%%~%%%\r\n:mpsFound-%%%~%%%\r\nprint \"Found matching MPS, starting removal process\"\r\nset instanceName wsman_answer.AMT_ManagementPresenceRemoteSAP.responses.{i}.Name\r\nset selector \"%3Cw:SelectorSet%3E%3Cw:Selector%20Name=%22Name%22%3E{instanceName}%3C/w:Selector%3E%3C/w:SelectorSet%3E\"\r\nwsdelete \"AMT_ManagementPresenceRemoteSAP\" selector\r\n:end-%%%~%%%\r\nset AMT_ManagementPresenceRemoteSAP\r\nset arr\r\nset curAccessInfo\r\nset i\r\nset instanceName\r\nset selector\r\nset ws_general_query\r\nset wsman_answer\r\nset wsman_result\r\nset wsman_result_str\r\nset arr_len\r\nset PullRemoteAccess 1",
+ "vars": {
+ "AccessInfo": {
+ "name": "FQDN/Address",
+ "desc": "The FQDN/IPv4 address of the MPS server to be deleted",
+ "type": 1,
+ "maxlength": 255,
+ "value": ""
+ },
+ "Port": {
+ "name": "Port Number",
+ "desc": "The MPS server port number",
+ "type": 2,
+ "maxlength": 5,
+ "value": ""
+ }
+ }
+ },
+ "AMT-RemoteAccess-RemoveAll-MPS": {
+ "name": "Remote - Remove All MPS",
+ "desc": "Remove all MPS",
+ "vars": { },
+ "code": "split ws_general_query \"AMT_ManagementPresenceRemoteSAP\" ,\nwsbatchenum \"wsman_answer\" ws_general_query\nset i 0\nset arr wsman_answer.AMT_ManagementPresenceRemoteSAP.responses\nLength arr_len arr\n:loop-%%%~%%%\nset instanceName wsman_answer.AMT_ManagementPresenceRemoteSAP.responses.{i}.Name\nset selector \"%3Cw:SelectorSet%3E%3Cw:Selector%20Name=%22Name%22%3E{instanceName}%3C/w:Selector%3E%3C/w:SelectorSet%3E\"\nwsdelete \"AMT_ManagementPresenceRemoteSAP\" selector\nadd i i 1\njump :loop-%%%~%%% i \"<\" arr_len\n:end-%%%~%%%\nset AMT_ManagementPresenceRemoteSAP\nset arr\nset i\nset instanceName\nset selector\nset ws_general_query\nset wsman_answer\nset wsman_result\nset wsman_result_str\nset arr_len\nset PullRemoteAccess 1\n"
+ },
+ "AMT-RemoteAccess-AddRemoteAccessPolicyRule": {
+ "name": "Remote - Add Trigger (User / Alert)",
+ "desc": "Set a remote access trigger policy, used to establish a secure tunnel between a management console and the Intel AMT platform.",
+ "code": "# *** Prepare arguments for AMT_RemoteAccessService.AddRemoteAccessPolicyRule ***\r\njsonparse ws_args \"%7B%22Trigger%22:%220%22,%22TunnelLifeTime%22:%22%%%tLifeTime%%%%22%7D\"\r\n# *** Verify valid input ***\r\njump :VALID_INPUT \"%%%AccessInfo1%%%\" \"!=\" \"\"\r\nprint \"ERROR: Field %22AccessInfo1%22 must not be empty, aborting operation...\"\r\njump :end-%%%~%%%\r\n:VALID_INPUT\r\n# *** Set a EPR selector matching user input ***\r\nsplit ws_general_query \"AMT_ManagementPresenceRemoteSAP\" ,\r\nwsbatchenum \"wsman_answer\" ws_general_query\r\nset i 0\r\nset arr wsman_answer.AMT_ManagementPresenceRemoteSAP.responses\r\nLength arr_len arr\r\nset mpsEpr1 \"*\"\r\nset mpsEpr2 \"*\"\r\n:loop-%%%~%%%\r\nset curAccessInfo arr.{i}.AccessInfo\r\nadd curAccessInfo curAccessInfo \":\"\r\nadd curAccessInfo curAccessInfo arr.{i}.Port\r\njump :MPS1_NO_MATCH curAccessInfo \"!=\" \"%%%AccessInfo1%%%\"\r\nset mpsEpr1 wsman_answer.AMT_ManagementPresenceRemoteSAP.responses.{i}.Name\r\nprint \"Found matching (primary) mps: {mpsEpr1}\"\r\njump :MPS2_NOTSET \"%%%AccessInfo2%%%\" \"=\" \"\"\r\n:MPS1_NO_MATCH\r\njump :MPS2_NO_MATCH curAccessInfo \"!=\" \"%%%AccessInfo2%%%\"\r\nset mpsEpr2 wsman_answer.AMT_ManagementPresenceRemoteSAP.responses.{i}.Name\r\nprint \"Found matching (secondary) mps: {mpsEpr2}\"\r\n:MPS2_NO_MATCH\r\nadd i i 1\r\njump :loop-%%%~%%% i \"<\" arr_len\r\n:MPS2_NOTSET\r\njump :MPS1_FOUND mpsEpr1 \"!=\" \"*\"\r\nprint \"ERROR: MPS server: %22%%%AccessInfo1%%%%22 could not be found, aborting operation...\"\r\njump :end-%%%~%%%\r\n:MPS1_FOUND\r\njump :MPS2_FOUND \"%%%AccessInfo2%%%\" \"=\" \"\"\r\njump :MPS2_FOUND mpsEpr2 \"!=\" \"*\"\r\nprint \"ERROR: MPS server: %22%%%AccessInfo2%%%%22 could not be found, aborting operation...\"\r\njump :end-%%%~%%%\r\n:MPS2_FOUND\r\nprint \"Setting policy...\"\r\njsonparse ws_args.MpServer \"%7B%7D\"\r\nset MpServer \"%3CAddress%20xmlns=%22http://schemas.xmlsoap.org/ws/2004/08/addressing%22%3Ehttp://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous%3C/Address%3E%3CReferenceParameters%20xmlns=%22http://schemas.xmlsoap.org/ws/2004/08/addressing%22%3E%3CResourceURI%20xmlns=%22http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd%22%3Ehttp://intel.com/wbem/wscim/1/amt-schema/1/AMT_ManagementPresenceRemoteSAP%3C/ResourceURI%3E%3CSelectorSet%20xmlns=%22http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd%22%3E%3CSelector%20Name=%22Name%22%3E{mpsEpr1}%3C/Selector%3E%3C/SelectorSet%3E%3C/ReferenceParameters%3E\"\r\njump :SKIP_ADD_MPS2 \"%%%AccessInfo2%%%\" \"=\" \"\"\r\nadd MpServer MpServer \"|%3CAddress%20xmlns=%22http://schemas.xmlsoap.org/ws/2004/08/addressing%22%3Ehttp://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous%3C/Address%3E%3CReferenceParameters%20xmlns=%22http://schemas.xmlsoap.org/ws/2004/08/addressing%22%3E%3CResourceURI%20xmlns=%22http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd%22%3Ehttp://intel.com/wbem/wscim/1/amt-schema/1/AMT_ManagementPresenceRemoteSAP%3C/ResourceURI%3E%3CSelectorSet%20xmlns=%22http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd%22%3E%3CSelector%20Name=%22Name%22%3E{mpsEpr2}%3C/Selector%3E%3C/SelectorSet%3E%3C/ReferenceParameters%3E\"\r\n:SKIP_ADD_MPS2\r\nsplit ws_args.MpServer MpServer \"|\"\r\n# *** Call AMT_RemoteAccessService.AddRemoteAccessPolicyRule with policy details. ***\r\nwsexec \"AMT_RemoteAccessService\" \"AddRemoteAccessPolicyRule\" ws_args selector\r\njump :error-%%%~%%% wsman_result \"!=\" 200\r\nprint \"Policy added successfully\"\r\njump :end-%%%~%%%\r\n:error-%%%~%%%\r\nprint \"WSMAN call failed: {wsman_result_str}\"\r\n:end-%%%~%%%\r\nset PullRemoteAccess 1\r\nset mpsEpr1\r\nset mpsEpr2\r\nset i\r\nset curAccessInfo\r\nset arr_len\r\nset MpServer\r\nset arr\r\nset AMT_RemoteAccessService\r\nset wsman_result\r\nset wsman_result_str\r\nset ws_args\r\nset ws_general_query\r\nset wsman_answer",
+ "vars": {
+ "AccessInfo1": {
+ "name": "MPS 1 Address",
+ "desc": "The FQDN/IPv4 & Port of the MPS targeted for this policy. (e.g. mps1.mydomain.com:1234, 1.2.3.4:2233)",
+ "type": 1,
+ "maxlength": 255,
+ "value": ""
+ },
+ "AccessInfo2": {
+ "name": "MPS 2 Address",
+ "desc": "Optional, leave empty value if not applicable. Sames as above. In case you wish to apply this policy to 2 (two) mps instances",
+ "type": 1,
+ "maxlength": 255,
+ "value": ""
+ },
+ "Trigger": {
+ "name": "Trigger",
+ "desc": "The event that will trigger the establishment of the remote connection to the MPS.",
+ "type": 3,
+ "values": {
+ "0": "User Initiated",
+ "1": "Alert"
+ },
+ "value": "0"
+ },
+ "tLifeTime": {
+ "name": "Tunnel Lifetime",
+ "desc": "Defines the tunnel’s lifetime in seconds. A value of 0 means that the tunnel should stay open until it is closed by the server, the CloseRemoteAccessConnection method or when a different policy with a higher priority needs to be processed.",
+ "type": 2,
+ "maxlength": 5,
+ "value": "0"
+ }
+ }
+ },
+ "AMT-RemoteAccess-AddRemoteAccessPolicyRule2": {
+ "name": "Remote - Add Trigger (Periodic)",
+ "desc": "Set a remote access trigger policy, used to establish a secure tunnel between a management console and the Intel AMT platform.",
+ "code": "# *** Verify valid input ***\r\nsplit period_arr \"%%%Period%%%\" \":\"\r\nlength period_arr_len period_arr\r\njump :INVALID_ARG_AccessInfo1 \"%%%AccessInfo1%%%\" \"=\" \"\"\r\njump :DailyPeriod \"%%%PeriodType%%%\" \"!=\" \"0\"\r\njump :INVALID_PeriodType \"%%%PeriodType%%%\" \"!=\" \"0\"\r\njump :INVALID_ARG_Period period_arr.0 \"<=\" \"0\"\r\njump :INVALID_ARG_Period period_arr.0 \">\" \"4294967295\"\r\nIntToStr extendedData \"0\"\r\nIntToStr bPeriod period_arr.0\r\nadd extendedData extendedData bPeriod\r\njump :SET_PERIOD\r\n:DailyPeriod\r\njump :INVALID_PeriodType period_arr_len \"!=\" \"2\"\r\njump :INVALID_ARG_PeriodDaily period_arr.0 \"<=\" \"0\"\r\njump :INVALID_ARG_PeriodDaily period_arr.0 \">\" \"23\"\r\njump :INVALID_ARG_PeriodDaily period_arr.1 \">\" \"59\"\r\njump :INVALID_ARG_PeriodDaily period_arr.1 \"<=\" \"0\"\r\nIntToStr extendedData \"1\"\r\nIntToStr bPeriodHour period_arr.0\r\nIntToStr bPeriodMinute period_arr.1\r\nadd extendedData extendedData bPeriodHour\r\nadd extendedData extendedData bPeriodMinute\r\njump :SET_PERIOD\r\n:INVALID_PeriodType\r\nprint \"ERROR: The period type and value must correspond, aborting operation...\"\r\njump :end-%%%~%%%\r\n:INVALID_ARG_PeriodDaily\r\nprint \"ERROR: Field %22Period%22 must be a value HH:MM 0<=HH<24 && 0<=MM<60, aborting operation...\"\r\njump :end-%%%~%%%\r\n:INVALID_ARG_AccessInfo1\r\nprint \"ERROR: Field %22AccessInfo1%22 must not be empty, aborting operation...\"\r\njump :end-%%%~%%%\r\n:INVALID_ARG_Period\r\nprint \"ERROR: Field %22Period%22 must be a value 0<=t
+
+
+
+
\ No newline at end of file
diff --git a/webrelay.ashx b/webrelay.ashx
new file mode 100644
index 0000000..f4ae753
--- /dev/null
+++ b/webrelay.ashx
@@ -0,0 +1,175 @@
+<%@ WebHandler Language="C#" Class="ManageabilityCommander.WebRelay" %>
+
+using System;
+using System.IO;
+using System.Net;
+using System.Web;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Collections;
+using System.Net.Sockets;
+using System.Net.Security;
+using System.Web.WebSockets;
+using System.Net.WebSockets;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Security.Cryptography;
+using System.Security.Authentication;
+using System.Security.Cryptography.X509Certificates;
+
+namespace ManageabilityCommander
+{
+ ///
+ /// WebSocket to TCP/TLS bridge. This handler accepts a websocket connection and forwards the traffic to TCP/TLS.
+ ///
+ public class WebRelay : IHttpHandler
+ {
+ string host = null;
+ int port = 0;
+ bool tls = false;
+ WebSocket websocket = null;
+ TcpClient client = null;
+ Stream stream = null;
+ byte[] clientReadBuf = new byte[16384];
+ bool closing = false;
+ object mainlock = new object();
+
+ public bool IsReusable { get { return false; } }
+ private void Log(string x) { lock (mainlock) { File.AppendAllText("C:\\temp\\tlog.txt", DateTime.Now.ToString() + " - " + x.Replace('\0', '~') + "\r\n"); } }
+
+ public void ProcessRequest(HttpContext context)
+ {
+ var queryargs = System.Web.HttpUtility.ParseQueryString(context.Request.Url.Query);
+
+ if (!context.IsWebSocketRequest)
+ {
+ context.Response.StatusCode = 200;
+ context.Response.Redirect("default.htm");
+ context.Response.End();
+ return;
+ }
+
+ if (queryargs["host"] == null || queryargs["port"] == null || queryargs["tls"] == null)
+ {
+ context.Response.StatusCode = 200;
+ context.Response.ContentType = "text/plain";
+ context.Response.Write("Host, Port and Tls arguments expected.");
+ context.Response.End();
+ return;
+ }
+
+ host = queryargs["host"];
+ int.TryParse(queryargs["port"], out port);
+ tls = (queryargs["tls"] != null && string.Compare(queryargs["tls"], "1", true) == 0);
+
+ if (port < 1 || port > 65535)
+ {
+ context.Response.StatusCode = 200;
+ context.Response.ContentType = "text/plain";
+ context.Response.Write("Invalid port.");
+ context.Response.End();
+ return;
+ }
+
+ try
+ {
+ context.AcceptWebSocketRequest(ProcessNewWebSocket);
+ }
+ catch (Exception ex)
+ {
+ context.Response.StatusCode = 202;
+ context.Response.ContentType = "text/plain";
+ context.Response.Write("AcceptWebSocketRequest() Error: " + ex.ToString());
+ context.Response.End();
+ }
+ }
+
+ private bool CheckClientCert(object sender, X509Certificate cert, X509Chain chain, SslPolicyErrors errors)
+ {
+ return true;
+ }
+
+ private async Task ProcessNewWebSocket(AspNetWebSocketContext context)
+ {
+ websocket = context.WebSocket;
+ client = new TcpClient();
+ try { await client.ConnectAsync(host, port); } catch (Exception) { client = null; }
+
+ if (client == null)
+ {
+ await websocket.CloseAsync(WebSocketCloseStatus.EndpointUnavailable, "Unable to TCP connect to target host:port", CancellationToken.None);
+ websocket.Dispose();
+ websocket = null;
+ return;
+ }
+
+ try
+ {
+ if (tls == false)
+ {
+ stream = client.GetStream();
+ stream.BeginRead(clientReadBuf, 0, clientReadBuf.Length, new AsyncCallback(onClientReadData), null);
+ }
+ else
+ {
+ SslStream secureClientStream = new SslStream(client.GetStream(), false, new RemoteCertificateValidationCallback(CheckClientCert), null, EncryptionPolicy.RequireEncryption);
+ stream = secureClientStream;
+ secureClientStream.AuthenticateAsClientAsync(host).Wait();
+ stream.BeginRead(clientReadBuf, 0, clientReadBuf.Length, new AsyncCallback(onClientReadData), null);
+ }
+ }
+ catch (Exception) { closing = true; }
+
+ while (closing == false)
+ {
+ try
+ {
+ ArraySegment buffer = new ArraySegment(new byte[16384]);
+ WebSocketReceiveResult result = await websocket.ReceiveAsync(buffer, CancellationToken.None);
+ if (closing == true || websocket.State != WebSocketState.Open) break;
+ stream.WriteAsync(buffer.Array, buffer.Offset, result.Count).Wait();
+ }
+ catch (Exception) { }
+ }
+
+ try
+ {
+ await websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Remote TCP connection closed", CancellationToken.None);
+ websocket.Dispose();
+ }
+ catch (Exception) { }
+
+ websocket = null;
+ stream = null;
+
+ try { client.Close(); } catch (Exception) { }
+ client = null;
+ }
+
+ private void onClientReadData(IAsyncResult ar)
+ {
+ int r = 0;
+ try { r = stream.EndRead(ar); } catch (Exception) { }
+
+ try
+ {
+ if (r == 0)
+ {
+ closing = true;
+ try { websocket.Abort(); } catch (Exception) { }
+ }
+ else
+ {
+ websocket.SendAsync(new ArraySegment(clientReadBuf, 0, r), WebSocketMessageType.Binary, true, CancellationToken.None).Wait();
+ stream.BeginRead(clientReadBuf, 0, clientReadBuf.Length, new AsyncCallback(onClientReadData), null);
+ }
+ }
+ catch (Exception) {
+ closing = true;
+ try { websocket.Abort(); } catch (Exception) { }
+ }
+ }
+
+ }
+}
\ No newline at end of file
diff --git a/websitecompiler/Firmware-MeshCommander.wcc b/websitecompiler/Firmware-MeshCommander.wcc
new file mode 100644
index 0000000..3d53892
Binary files /dev/null and b/websitecompiler/Firmware-MeshCommander.wcc differ
diff --git a/websitecompiler/NodeWebkit-Commander.wcc b/websitecompiler/NodeWebkit-Commander.wcc
new file mode 100644
index 0000000..a07c8e3
Binary files /dev/null and b/websitecompiler/NodeWebkit-Commander.wcc differ
diff --git a/websocket-wrapper-0.2.0.js b/websocket-wrapper-0.2.0.js
new file mode 100644
index 0000000..d761c84
--- /dev/null
+++ b/websocket-wrapper-0.2.0.js
@@ -0,0 +1,206 @@
+/**
+* @description MeshCentral2 communication using websocket
+* @author Ylian Saint-Hilaire
+* @version v0.2.0a
+*/
+
+// Construct a MeshCentral2 communication object
+var CreateWebSocketWrapper = function (host, port, path, certhash) {
+ //console.log('CreateWebSocketWrapper', host, port, path, certhash);
+ var obj = {};
+ obj.host = host;
+ obj.port = port;
+ obj.path = path;
+ obj.certhash = certhash;
+ obj.socket = null;
+ obj.socketState = 0;
+ obj.net = require('net');
+ obj.tls = require('tls');
+ obj.crypto = require('crypto');
+ obj.constants = require('constants');
+ obj.xtlsoptions = null;
+ obj.accumulator = "";
+ obj.accopcodes = 0;
+ obj.acclen = -1;
+ obj.accmask = false;
+ obj.xtlsCertificate = null;
+ obj.xtlsFingerprint = null;
+
+ // Events
+ obj.ondata = null;
+ obj.onclose = null;
+ obj.ontimeout = null;
+ obj.onconnect = null;
+ obj.on = function (ev, fn) {
+ if (ev == 'data') { obj.ondata = fn; }
+ if (ev == 'close') { obj.onclose = fn; }
+ if (ev == 'error') { }
+ }
+
+ // Called to initiate a websocket connection to the server
+ obj.connect = function (onconnect) {
+ obj.onconnect = onconnect;
+ obj.socketState = 1;
+ obj.accumulator = "";
+ obj.accopcodes = 0;
+ obj.acclen = -1;
+ obj.accmask = false;
+ obj.xtlsFingerprint = null;
+ if (obj.certhash == null) {
+ //console.log('Connecting to ws://' + obj.host + ':' + obj.port + obj.path);
+ obj.socket = new obj.net.Socket();
+ obj.socket.setEncoding('binary');
+ obj.socket.connect(obj.port, obj.host, _OnSocketConnected);
+ } else {
+ //console.log('Connecting to wss://' + obj.host + ':' + obj.port + obj.path);
+ obj.socket = obj.tls.connect(obj.port, obj.host, { rejectUnauthorized: false }, _OnSocketConnected);
+ obj.socket.setEncoding('binary');
+ }
+ obj.socket.on('data', _OnSocketData);
+ obj.socket.on('close', _OnSocketClosed);
+ obj.socket.on('error', _OnSocketClosed);
+ }
+
+ obj.disconnect = function () { _OnSocketClosed("UserDisconnect"); }
+ obj.send = function (obj) { _Send(obj); }
+ obj.setEncoding = function(encoding) { }
+ obj.setTimeout = function (timeout) { }
+ obj.setNoDelay = function (delay) { }
+ obj.destroy = function () { _OnSocketClosed(); }
+ obj.end = function () { _OnSocketClosed(); }
+ obj.write = function (data) { _SendEx(data.toString('binary')); }
+
+ // Called when the socket is connected, we still need to do work to get the websocket connected
+ function _OnSocketConnected() {
+ if (obj.socket == null) return;
+ //console.log('Websocket connected');
+ // Check if this is really the MeshServer we want to connect to
+ obj.xtlsCertificate = obj.socket.getPeerCertificate();
+ obj.xtlsFingerprint = obj.xtlsCertificate.fingerprint.split(':').join('').toLowerCase();
+ if (obj.xtlsFingerprint != obj.certhash.split(':').join('').toLowerCase()) { console.error("Hash match fail", obj.xtlsFingerprint, obj.certhash.split(':').join('').toLowerCase()); _OnSocketClosed("HashMatchFail"); return; }
+
+ // Send the websocket switching header
+ obj.socket.write(new Buffer("GET " + obj.path + " HTTP/1.1\r\nHost: " + obj.host + "\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\nSec-WebSocket-Version: 13\r\n\r\n", "binary"));
+ }
+
+ // Called when socket data is received from the server
+ function _OnSocketData(e) {
+ //console.log('_OnSocketData', typeof e, e.length);
+ obj.accumulator += e;
+ if (obj.socketState == 1) {
+ // Look for the HTTP header response
+ var i = obj.accumulator.indexOf('\r\n\r\n');
+ if (i >= 0) {
+ var header = parseHttpHeader(obj.accumulator.substring(0, i));
+ if ((header != null) && (header._Path == '101')) {
+ // Success
+ obj.accumulator = obj.accumulator.substring(i + 4);
+ obj.socketState = 2;
+ //console.log('websocket connected');
+ if (obj.onconnect) { obj.onconnect(); }
+ } else {
+ // Fail
+ if (header == null) { _OnSocketClosed("Bad header"); } else { _OnSocketClosed(header._Path); }
+ }
+ }
+ }
+ if (obj.socketState >= 2) {
+ // Parse WebSocket data
+ //console.log('ACC(' + obj.accumulator.length + '):' + obj.accumulator);
+ while (_parseWsData() != 0) { }
+ }
+ };
+
+ // Parses websocket data from a socket connection, returns the number of bytes consumed.
+ function _parseWsData() {
+ if (obj.acclen == -1) {
+ // Look for a websocket header
+ if (obj.accumulator.length < 2) return 0;
+ var headsize = 2;
+ obj.accopcodes = obj.accumulator.charCodeAt(0);
+ obj.accmask = ((obj.accumulator.charCodeAt(1) & 0x80) != 0)
+ obj.acclen = (obj.accumulator.charCodeAt(1) & 0x7F);
+ if (obj.acclen == 126) {
+ if (obj.accumulator.length < 4) return 0;
+ headsize = 4;
+ obj.acclen = ReadShort(obj.accumulator, 2);
+ }
+ else if (obj.acclen == 127) {
+ if (obj.accumulator.length < 10) return 0;
+ headsize = 10;
+ obj.acclen = ReadInt(obj.accumulator, 6);
+ }
+ if (obj.accmask == true) {
+ // TODO: Do unmasking here.
+ headsize += 4;
+ }
+ //console.log('FIN: ' + ((obj.accopcodes & 0x80) != 0) + ', OP: ' + (obj.accopcodes & 0x0F) + ', LEN: ' + obj.acclen + ', MASK: ' + obj.accmask);
+ obj.accumulator = obj.accumulator.substring(headsize);
+ return headsize;
+ } else {
+ // Read the data
+ if (obj.accumulator.length < obj.acclen) return 0;
+ _OnWebSocketMessage(((obj.accopcodes & 0x80) != 0), (obj.accopcodes & 0x0F), obj.accumulator.substring(0, obj.acclen));
+ obj.accumulator = obj.accumulator.substring(obj.acclen);
+ var out = obj.acclen;
+ obj.acclen = -1;
+ return out;
+ }
+ }
+
+ // Called when the a command is received from the server
+ function _OnWebSocketMessage(fin, op, data) {
+ //console.log('FIN: ' + fin + ', OP: ' + op + ', LEN: ' + data.length, ': ' + data);
+ //if (op != 1) { return; } // We only process text frames
+ if ((op == 1 || op == 2) && (obj.ondata != null) && (data.length > 0)) { obj.ondata(data); } // Pass text & binary
+ if (op == 8) { _OnSocketClosed('RemoteClose'); } // Close the websocket
+ }
+
+ // Called when the socket is closed
+ function _OnSocketClosed(cause) {
+ //console.log('Websocket closed: ' + cause);
+ if (obj.socketState == 0) return;
+ obj.socketState = 0;
+ if (obj.onclose != null) { obj.onclose(); }
+ if (obj.socket != null) { try { obj.socket.end(); } catch (ex) { } obj.socket = null; }
+ }
+
+ // Called to send websocket data to the server
+ function _Send(object) {
+ if (obj.socketState < 2) { return; }
+ var data = new Buffer(JSON.stringify(object), "binary");
+ var header = String.fromCharCode(129); // 129 is default full fragment op code (129 = text, 130 = binary)
+ if (data.length < 126) { header += String.fromCharCode(data.length); }
+ else if (data.length < 65536) { header += String.fromCharCode(126) + ShortToStr(data.length); }
+ else { header += String.fromCharCode(127) + IntToStr(0) + IntToStr(data.length); }
+ try { obj.socket.write(new Buffer(header + data, 'binary')); } catch (e) { }
+ }
+
+ // Called to send websocket data to the server
+ function _SendEx(data) {
+ if (obj.socketState < 2) { return; }
+ //if (typeof data == 'string') { data = new Buffer(data, 'binary'); }
+ var header = String.fromCharCode(130); // 129 is default full fragment op code (129 = text, 130 = binary)
+ if (data.length < 126) { header += String.fromCharCode(data.length); }
+ else if (data.length < 65536) { header += String.fromCharCode(126) + ShortToStr(data.length); }
+ else { header += String.fromCharCode(127) + IntToStr(0) + IntToStr(data.length); }
+ try { obj.socket.write(new Buffer(header + data, 'binary')); } catch (e) { }
+ }
+
+ // Parse the data and return the decoded HTTP header if present.
+ function parseHttpHeader(data) {
+ var lines = data.split('\r\n');
+ if (lines.length < 1) return null;
+ var values = {}, directive = lines[0].split(' ');
+ if (directive.length < 3) return null;
+ values['_Action'] = directive[0];
+ values['_Path'] = directive[1];
+ values['_Protocol'] = directive[2];
+ for (i in lines) { if (i == 0) continue; var j = lines[i].indexOf(':'); if (j > 0) { values[lines[i].substring(0, j).trim()] = lines[i].substring(j + 1).trim(); } }
+ if (values['Content-Length']) { values['Content-Length'] = parseInt(values['Content-Length']); }
+ return values;
+ }
+
+ return obj;
+}
+
diff --git a/zlib-adler32.js b/zlib-adler32.js
new file mode 100644
index 0000000..d1165fa
--- /dev/null
+++ b/zlib-adler32.js
@@ -0,0 +1,279 @@
+/* zlib-adler32.js -- JavaScript implementation for the zlib adler32.
+ Version: 0.2.0
+ LastModified: Apr 12 2012
+ Copyright (C) 2012 Masanao Izumo
+
+ API documentation
+==============================================================================
+Usage: adler = ZLIB.adler32(adler, buf, offset, len);
+
+ Update a running Adler-32 checksum with the bytes buf[offset..offset+len-1] and
+ return the updated checksum. If buf is null, this function returns the
+ required initial value for the checksum.
+
+ An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+ much faster.
+
+ Usage example:
+
+ var adler = ZLIB.adler32(0, null, 0, 0);
+
+ while (read_buffer(buffer, length) != EOF) {
+ adler = ZLIB.adler32(adler, buffer, 0, length);
+ }
+ if (adler != original_adler) error();
+
+==============================================================================
+Usage: adler = ZLIB.adler32_combine(adler1, adler2, len2);
+
+ Combine two Adler-32 checksums into one. For two sequences of bytes, seq1
+ and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+ each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of
+ seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note
+ that the z_off_t type (like off_t) is a signed integer. If len2 is
+ negative, the result has no meaning or utility.
+*/
+
+if( typeof ZLIB === 'undefined' ) {
+ alert('ZLIB is not defined. SRC zlib.js before zlib-adler32.js')
+}
+
+(function() {
+
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2011 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+var BASE = 65521; /* largest prime smaller than 65536 */
+var NMAX = 5552;
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+/* ========================================================================= */
+function adler32_string(adler, buf, offset, len)
+{
+ var sum2;
+ var n;
+
+ /* split Adler-32 into component sums */
+ sum2 = (adler >>> 16) & 0xffff;
+ adler &= 0xffff;
+
+ /* in case user likes doing a byte at a time, keep it fast */
+ if (len == 1) {
+ adler += buf.charCodeAt(offset) & 0xff;
+ if (adler >= BASE)
+ adler -= BASE;
+ sum2 += adler;
+ if (sum2 >= BASE)
+ sum2 -= BASE;
+ return adler | (sum2 << 16);
+ }
+
+ /* initial Adler-32 value (deferred check for len == 1 speed) */
+ if (buf === null)
+ return 1;
+
+ /* in case short lengths are provided, keep it somewhat fast */
+ if (len < 16) {
+ while (len--) {
+ adler += buf.charCodeAt(offset++) & 0xff;
+ sum2 += adler;
+ }
+ if (adler >= BASE)
+ adler -= BASE;
+ sum2 %= BASE; /* only added so many BASE's */
+ return adler | (sum2 << 16);
+ }
+
+ /* do length NMAX blocks -- requires just one modulo operation */
+ while (len >= NMAX) {
+ len -= NMAX;
+ n = NMAX >> 4; /* NMAX is divisible by 16 */
+ do {
+ /* 16 sums unrolled */
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ } while (--n);
+ adler %= BASE;
+ sum2 %= BASE;
+ }
+
+ /* do remaining bytes (less than NMAX, still just one modulo) */
+ if (len) { /* avoid modulos if none remaining */
+ while (len >= 16) {
+ len -= 16;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ }
+ while (len--) {
+ adler += buf.charCodeAt(offset++) & 0xff; sum2 += adler;
+ }
+ adler %= BASE;
+ sum2 %= BASE;
+ }
+
+ /* return recombined sums */
+ return adler | (sum2 << 16);
+}
+
+/* ========================================================================= */
+function adler32_array(adler, buf, offset, len)
+{
+ var sum2;
+ var n;
+
+ /* split Adler-32 into component sums */
+ sum2 = (adler >>> 16) & 0xffff;
+ adler &= 0xffff;
+
+ /* in case user likes doing a byte at a time, keep it fast */
+ if (len == 1) {
+ adler += buf[offset];
+ if (adler >= BASE)
+ adler -= BASE;
+ sum2 += adler;
+ if (sum2 >= BASE)
+ sum2 -= BASE;
+ return adler | (sum2 << 16);
+ }
+
+ /* initial Adler-32 value (deferred check for len == 1 speed) */
+ if (buf === null)
+ return 1;
+
+ /* in case short lengths are provided, keep it somewhat fast */
+ if (len < 16) {
+ while (len--) {
+ adler += buf[offset++];
+ sum2 += adler;
+ }
+ if (adler >= BASE)
+ adler -= BASE;
+ sum2 %= BASE; /* only added so many BASE's */
+ return adler | (sum2 << 16);
+ }
+
+ /* do length NMAX blocks -- requires just one modulo operation */
+ while (len >= NMAX) {
+ len -= NMAX;
+ n = NMAX >> 4; /* NMAX is divisible by 16 */
+ do {
+ /* 16 sums unrolled */
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ } while (--n);
+ adler %= BASE;
+ sum2 %= BASE;
+ }
+
+ /* do remaining bytes (less than NMAX, still just one modulo) */
+ if (len) { /* avoid modulos if none remaining */
+ while (len >= 16) {
+ len -= 16;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ adler += buf[offset++]; sum2 += adler;
+ }
+ while (len--) {
+ adler += buf[offset++]; sum2 += adler;
+ }
+ adler %= BASE;
+ sum2 %= BASE;
+ }
+
+ /* return recombined sums */
+ return adler | (sum2 << 16);
+}
+
+/* ========================================================================= */
+ZLIB.adler32 = function(adler, buf, offset, len)
+{
+ if(typeof buf === 'string') {
+ return adler32_string(adler, buf, offset, len);
+ } else {
+ return adler32_array(adler, buf, offset, len);
+ }
+};
+
+ZLIB.adler32_combine = function(adler1, adler2, len2)
+{
+ var sum1;
+ var sum2;
+ var rem;
+
+ /* for negative len, return invalid adler32 as a clue for debugging */
+ if (len2 < 0)
+ return 0xffffffff;
+
+ /* the derivation of this formula is left as an exercise for the reader */
+ len2 %= BASE; /* assumes len2 >= 0 */
+ rem = len2;
+ sum1 = adler1 & 0xffff;
+ sum2 = rem * sum1;
+ sum2 %= BASE;
+ sum1 += (adler2 & 0xffff) + BASE - 1;
+ sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
+ if (sum1 >= BASE) sum1 -= BASE;
+ if (sum1 >= BASE) sum1 -= BASE;
+ if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
+ if (sum2 >= BASE) sum2 -= BASE;
+ return sum1 | (sum2 << 16);
+}
+
+}());
diff --git a/zlib-crc32.js b/zlib-crc32.js
new file mode 100644
index 0000000..734bab6
--- /dev/null
+++ b/zlib-crc32.js
@@ -0,0 +1,246 @@
+/* zlib-adler32.js -- JavaScript implementation for the zlib crc32.
+ Version: 0.2.0
+ LastModified: Apr 12 2012
+ Copyright (C) 2012 Masanao Izumo
+
+ API documentation
+==============================================================================
+Usage: crc = ZLIB.crc32(crc, buf, offset, len);
+
+ Update a running CRC-32 with the bytes buf[offset..offset+len-1] and return the
+ updated CRC-32. If buf is null, this function returns the required
+ initial value for the for the crc. Pre- and post-conditioning (one's
+ complement) is performed within this function so it shouldn't be done by the
+ application.
+
+ Usage example:
+
+ var crc = ZLIB.crc32(0, null, 0, 0);
+
+ while (read_buffer(buffer, length) != EOF) {
+ crc = ZLIB.crc32(crc, buffer, 0, length);
+ }
+ if (crc != original_crc) error();
+
+==============================================================================
+Usage: crc = crc32_combine(crc1, crc2, len2);
+
+ Combine two CRC-32 check values into one. For two sequences of bytes,
+ seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+ calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32
+ check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+ len2.
+*/
+
+if( typeof ZLIB === 'undefined' ) {
+ alert('ZLIB is not defined. SRC zlib.js before zlib-crc32.js')
+}
+
+(function() {
+
+/* crc32.c -- compute the CRC-32 of a data stream
+ * Copyright (C) 1995-2006, 2010, 2011 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Thanks to Rodney Brown for his contribution of faster
+ * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
+ * tables for updating the shift register in one step with three exclusive-ors
+ * instead of four steps with four exclusive-ors. This results in about a
+ * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
+ */
+
+var crc_table = [
+ 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
+ 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
+ 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
+ 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+ 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
+ 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+ 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
+ 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+ 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
+ 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
+ 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
+ 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+ 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
+ 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
+ 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
+ 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+ 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
+ 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+ 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
+ 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+ 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
+ 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
+ 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
+ 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+ 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
+ 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
+ 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
+ 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+ 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
+ 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+ 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
+ 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+ 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
+ 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
+ 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
+ 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+ 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
+ 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
+ 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
+ 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+ 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
+ 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+ 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
+ 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+ 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
+ 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
+ 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
+ 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+ 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
+ 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
+ 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
+ 0x2d02ef8d ];
+
+/* ========================================================================= */
+function crc32_string(crc, buf, offset, len)
+{
+ if (buf == null) return 0;
+
+ crc = crc ^ 0xffffffff;
+ while (len >= 8) {
+ crc = crc_table[(crc ^ buf.charCodeAt(offset++)) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf.charCodeAt(offset++)) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf.charCodeAt(offset++)) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf.charCodeAt(offset++)) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf.charCodeAt(offset++)) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf.charCodeAt(offset++)) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf.charCodeAt(offset++)) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf.charCodeAt(offset++)) & 0xff] ^ (crc >>> 8)
+ len -= 8;
+ }
+ if (len) do {
+ crc = crc_table[(crc ^ buf.charCodeAt(offset++)) & 0xff] ^ (crc >>> 8)
+ } while (--len);
+ return crc ^ 0xffffffff;
+}
+
+/* ========================================================================= */
+function crc32_array(crc, buf, offset, len)
+{
+ if (buf == null) return 0;
+
+ crc = crc ^ 0xffffffff;
+ while (len >= 8) {
+ crc = crc_table[(crc ^ buf[offset++]) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf[offset++]) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf[offset++]) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf[offset++]) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf[offset++]) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf[offset++]) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf[offset++]) & 0xff] ^ (crc >>> 8)
+ crc = crc_table[(crc ^ buf[offset++]) & 0xff] ^ (crc >>> 8)
+ len -= 8;
+ }
+ if (len) do {
+ crc = crc_table[(crc ^ buf[offset++]) & 0xff] ^ (crc >>> 8)
+ } while (--len);
+ return crc ^ 0xffffffff;
+}
+
+/* ========================================================================= */
+ZLIB.crc32 = function(crc, buf, offset, len)
+{
+ if(typeof buf === 'string') {
+ return crc32_string(crc, buf, offset, len);
+ } else {
+ return crc32_array(crc, buf, offset, len);
+ }
+};
+
+/* ========================================================================= */
+var GF2_DIM = 32; /* dimension of GF(2) vectors (length of CRC) */
+
+/* ========================================================================= */
+function gf2_matrix_times(mat, vec)
+{
+ var sum;
+ var mat_i = 0;
+
+ sum = 0;
+ while (vec) {
+ if (vec & 1)
+ sum ^= mat[mat_i];
+ vec >>= 1;
+ mat_i++;
+ }
+ return sum;
+}
+
+/* ========================================================================= */
+function gf2_matrix_square(square, mat)
+{
+ var n;
+
+ for (n = 0; n < GF2_DIM; n++)
+ square[n] = gf2_matrix_times(mat, mat[n]);
+}
+
+/* ========================================================================= */
+ZLIB.crc32_combine = function(crc1, crc2, len2)
+{
+ var n;
+ var row;
+ var even; /* even-power-of-two zeros operator */
+ var odd; /* odd-power-of-two zeros operator */
+
+ /* degenerate case (also disallow negative lengths) */
+ if (len2 <= 0)
+ return crc1;
+
+ even = new Array(GF2_DIM);
+ odd = new Array(GF2_DIM);
+
+ /* put operator for one zero bit in odd */
+ odd[0] = 0xedb88320; /* CRC-32 polynomial */
+ row = 1;
+ for (n = 1; n < GF2_DIM; n++) {
+ odd[n] = row;
+ row <<= 1;
+ }
+
+ /* put operator for two zero bits in even */
+ gf2_matrix_square(even, odd);
+
+ /* put operator for four zero bits in odd */
+ gf2_matrix_square(odd, even);
+
+ /* apply len2 zeros to crc1 (first square will put the operator for one
+ zero byte, eight zero bits, in even) */
+ do {
+ /* apply zeros operator for this bit of len2 */
+ gf2_matrix_square(even, odd);
+ if (len2 & 1)
+ crc1 = gf2_matrix_times(even, crc1);
+ len2 >>= 1;
+
+ /* if no more bits set, then done */
+ if (len2 == 0)
+ break;
+
+ /* another iteration of the loop with odd and even swapped */
+ gf2_matrix_square(odd, even);
+ if (len2 & 1)
+ crc1 = gf2_matrix_times(odd, crc1);
+ len2 >>= 1;
+
+ /* if no more bits set, then done */
+ } while (len2 != 0);
+
+ /* return combined crc */
+ crc1 ^= crc2;
+ return crc1;
+};
+
+}());
diff --git a/zlib-inflate.js b/zlib-inflate.js
new file mode 100644
index 0000000..bbe6ea2
--- /dev/null
+++ b/zlib-inflate.js
@@ -0,0 +1,1955 @@
+/* zlib-inflate.js -- JavaScript implementation for the zlib inflate.
+ Version: 0.2.0
+ LastModified: Apr 12 2012
+ Copyright (C) 2012 Masanao Izumo
+
+ This library is one of the JavaScript zlib implementation.
+ Some API's are modified from the original.
+ Only inflate API is implemented.
+
+ The original copyright notice (zlib 1.2.6):
+
+ Copyright (C) 1995-2012 Jean-loup Gailly and Mark Adler
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Jean-loup Gailly Mark Adler
+ jloup@gzip.org madler@alumni.caltech.edu
+
+
+ The data format used by the zlib library is described by RFCs (Request for
+ Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
+ (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
+*/
+
+/*
+ API documentation
+==============================================================================
+Usage: z_stream = ZLIB.inflateInit([windowBits]);
+
+ Create the stream object for decompression.
+ See zlib.h for windowBits information.
+
+==============================================================================
+Usage: decoded_string = z_stream.inflate(encoded_string [, {OPTIONS...}]);
+
+OPTIONS:
+ next_in: decode start offset for encoded_string.
+
+ avail_in: // TODO document. See zlib.h for the information.
+
+ avail_out: // TODO document. See zlib.h for the information.
+
+ flush: // TODO document. See zlib.h for the information.
+
+Ex: decoded_string = z_stream.inflate(encoded_string);
+ decoded_string = z_stream.inflate(encoded_string,
+ {next_in: 0,
+ avail_in: encoded_string.length,
+ avail_out: 1024,
+ flush: ZLIB.Z_NO_FLUSH});
+
+ See zlib.h for more information.
+
+==============================================================================
+Usage: z_stream.inflateReset();
+ TODO document
+
+*/
+
+if( typeof ZLIB === 'undefined' ) {
+ alert('ZLIB is not defined. SRC zlib.js before zlib-inflate.js')
+}
+
+(function() {
+
+/* inflate.c -- zlib decompression
+ * Copyright (C) 1995-2011 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+var DEF_WBITS = 15;
+
+// inflate_mode
+var HEAD = 0; /* i: waiting for magic header */
+var FLAGS = 1; /* i: waiting for method and flags (gzip) */
+var TIME = 2; /* i: waiting for modification time (gzip) */
+var OS = 3; /* i: waiting for extra flags and operating system (gzip) */
+var EXLEN = 4; /* i: waiting for extra length (gzip) */
+var EXTRA = 5; /* i: waiting for extra bytes (gzip) */
+var NAME = 6; /* i: waiting for end of file name (gzip) */
+var COMMENT = 7; /* i: waiting for end of comment (gzip) */
+var HCRC = 8; /* i: waiting for header crc (gzip) */
+var DICTID = 9; /* i: waiting for dictionary check value */
+var DICT = 10; /* waiting for inflateSetDictionary() call */
+var TYPE = 11; /* i: waiting for type bits, including last-flag bit */
+var TYPEDO = 12; /* i: same, but skip check to exit inflate on new block */
+var STORED = 13; /* i: waiting for stored size (length and complement) */
+var COPY_ = 14; /* i/o: same as COPY below, but only first time in */
+var COPY = 15; /* i/o: waiting for input or output to copy stored block */
+var TABLE = 16; /* i: waiting for dynamic block table lengths */
+var LENLENS = 17; /* i: waiting for code length code lengths */
+var CODELENS = 18; /* i: waiting for length/lit and distance code lengths */
+var LEN_ = 19; /* i: same as LEN below, but only first time in */
+var LEN = 20; /* i: waiting for length/lit/eob code */
+var LENEXT = 21; /* i: waiting for length extra bits */
+var DIST = 22; /* i: waiting for distance code */
+var DISTEXT = 23; /* i: waiting for distance extra bits */
+var MATCH = 24; /* o: waiting for output space to copy string */
+var LIT = 25; /* o: waiting for output space to write literal */
+var CHECK = 26; /* i: waiting for 32-bit check value */
+var LENGTH = 27; /* i: waiting for 32-bit length (gzip) */
+var DONE = 28; /* finished check, done -- remain here until reset */
+var BAD = 29; /* got a data error -- remain here until reset */
+var MEM = 30; /* got an inflate() memory error -- remain here until reset */
+var SYNC = 31; /* looking for synchronization bytes to restart inflate() */
+
+/* Maximum size of the dynamic table. The maximum number of code structures is
+ 1444, which is the sum of 852 for literal/length codes and 592 for distance
+ codes. These values were found by exhaustive searches using the program
+ examples/enough.c found in the zlib distribtution. The arguments to that
+ program are the number of symbols, the initial root table size, and the
+ maximum bit length of a code. "enough 286 9 15" for literal/length codes
+ returns returns 852, and "enough 30 6 15" for distance codes returns 592.
+ The initial root table size (9 or 6) is found in the fifth argument of the
+ inflate_table() calls in inflate.c and infback.c. If the root table size is
+ changed, then these maximum sizes would be need to be recalculated and
+ updated. */
+var ENOUGH_LENS = 852;
+var ENOUGH_DISTS = 592;
+var ENOUGH = (ENOUGH_LENS + ENOUGH_DISTS);
+
+/* Type of code to build for inflate_table() */
+var CODES = 0;
+var LENS = 1;
+var DISTS = 2;
+
+
+
+var inflate_table_lbase = [ /* Length codes 257..285 base */
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+ 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0];
+var inflate_table_lext = [ /* Length codes 257..285 extra */
+ 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
+ 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 203, 69];
+var inflate_table_dbase = [ /* Distance codes 0..29 base */
+ 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+ 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+ 8193, 12289, 16385, 24577, 0, 0];
+var inflate_table_dext = [ /* Distance codes 0..29 extra */
+ 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
+ 23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
+ 28, 28, 29, 29, 64, 64];
+
+/* inftrees.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2012 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+ZLIB.inflate_copyright =
+ ' inflate 1.2.6 Copyright 1995-2012 Mark Adler ';
+/*
+ If you use the zlib library in a product, an acknowledgment is welcome
+ in the documentation of your product. If for some reason you cannot
+ include such an acknowledgment, I would appreciate that you keep this
+ copyright string in the executable of your product.
+ */
+
+/*
+ Build a set of tables to decode the provided canonical Huffman code.
+ The code lengths are lens[0..codes-1]. The result starts at *table,
+ whose indices are 0..2^bits-1. work is a writable array of at least
+ lens shorts, which is used as a work area. type is the type of code
+ to be generated, CODES, LENS, or DISTS. On return, zero is success,
+ -1 is an invalid code, and +1 means that ENOUGH isn't enough. table
+ on return points to the next available entry's address. bits is the
+ requested root table index bits, and on return it is the actual root
+ table index bits. It will differ if the request is greater than the
+ longest code or if it is less than the shortest code.
+*/
+function inflate_table(state, type)
+{
+ var MAXBITS = 15;
+ var table = state.next;
+ var bits = (type == DISTS ? state.distbits : state.lenbits);
+ var work = state.work;
+ var lens = state.lens;
+ var lens_offset = (type == DISTS ? state.nlen : 0);
+ var state_codes = state.codes;
+ var codes;
+ if(type == LENS)
+ codes = state.nlen;
+ else if(type == DISTS)
+ codes = state.ndist;
+ else // CODES
+ codes = 19;
+
+ var len; /* a code's length in bits */
+ var sym; /* index of code symbols */
+ var min, max; /* minimum and maximum code lengths */
+ var root; /* number of index bits for root table */
+ var curr; /* number of index bits for current table */
+ var drop; /* code bits to drop for sub-table */
+ var left; /* number of prefix codes available */
+ var used; /* code entries in table used */
+ var huff; /* Huffman code */
+ var incr; /* for incrementing code, index */
+ var fill; /* index for replicating entries */
+ var low; /* low bits for current root entry */
+ var mask; /* mask for low root bits */
+ var here; /* table entry for duplication */
+ var next; /* next available space in table */
+ var base; /* base value table to use */
+ var base_offset;
+ var extra; /* extra bits table to use */
+ var extra_offset;
+ var end; /* use base and extra for symbol > end */
+ var count = new Array(MAXBITS+1); /* number of codes of each length */
+ var offs = new Array(MAXBITS+1); /* offsets in table for each length */
+
+ /*
+ Process a set of code lengths to create a canonical Huffman code. The
+ code lengths are lens[0..codes-1]. Each length corresponds to the
+ symbols 0..codes-1. The Huffman code is generated by first sorting the
+ symbols by length from short to long, and retaining the symbol order
+ for codes with equal lengths. Then the code starts with all zero bits
+ for the first code of the shortest length, and the codes are integer
+ increments for the same length, and zeros are appended as the length
+ increases. For the deflate format, these bits are stored backwards
+ from their more natural integer increment ordering, and so when the
+ decoding tables are built in the large loop below, the integer codes
+ are incremented backwards.
+
+ This routine assumes, but does not check, that all of the entries in
+ lens[] are in the range 0..MAXBITS. The caller must assure this.
+ 1..MAXBITS is interpreted as that code length. zero means that that
+ symbol does not occur in this code.
+
+ The codes are sorted by computing a count of codes for each length,
+ creating from that a table of starting indices for each length in the
+ sorted table, and then entering the symbols in order in the sorted
+ table. The sorted table is work[], with that space being provided by
+ the caller.
+
+ The length counts are used for other purposes as well, i.e. finding
+ the minimum and maximum length codes, determining if there are any
+ codes at all, checking for a valid set of lengths, and looking ahead
+ at length counts to determine sub-table sizes when building the
+ decoding tables.
+ */
+
+ /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
+ for (len = 0; len <= MAXBITS; len++)
+ count[len] = 0;
+ for (sym = 0; sym < codes; sym++)
+ count[lens[lens_offset + sym]]++;
+
+ /* bound code lengths, force root to be within code lengths */
+ root = bits;
+
+ for (max = MAXBITS; max >= 1; max--)
+ if (count[max] != 0) break;
+ if (root > max) root = max;
+ if (max == 0) {
+ /* no symbols to code at all */
+ /* invalid code marker */
+ here = {op:64, bits:1, val:0};
+ state_codes[table++] = here; /* make a table to force an error */
+ state_codes[table++] = here;
+ if(type == DISTS) state.distbits = 1; else state.lenbits = 1; // *bits = 1;
+ state.next = table;
+ return 0; /* no symbols, but wait for decoding to report error */
+ }
+ for (min = 1; min < max; min++)
+ if (count[min] != 0) break;
+ if (root < min) root = min;
+
+ /* check for an over-subscribed or incomplete set of lengths */
+ left = 1;
+ for (len = 1; len <= MAXBITS; len++) {
+ left <<= 1;
+ left -= count[len];
+ if (left < 0) return -1; /* over-subscribed */
+ }
+ if (left > 0 && (type == CODES || max != 1)) {
+ state.next = table;
+ return -1; /* incomplete set */
+ }
+
+ /* generate offsets into symbol table for each length for sorting */
+ offs[1] = 0;
+ for (len = 1; len < MAXBITS; len++)
+ offs[len + 1] = offs[len] + count[len];
+
+ /* sort symbols by length, by symbol order within each length */
+ for (sym = 0; sym < codes; sym++)
+ if (lens[lens_offset + sym] != 0) work[offs[lens[lens_offset + sym]]++] = sym;
+
+ /*
+ Create and fill in decoding tables. In this loop, the table being
+ filled is at next and has curr index bits. The code being used is huff
+ with length len. That code is converted to an index by dropping drop
+ bits off of the bottom. For codes where len is less than drop + curr,
+ those top drop + curr - len bits are incremented through all values to
+ fill the table with replicated entries.
+
+ root is the number of index bits for the root table. When len exceeds
+ root, sub-tables are created pointed to by the root entry with an index
+ of the low root bits of huff. This is saved in low to check for when a
+ new sub-table should be started. drop is zero when the root table is
+ being filled, and drop is root when sub-tables are being filled.
+
+ When a new sub-table is needed, it is necessary to look ahead in the
+ code lengths to determine what size sub-table is needed. The length
+ counts are used for this, and so count[] is decremented as codes are
+ entered in the tables.
+
+ used keeps track of how many table entries have been allocated from the
+ provided *table space. It is checked for LENS and DIST tables against
+ the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
+ the initial root table size constants. See the comments in inftrees.h
+ for more information.
+
+ sym increments through all symbols, and the loop terminates when
+ all codes of length max, i.e. all codes, have been processed. This
+ routine permits incomplete codes, so another loop after this one fills
+ in the rest of the decoding tables with invalid code markers.
+ */
+
+ /* set up for code type */
+ switch (type) {
+ case CODES:
+ base = extra = work; /* dummy value--not used */
+ base_offset = 0;
+ extra_offset = 0;
+ end = 19;
+ break;
+ case LENS:
+ base = inflate_table_lbase;
+ base_offset = -257; // base -= 257;
+ extra = inflate_table_lext;
+ extra_offset = -257; // extra -= 257;
+ end = 256;
+ break;
+ default: /* DISTS */
+ base = inflate_table_dbase;
+ extra = inflate_table_dext;
+ base_offset = 0;
+ extra_offset = 0;
+ end = -1;
+ }
+
+ /* initialize state for loop */
+ huff = 0; /* starting code */
+ sym = 0; /* starting code symbol */
+ len = min; /* starting code length */
+ next = table; /* current table to fill in */
+ curr = root; /* current table index bits */
+ drop = 0; /* current bits to drop from code for index */
+ low = -1; /* trigger new sub-table when len > root */
+ used = 1 << root; /* use root table entries */
+ mask = used - 1; /* mask for comparing low */
+
+ /* check available table space */
+ if ((type == LENS && used >= ENOUGH_LENS) ||
+ (type == DISTS && used >= ENOUGH_DISTS)) {
+ state.next = table;
+ return 1;
+ }
+
+ /* process all codes and make table entries */
+ for (;;) {
+ /* create table entry */
+ here = {op:0, bits:len - drop, val:0};
+ if (work[sym] < end) {
+ here.val = work[sym];
+ }
+ else if (work[sym] > end) {
+ here.op = extra[extra_offset + work[sym]];
+ here.val = base[base_offset + work[sym]];
+ }
+ else {
+ here.op = 32 + 64; /* end of block */
+ }
+
+ /* replicate for those indices with low len bits equal to huff */
+ incr = 1 << (len - drop);
+ fill = 1 << curr;
+ min = fill; /* save offset to next table */
+ do {
+ fill -= incr;
+ state_codes[next + (huff >>> drop) + fill] = here;
+ } while (fill != 0);
+
+ /* backwards increment the len-bit code huff */
+ incr = 1 << (len - 1);
+ while (huff & incr)
+ incr >>>= 1;
+ if (incr != 0) {
+ huff &= incr - 1;
+ huff += incr;
+ }
+ else
+ huff = 0;
+
+ /* go to next symbol, update count, len */
+ sym++;
+ if (--(count[len]) == 0) {
+ if (len == max) break;
+ len = lens[lens_offset + work[sym]];
+ }
+
+ /* create new sub-table if needed */
+ if (len > root && (huff & mask) != low) {
+ /* if first time, transition to sub-tables */
+ if (drop == 0)
+ drop = root;
+
+ /* increment past last table */
+ next += min; /* here min is 1 << curr */
+
+ /* determine length of next table */
+ curr = len - drop;
+ left = (1 << curr);
+ while (curr + drop < max) {
+ left -= count[curr + drop];
+ if (left <= 0) break;
+ curr++;
+ left <<= 1;
+ }
+
+ /* check for enough space */
+ used += 1 << curr;
+ if ((type == LENS && used >= ENOUGH_LENS) ||
+ (type == DISTS && used >= ENOUGH_DISTS)) {
+ state.next = table;
+ return 1;
+ }
+
+ /* point entry in root table to sub-table */
+ low = huff & mask;
+ state_codes[table + low] = {op:curr, bits:root, val:next - table};
+ }
+ }
+
+ /* fill in remaining table entry if code is incomplete (guaranteed to have
+ at most one remaining entry, since if the code is incomplete, the
+ maximum code length that was allowed to get this far is one bit) */
+ if (huff != 0) {
+ state_codes[next + huff] = {op:64, bits:len - drop, val:0};
+ }
+
+ /* set return parameters */
+ state.next = table + used;
+ if(type == DISTS) state.distbits = root; else state.lenbits = root; //*bits = root;
+ return 0;
+}
+
+/* inffast.c -- fast decoding
+ * Copyright (C) 1995-2008, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ Decode literal, length, and distance codes and write out the resulting
+ literal and match bytes until either not enough input or output is
+ available, an end-of-block is encountered, or a data error is encountered.
+ When large enough input and output buffers are supplied to inflate(), for
+ example, a 16K input buffer and a 64K output buffer, more than 95% of the
+ inflate execution time is spent in this routine.
+
+ Entry assumptions:
+
+ state->mode == LEN
+ strm->avail_in >= 6
+ strm->avail_out >= 258
+ start >= strm->avail_out
+ state->bits < 8
+
+ On return, state->mode is one of:
+
+ LEN -- ran out of enough output space or enough available input
+ TYPE -- reached end of block code, inflate() to interpret next block
+ BAD -- error in block data
+
+ Notes:
+
+ - The maximum input bits used by a length/distance pair is 15 bits for the
+ length code, 5 bits for the length extra, 15 bits for the distance code,
+ and 13 bits for the distance extra. This totals 48 bits, or six bytes.
+ Therefore if strm->avail_in >= 6, then there is enough input to avoid
+ checking for available input while decoding.
+
+ - The maximum bytes that a single length/distance pair can output is 258
+ bytes, which is the maximum length that can be coded. inflate_fast()
+ requires strm->avail_out >= 258 for each loop to avoid checking for
+ output space.
+ */
+function inflate_fast(strm,
+ start) /* inflate()'s starting value for strm->avail_out */
+{
+ var state;
+ var input_data; /* local strm->input_data */
+ var next_in; /* zlib.js: index of input_data */
+ var last; /* while next_in < last, enough input available */
+ var out; /* local strm.next_out */
+ var beg; /* inflate()'s initial strm.next_out */
+ var end; /* while out < end, enough space available */
+//NOSPRT #ifdef INFLATE_STRICT
+// unsigned dmax; /* maximum distance from zlib header */
+//#endif
+ var wsize; /* window size or zero if not using window */
+ var whave; /* valid bytes in the window */
+ var wnext; /* window write index */
+ var window; /* allocated sliding window, if wsize != 0 */
+ var hold; /* local strm->hold */
+ var bits; /* local strm->bits */
+ var codes; /* zlib.js: local state.codes */
+ var lcode; /* local strm->lencode */
+ var dcode; /* local strm->distcode */
+ var lmask; /* mask for first level of length codes */
+ var dmask; /* mask for first level of distance codes */
+ var here; /* retrieved table entry */
+ var op; /* code bits, operation, extra bits, or */
+ /* window position, window bytes to copy */
+ var len; /* match length, unused bytes */
+ var dist; /* match distance */
+ // var from; /* where to copy match from */
+ var from_window_offset = -1; /* index of window[] */
+ var from_out_offset = -1; /* index of next_out[] */
+
+ /* copy state to local variables */
+ state = strm.state;
+ input_data = strm.input_data;
+ next_in = strm.next_in;
+ last = next_in + strm.avail_in - 5;
+ out = strm.next_out;
+ beg = out - (start - strm.avail_out);
+ end = out + (strm.avail_out - 257);
+//NOSPRT #ifdef INFLATE_STRICT
+// dmax = state->dmax;
+//#endif
+ wsize = state.wsize;
+ whave = state.whave;
+ wnext = state.wnext;
+ window = state.window;
+ hold = state.hold;
+ bits = state.bits;
+ codes = state.codes;
+ lcode = state.lencode;
+ dcode = state.distcode;
+ lmask = (1 << state.lenbits) - 1;
+ dmask = (1 << state.distbits) - 1;
+
+ /* decode literals and length/distances until end-of-block or not enough
+ input data or output space */
+loop: do {
+ if (bits < 15) {
+ hold += (input_data.charCodeAt(next_in++) & 0xff) << bits;
+ bits += 8;
+ hold += (input_data.charCodeAt(next_in++) & 0xff) << bits;
+ bits += 8;
+ }
+ here = codes[lcode + (hold & lmask)];
+ dolen: while(true) {
+ op = here.bits;
+ hold >>>= op;
+ bits -= op;
+ op = here.op;
+ if (op == 0) { /* literal */
+// Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
+// "inflate: literal '%c'\n" :
+// "inflate: literal 0x%02x\n", here.val));
+ strm.output_data += String.fromCharCode(here.val);
+ out++;
+ }
+ else if (op & 16) { /* length base */
+ len = here.val;
+ op &= 15; /* number of extra bits */
+ if (op) {
+ if (bits < op) {
+ hold += (input_data.charCodeAt(next_in++) & 0xff) << bits;
+ bits += 8;
+ }
+ len += hold & ((1 << op) - 1);
+ hold >>>= op;
+ bits -= op;
+ }
+// Tracevv((stderr, "inflate: length %u\n", len));
+ if (bits < 15) {
+ hold += (input_data.charCodeAt(next_in++) & 0xff) << bits;
+ bits += 8;
+ hold += (input_data.charCodeAt(next_in++) & 0xff) << bits;
+ bits += 8;
+ }
+ here = codes[dcode + (hold & dmask)];
+ dodist: while(true) {
+ op = here.bits;
+ hold >>>= op;
+ bits -= op;
+ op = here.op;
+ if (op & 16) { /* distance base */
+ dist = here.val;
+ op &= 15; /* number of extra bits */
+ if (bits < op) {
+ hold += (input_data.charCodeAt(next_in++) & 0xff) << bits;
+ bits += 8;
+ if (bits < op) {
+ hold += (input_data.charCodeAt(next_in++) & 0xff) << bits;
+ bits += 8;
+ }
+ }
+ dist += hold & ((1 << op) - 1);
+//NOSPRT #ifdef INFLATE_STRICT
+// if (dist > dmax) {
+// strm->msg = (char *)"invalid distance too far back";
+// state->mode = BAD;
+// break loop;
+// }
+//#endif
+ hold >>>= op;
+ bits -= op;
+// Tracevv((stderr, "inflate: distance %u\n", dist));
+ op = out - beg; /* max distance in output */
+ if (dist > op) { /* see if copy from window */
+ op = dist - op; /* distance back in window */
+ if (op > whave) {
+ if (state.sane) {
+ strm.msg = 'invalid distance too far back';
+ state.mode = BAD;
+ break loop;
+ }
+//NOSPRT #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+// if (len <= op - whave) {
+// do {
+// PUP(out) = 0;
+// } while (--len);
+// continue;
+// }
+// len -= op - whave;
+// do {
+// PUP(out) = 0;
+// } while (--op > whave);
+// if (op == 0) {
+// from = out - dist;
+// do {
+// PUP(out) = PUP(from);
+// } while (--len);
+// continue;
+// }
+//#endif
+ } // if (op > whave)
+
+ from_window_offset = 0;
+ from_out_offset = -1;
+ if (wnext == 0) { /* very common case */
+ from_window_offset += wsize - op;
+ if (op < len) { /* some from window */
+ len -= op;
+ strm.output_data += window.substring(from_window_offset, from_window_offset + op);
+ out += op;
+ op = 0;
+ from_window_offset = -1;
+ from_out_offset = out - dist; /* rest from output */
+ }
+ }
+//NOTREACHED else if (wnext < op) { /* wrap around window */
+//NOTREACHED from += wsize + wnext - op;
+//NOTREACHED op -= wnext;
+//NOTREACHED if (op < len) { /* some from end of window */
+//NOTREACHED len -= op;
+//NOTREACHED do {
+//NOTREACHED PUP(out) = PUP(from);
+//NOTREACHED } while (--op);
+//NOTREACHED from = window - OFF;
+//NOTREACHED if (wnext < len) { /* some from start of window */
+//NOTREACHED op = wnext;
+//NOTREACHED len -= op;
+//NOTREACHED do {
+//NOTREACHED PUP(out) = PUP(from);
+//NOTREACHED } while (--op);
+//NOTREACHED from = out - dist; /* rest from output */
+//NOTREACHED }
+//NOTREACHED }
+//NOTREACHED }
+ else { /* contiguous in window */
+ from_window_offset += wnext - op;
+ if (op < len) { /* some from window */
+ len -= op;
+ strm.output_data += window.substring(from_window_offset, from_window_offset + op);
+ out += op;
+ from_window_offset = -1;
+ from_out_offset = out - dist; /* rest from output */
+ }
+ }
+ }
+ else {
+ from_window_offset = -1;
+ from_out_offset = out - dist; /* copy direct from output */
+ }
+
+ if (from_window_offset >= 0) {
+ strm.output_data += window.substring(from_window_offset, from_window_offset + len);
+ out += len;
+ from_window_offset += len;
+ } else {
+ var len_inner = len;
+ if(len_inner > out - from_out_offset)
+ len_inner = out - from_out_offset;
+ strm.output_data += strm.output_data.substring(
+ from_out_offset, from_out_offset + len_inner);
+ out += len_inner;
+ len -= len_inner;
+ from_out_offset += len_inner;
+ out += len;
+ while (len > 2) {
+ strm.output_data += strm.output_data.charAt(from_out_offset++);
+ strm.output_data += strm.output_data.charAt(from_out_offset++);
+ strm.output_data += strm.output_data.charAt(from_out_offset++);
+ len -= 3;
+ }
+ if (len) {
+ strm.output_data += strm.output_data.charAt(from_out_offset++);
+ if (len > 1)
+ strm.output_data += strm.output_data.charAt(from_out_offset++);
+ }
+ }
+ }
+ else if ((op & 64) == 0) { /* 2nd level distance code */
+ here = codes[dcode + (here.val + (hold & ((1 << op) - 1)))];
+ continue dodist; // goto dodist
+ }
+ else {
+ strm.msg = 'invalid distance code';
+ state.mode = BAD;
+ break loop;
+ }
+ break dodist; }
+ }
+ else if ((op & 64) == 0) { /* 2nd level length code */
+ here = codes[lcode + (here.val + (hold & ((1 << op) - 1)))];
+ continue dolen; // goto dolen;
+ }
+ else if (op & 32) { /* end-of-block */
+ // Tracevv((stderr, "inflate: end of block\n"));
+ state.mode = TYPE;
+ break loop;
+ }
+ else {
+ strm.msg = 'invalid literal/length code';
+ state.mode = BAD;
+ break loop;
+ }
+ break dolen; }
+ } while (next_in < last && out < end);
+
+ /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
+ len = bits >>> 3;
+ next_in -= len;
+ bits -= len << 3;
+ hold &= (1 << bits) - 1;
+
+ /* update state and return */
+ strm.next_in = next_in;
+ strm.next_out = out;
+ strm.avail_in = (next_in < last ? 5 + (last - next_in) : 5 - (next_in - last));
+ strm.avail_out = (out < end ?
+ 257 + (end - out) : 257 - (out - end));
+ state.hold = hold;
+ state.bits = bits;
+}
+
+function new_array(size)
+{
+ var i;
+ var ary = new Array(size);
+ for(i = 0; i < size; i++)
+ ary[i] = 0;
+ return ary;
+}
+
+function getarg(opts, name, def_value)
+{
+ return (opts && (name in opts)) ? opts[name] : def_value;
+}
+
+function checksum_none()
+{
+ return 0;
+}
+
+/**
+ * z_stream constructor
+ * @constructor
+ */
+function inflate_state()
+{
+ var i;
+
+ this.mode = 0; /* current inflate mode */
+ this.last = 0; /* true if processing last block */
+ this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */
+ this.havedict = 0; /* true if dictionary provided */
+ this.flags = 0; /* gzip header method and flags (0 if zlib) */
+ this.dmax = 0; /* zlib header max distance (INFLATE_STRICT) */
+ this.check = 0; /* protected copy of check value */
+ this.total = 0; /* protected copy of output count */
+ this.head = null; /* where to save gzip header information */
+ /* sliding window */
+ this.wbits = 0; /* log base 2 of requested window size */
+ this.wsize = 0; /* window size or zero if not using window */
+ this.whave = 0; /* valid bytes in the window */
+ this.wnext = 0; /* window write index (TODO remove) */
+ this.window = null; /* allocated sliding window, if needed */
+ /* bit accumulator */
+ this.hold = 0; /* input bit accumulator */
+ this.bits = 0; /* number of bits in "in" */
+ /* for string and stored block copying */
+ this.length = 0; /* literal or length of data to copy */
+ this.offset = 0; /* distance back to copy string from */
+ /* for table and code decoding */
+ this.extra = 0; /* extra bits needed */
+ /* fixed and dynamic code tables */
+
+ /* zlib.js: modified implementation: lencode, distcode, next are offset of codes[] */
+ this.lencode = 0; /* starting table for length/literal codes */
+ this.distcode = 0; /* starting table for distance codes */
+ this.lenbits = 0; /* index bits for lencode */
+ this.distbits = 0; /* index bits for distcode */
+ /* dynamic table building */
+ this.ncode = 0; /* number of code length code lengths */
+ this.nlen = 0; /* number of length code lengths */
+ this.ndist = 0; /* number of distance code lengths */
+ this.have = 0; /* number of code lengths in lens[] */
+ this.next = 0; /* next available space in codes[] */
+ this.lens = new_array(320); /* temporary storage for code lengths */
+ this.work = new_array(288); /* work area for code table building */
+ this.codes = new Array(ENOUGH); /* space for code tables */
+ var c = {op:0, bits:0, val:0};
+ for(i = 0; i < ENOUGH; i++)
+ this.codes[i] = c;
+ this.sane = 0; /* if false, allow invalid distance too far */
+ this.back = 0; /* bits back of last unprocessed length/lit */
+ this.was = 0; /* initial length of match */
+}
+
+ZLIB.inflateResetKeep = function(strm)
+{
+ var state;
+
+ if (!strm || !strm.state) return ZLIB.Z_STREAM_ERROR;
+ state = strm.state;
+ strm.total_in = strm.total_out = state.total = 0;
+ strm.msg = null;
+ if (state.wrap) { /* to support ill-conceived Java test suite */
+ strm.adler = state.wrap & 1;
+ }
+
+ state.mode = HEAD;
+ state.last = 0;
+ state.havedict = 0;
+ state.dmax = 32768;
+ state.head = null;
+ state.hold = 0;
+ state.bits = 0;
+ state.lencode = 0;
+ state.distcode = 0;
+ state.next = 0;
+ state.sane = 1;
+ state.back = -1;
+ return ZLIB.Z_OK;
+};
+
+// Usage: strm = ZLIB.inflateReset(z_stream [, windowBits]);
+ZLIB.inflateReset = function(strm, windowBits)
+{
+ var wrap;
+ var state;
+
+ /* get the state */
+ if (!strm || !strm.state) return ZLIB.Z_STREAM_ERROR;
+ state = strm.state;
+
+ if(typeof windowBits === "undefined")
+ windowBits = DEF_WBITS;
+
+ /* extract wrap request from windowBits parameter */
+ if (windowBits < 0) {
+ wrap = 0;
+ windowBits = -windowBits;
+ }
+ else {
+ wrap = (windowBits >>> 4) + 1;
+ if (windowBits < 48)
+ windowBits &= 15;
+ }
+
+ if(wrap == 1 && (typeof ZLIB.adler32 === 'function')) {
+ strm.checksum_function = ZLIB.adler32;
+ } else if(wrap == 2 && (typeof ZLIB.crc32 === 'function')) {
+ strm.checksum_function = ZLIB.crc32;
+ } else {
+ strm.checksum_function = checksum_none;
+ }
+
+ /* set number of window bits, free window if different */
+ if (windowBits && (windowBits < 8 || windowBits > 15))
+ return ZLIB.Z_STREAM_ERROR;
+ if (state.window && state.wbits != windowBits) {
+ state.window = null;
+ }
+
+ /* update state and reset the rest of it */
+ state.wrap = wrap;
+ state.wbits = windowBits;
+ state.wsize = 0;
+ state.whave = 0;
+ state.wnext = 0;
+ return ZLIB.inflateResetKeep(strm);
+};
+
+// Usage: strm = ZLIB.inflateInit([windowBits]);
+ZLIB.inflateInit = function(windowBits)
+{
+ var strm = new ZLIB.z_stream();
+ strm.state = new inflate_state();
+ ZLIB.inflateReset(strm, windowBits);
+ return strm;
+};
+
+ZLIB.inflatePrime = function(strm, bits, value)
+{
+ var state;
+
+ if (!strm || !strm.state) return ZLIB.Z_STREAM_ERROR;
+ state = strm.state;
+ if (bits < 0) {
+ state.hold = 0;
+ state.bits = 0;
+ return ZLIB.Z_OK;
+ }
+ if (bits > 16 || state.bits + bits > 32) return ZLIB.Z_STREAM_ERROR;
+ value &= (1 << bits) - 1;
+ state.hold += value << state.bits;
+ state.bits += bits;
+ return ZLIB.Z_OK;
+};
+
+var lenfix_ary = null;
+var distfix_ary = null;
+
+function fixedtables(state)
+{
+ var i;
+ if (!lenfix_ary) lenfix_ary = [{ op: 96, bits: 7, val: 0 }, { op: 0, bits: 8, val: 80 }, { op: 0, bits: 8, val: 16 }, { op: 20, bits: 8, val: 115 }, { op: 18, bits: 7, val: 31 }, { op: 0, bits: 8, val: 112 }, { op: 0, bits: 8, val: 48 }, { op: 0, bits: 9, val: 192 }, { op: 16, bits: 7, val: 10 }, { op: 0, bits: 8, val: 96 }, { op: 0, bits: 8, val: 32 }, { op: 0, bits: 9, val: 160 }, { op: 0, bits: 8, val: 0 }, { op: 0, bits: 8, val: 128 }, { op: 0, bits: 8, val: 64 }, { op: 0, bits: 9, val: 224 }, { op: 16, bits: 7, val: 6 }, { op: 0, bits: 8, val: 88 }, { op: 0, bits: 8, val: 24 }, { op: 0, bits: 9, val: 144 }, { op: 19, bits: 7, val: 59 }, { op: 0, bits: 8, val: 120 }, { op: 0, bits: 8, val: 56 }, { op: 0, bits: 9, val: 208 }, { op: 17, bits: 7, val: 17 }, { op: 0, bits: 8, val: 104 }, { op: 0, bits: 8, val: 40 }, { op: 0, bits: 9, val: 176 }, { op: 0, bits: 8, val: 8 }, { op: 0, bits: 8, val: 136 }, { op: 0, bits: 8, val: 72 }, { op: 0, bits: 9, val: 240 }, { op: 16, bits: 7, val: 4 }, { op: 0, bits: 8, val: 84 }, { op: 0, bits: 8, val: 20 }, { op: 21, bits: 8, val: 227 }, { op: 19, bits: 7, val: 43 }, { op: 0, bits: 8, val: 116 }, { op: 0, bits: 8, val: 52 }, { op: 0, bits: 9, val: 200 }, { op: 17, bits: 7, val: 13 }, { op: 0, bits: 8, val: 100 }, { op: 0, bits: 8, val: 36 }, { op: 0, bits: 9, val: 168 }, { op: 0, bits: 8, val: 4 }, { op: 0, bits: 8, val: 132 }, { op: 0, bits: 8, val: 68 }, { op: 0, bits: 9, val: 232 }, { op: 16, bits: 7, val: 8 }, { op: 0, bits: 8, val: 92 }, { op: 0, bits: 8, val: 28 }, { op: 0, bits: 9, val: 152 }, { op: 20, bits: 7, val: 83 }, { op: 0, bits: 8, val: 124 }, { op: 0, bits: 8, val: 60 }, { op: 0, bits: 9, val: 216 }, { op: 18, bits: 7, val: 23 }, { op: 0, bits: 8, val: 108 }, { op: 0, bits: 8, val: 44 }, { op: 0, bits: 9, val: 184 }, { op: 0, bits: 8, val: 12 }, { op: 0, bits: 8, val: 140 }, { op: 0, bits: 8, val: 76 }, { op: 0, bits: 9, val: 248 }, { op: 16, bits: 7, val: 3 }, { op: 0, bits: 8, val: 82 }, { op: 0, bits: 8, val: 18 }, { op: 21, bits: 8, val: 163 }, { op: 19, bits: 7, val: 35 }, { op: 0, bits: 8, val: 114 }, { op: 0, bits: 8, val: 50 }, { op: 0, bits: 9, val: 196 }, { op: 17, bits: 7, val: 11 }, { op: 0, bits: 8, val: 98 }, { op: 0, bits: 8, val: 34 }, { op: 0, bits: 9, val: 164 }, { op: 0, bits: 8, val: 2 }, { op: 0, bits: 8, val: 130 }, { op: 0, bits: 8, val: 66 }, { op: 0, bits: 9, val: 228 }, { op: 16, bits: 7, val: 7 }, { op: 0, bits: 8, val: 90 }, { op: 0, bits: 8, val: 26 }, { op: 0, bits: 9, val: 148 }, { op: 20, bits: 7, val: 67 }, { op: 0, bits: 8, val: 122 }, { op: 0, bits: 8, val: 58 }, { op: 0, bits: 9, val: 212 }, { op: 18, bits: 7, val: 19 }, { op: 0, bits: 8, val: 106 }, { op: 0, bits: 8, val: 42 }, { op: 0, bits: 9, val: 180 }, { op: 0, bits: 8, val: 10 }, { op: 0, bits: 8, val: 138 }, { op: 0, bits: 8, val: 74 }, { op: 0, bits: 9, val: 244 }, { op: 16, bits: 7, val: 5 }, { op: 0, bits: 8, val: 86 }, { op: 0, bits: 8, val: 22 }, { op: 64, bits: 8, val: 0 }, { op: 19, bits: 7, val: 51 }, { op: 0, bits: 8, val: 118 }, { op: 0, bits: 8, val: 54 }, { op: 0, bits: 9, val: 204 }, { op: 17, bits: 7, val: 15 }, { op: 0, bits: 8, val: 102 }, { op: 0, bits: 8, val: 38 }, { op: 0, bits: 9, val: 172 }, { op: 0, bits: 8, val: 6 }, { op: 0, bits: 8, val: 134 }, { op: 0, bits: 8, val: 70 }, { op: 0, bits: 9, val: 236 }, { op: 16, bits: 7, val: 9 }, { op: 0, bits: 8, val: 94 }, { op: 0, bits: 8, val: 30 }, { op: 0, bits: 9, val: 156 }, { op: 20, bits: 7, val: 99 }, { op: 0, bits: 8, val: 126 }, { op: 0, bits: 8, val: 62 }, { op: 0, bits: 9, val: 220 }, { op: 18, bits: 7, val: 27 }, { op: 0, bits: 8, val: 110 }, { op: 0, bits: 8, val: 46 }, { op: 0, bits: 9, val: 188 }, { op: 0, bits: 8, val: 14 }, { op: 0, bits: 8, val: 142 }, { op: 0, bits: 8, val: 78 }, { op: 0, bits: 9, val: 252 }, { op: 96, bits: 7, val: 0 }, { op: 0, bits: 8, val: 81 }, { op: 0, bits: 8, val: 17 }, { op: 21, bits: 8, val: 131 }, { op: 18, bits: 7, val: 31 }, { op: 0, bits: 8, val: 113 }, { op: 0, bits: 8, val: 49 }, { op: 0, bits: 9, val: 194 }, { op: 16, bits: 7, val: 10 }, { op: 0, bits: 8, val: 97 }, { op: 0, bits: 8, val: 33 }, { op: 0, bits: 9, val: 162 }, { op: 0, bits: 8, val: 1 }, { op: 0, bits: 8, val: 129 }, { op: 0, bits: 8, val: 65 }, { op: 0, bits: 9, val: 226 }, { op: 16, bits: 7, val: 6 }, { op: 0, bits: 8, val: 89 }, { op: 0, bits: 8, val: 25 }, { op: 0, bits: 9, val: 146 }, { op: 19, bits: 7, val: 59 }, { op: 0, bits: 8, val: 121 }, { op: 0, bits: 8, val: 57 }, { op: 0, bits: 9, val: 210 }, { op: 17, bits: 7, val: 17 }, { op: 0, bits: 8, val: 105 }, { op: 0, bits: 8, val: 41 }, { op: 0, bits: 9, val: 178 }, { op: 0, bits: 8, val: 9 }, { op: 0, bits: 8, val: 137 }, { op: 0, bits: 8, val: 73 }, { op: 0, bits: 9, val: 242 }, { op: 16, bits: 7, val: 4 }, { op: 0, bits: 8, val: 85 }, { op: 0, bits: 8, val: 21 }, { op: 16, bits: 8, val: 258 }, { op: 19, bits: 7, val: 43 }, { op: 0, bits: 8, val: 117 }, { op: 0, bits: 8, val: 53 }, { op: 0, bits: 9, val: 202 }, { op: 17, bits: 7, val: 13 }, { op: 0, bits: 8, val: 101 }, { op: 0, bits: 8, val: 37 }, { op: 0, bits: 9, val: 170 }, { op: 0, bits: 8, val: 5 }, { op: 0, bits: 8, val: 133 }, { op: 0, bits: 8, val: 69 }, { op: 0, bits: 9, val: 234 }, { op: 16, bits: 7, val: 8 }, { op: 0, bits: 8, val: 93 }, { op: 0, bits: 8, val: 29 }, { op: 0, bits: 9, val: 154 }, { op: 20, bits: 7, val: 83 }, { op: 0, bits: 8, val: 125 }, { op: 0, bits: 8, val: 61 }, { op: 0, bits: 9, val: 218 }, { op: 18, bits: 7, val: 23 }, { op: 0, bits: 8, val: 109 }, { op: 0, bits: 8, val: 45 }, { op: 0, bits: 9, val: 186 }, { op: 0, bits: 8, val: 13 }, { op: 0, bits: 8, val: 141 }, { op: 0, bits: 8, val: 77 }, { op: 0, bits: 9, val: 250 }, { op: 16, bits: 7, val: 3 }, { op: 0, bits: 8, val: 83 }, { op: 0, bits: 8, val: 19 }, { op: 21, bits: 8, val: 195 }, { op: 19, bits: 7, val: 35 }, { op: 0, bits: 8, val: 115 }, { op: 0, bits: 8, val: 51 }, { op: 0, bits: 9, val: 198 }, { op: 17, bits: 7, val: 11 }, { op: 0, bits: 8, val: 99 }, { op: 0, bits: 8, val: 35 }, { op: 0, bits: 9, val: 166 }, { op: 0, bits: 8, val: 3 }, { op: 0, bits: 8, val: 131 }, { op: 0, bits: 8, val: 67 }, { op: 0, bits: 9, val: 230 }, { op: 16, bits: 7, val: 7 }, { op: 0, bits: 8, val: 91 }, { op: 0, bits: 8, val: 27 }, { op: 0, bits: 9, val: 150 }, { op: 20, bits: 7, val: 67 }, { op: 0, bits: 8, val: 123 }, { op: 0, bits: 8, val: 59 }, { op: 0, bits: 9, val: 214 }, { op: 18, bits: 7, val: 19 }, { op: 0, bits: 8, val: 107 }, { op: 0, bits: 8, val: 43 }, { op: 0, bits: 9, val: 182 }, { op: 0, bits: 8, val: 11 }, { op: 0, bits: 8, val: 139 }, { op: 0, bits: 8, val: 75 }, { op: 0, bits: 9, val: 246 }, { op: 16, bits: 7, val: 5 }, { op: 0, bits: 8, val: 87 }, { op: 0, bits: 8, val: 23 }, { op: 64, bits: 8, val: 0 }, { op: 19, bits: 7, val: 51 }, { op: 0, bits: 8, val: 119 }, { op: 0, bits: 8, val: 55 }, { op: 0, bits: 9, val: 206 }, { op: 17, bits: 7, val: 15 }, { op: 0, bits: 8, val: 103 }, { op: 0, bits: 8, val: 39 }, { op: 0, bits: 9, val: 174 }, { op: 0, bits: 8, val: 7 }, { op: 0, bits: 8, val: 135 }, { op: 0, bits: 8, val: 71 }, { op: 0, bits: 9, val: 238 }, { op: 16, bits: 7, val: 9 }, { op: 0, bits: 8, val: 95 }, { op: 0, bits: 8, val: 31 }, { op: 0, bits: 9, val: 158 }, { op: 20, bits: 7, val: 99 }, { op: 0, bits: 8, val: 127 }, { op: 0, bits: 8, val: 63 }, { op: 0, bits: 9, val: 222 }, { op: 18, bits: 7, val: 27 }, { op: 0, bits: 8, val: 111 }, { op: 0, bits: 8, val: 47 }, { op: 0, bits: 9, val: 190 }, { op: 0, bits: 8, val: 15 }, { op: 0, bits: 8, val: 143 }, { op: 0, bits: 8, val: 79 }, { op: 0, bits: 9, val: 254 }, { op: 96, bits: 7, val: 0 }, { op: 0, bits: 8, val: 80 }, { op: 0, bits: 8, val: 16 }, { op: 20, bits: 8, val: 115 }, { op: 18, bits: 7, val: 31 }, { op: 0, bits: 8, val: 112 }, { op: 0, bits: 8, val: 48 }, { op: 0, bits: 9, val: 193 }, { op: 16, bits: 7, val: 10 }, { op: 0, bits: 8, val: 96 }, { op: 0, bits: 8, val: 32 }, { op: 0, bits: 9, val: 161 }, { op: 0, bits: 8, val: 0 }, { op: 0, bits: 8, val: 128 }, { op: 0, bits: 8, val: 64 }, { op: 0, bits: 9, val: 225 }, { op: 16, bits: 7, val: 6 }, { op: 0, bits: 8, val: 88 }, { op: 0, bits: 8, val: 24 }, { op: 0, bits: 9, val: 145 }, { op: 19, bits: 7, val: 59 }, { op: 0, bits: 8, val: 120 }, { op: 0, bits: 8, val: 56 }, { op: 0, bits: 9, val: 209 }, { op: 17, bits: 7, val: 17 }, { op: 0, bits: 8, val: 104 }, { op: 0, bits: 8, val: 40 }, { op: 0, bits: 9, val: 177 }, { op: 0, bits: 8, val: 8 }, { op: 0, bits: 8, val: 136 }, { op: 0, bits: 8, val: 72 }, { op: 0, bits: 9, val: 241 }, { op: 16, bits: 7, val: 4 }, { op: 0, bits: 8, val: 84 }, { op: 0, bits: 8, val: 20 }, { op: 21, bits: 8, val: 227 }, { op: 19, bits: 7, val: 43 }, { op: 0, bits: 8, val: 116 }, { op: 0, bits: 8, val: 52 }, { op: 0, bits: 9, val: 201 }, { op: 17, bits: 7, val: 13 }, { op: 0, bits: 8, val: 100 }, { op: 0, bits: 8, val: 36 }, { op: 0, bits: 9, val: 169 }, { op: 0, bits: 8, val: 4 }, { op: 0, bits: 8, val: 132 }, { op: 0, bits: 8, val: 68 }, { op: 0, bits: 9, val: 233 }, { op: 16, bits: 7, val: 8 }, { op: 0, bits: 8, val: 92 }, { op: 0, bits: 8, val: 28 }, { op: 0, bits: 9, val: 153 }, { op: 20, bits: 7, val: 83 }, { op: 0, bits: 8, val: 124 }, { op: 0, bits: 8, val: 60 }, { op: 0, bits: 9, val: 217 }, { op: 18, bits: 7, val: 23 }, { op: 0, bits: 8, val: 108 }, { op: 0, bits: 8, val: 44 }, { op: 0, bits: 9, val: 185 }, { op: 0, bits: 8, val: 12 }, { op: 0, bits: 8, val: 140 }, { op: 0, bits: 8, val: 76 }, { op: 0, bits: 9, val: 249 }, { op: 16, bits: 7, val: 3 }, { op: 0, bits: 8, val: 82 }, { op: 0, bits: 8, val: 18 }, { op: 21, bits: 8, val: 163 }, { op: 19, bits: 7, val: 35 }, { op: 0, bits: 8, val: 114 }, { op: 0, bits: 8, val: 50 }, { op: 0, bits: 9, val: 197 }, { op: 17, bits: 7, val: 11 }, { op: 0, bits: 8, val: 98 }, { op: 0, bits: 8, val: 34 }, { op: 0, bits: 9, val: 165 }, { op: 0, bits: 8, val: 2 }, { op: 0, bits: 8, val: 130 }, { op: 0, bits: 8, val: 66 }, { op: 0, bits: 9, val: 229 }, { op: 16, bits: 7, val: 7 }, { op: 0, bits: 8, val: 90 }, { op: 0, bits: 8, val: 26 }, { op: 0, bits: 9, val: 149 }, { op: 20, bits: 7, val: 67 }, { op: 0, bits: 8, val: 122 }, { op: 0, bits: 8, val: 58 }, { op: 0, bits: 9, val: 213 }, { op: 18, bits: 7, val: 19 }, { op: 0, bits: 8, val: 106 }, { op: 0, bits: 8, val: 42 }, { op: 0, bits: 9, val: 181 }, { op: 0, bits: 8, val: 10 }, { op: 0, bits: 8, val: 138 }, { op: 0, bits: 8, val: 74 }, { op: 0, bits: 9, val: 245 }, { op: 16, bits: 7, val: 5 }, { op: 0, bits: 8, val: 86 }, { op: 0, bits: 8, val: 22 }, { op: 64, bits: 8, val: 0 }, { op: 19, bits: 7, val: 51 }, { op: 0, bits: 8, val: 118 }, { op: 0, bits: 8, val: 54 }, { op: 0, bits: 9, val: 205 }, { op: 17, bits: 7, val: 15 }, { op: 0, bits: 8, val: 102 }, { op: 0, bits: 8, val: 38 }, { op: 0, bits: 9, val: 173 }, { op: 0, bits: 8, val: 6 }, { op: 0, bits: 8, val: 134 }, { op: 0, bits: 8, val: 70 }, { op: 0, bits: 9, val: 237 }, { op: 16, bits: 7, val: 9 }, { op: 0, bits: 8, val: 94 }, { op: 0, bits: 8, val: 30 }, { op: 0, bits: 9, val: 157 }, { op: 20, bits: 7, val: 99 }, { op: 0, bits: 8, val: 126 }, { op: 0, bits: 8, val: 62 }, { op: 0, bits: 9, val: 221 }, { op: 18, bits: 7, val: 27 }, { op: 0, bits: 8, val: 110 }, { op: 0, bits: 8, val: 46 }, { op: 0, bits: 9, val: 189 }, { op: 0, bits: 8, val: 14 }, { op: 0, bits: 8, val: 142 }, { op: 0, bits: 8, val: 78 }, { op: 0, bits: 9, val: 253 }, { op: 96, bits: 7, val: 0 }, { op: 0, bits: 8, val: 81 }, { op: 0, bits: 8, val: 17 }, { op: 21, bits: 8, val: 131 }, { op: 18, bits: 7, val: 31 }, { op: 0, bits: 8, val: 113 }, { op: 0, bits: 8, val: 49 }, { op: 0, bits: 9, val: 195 }, { op: 16, bits: 7, val: 10 }, { op: 0, bits: 8, val: 97 }, { op: 0, bits: 8, val: 33 }, { op: 0, bits: 9, val: 163 }, { op: 0, bits: 8, val: 1 }, { op: 0, bits: 8, val: 129 }, { op: 0, bits: 8, val: 65 }, { op: 0, bits: 9, val: 227 }, { op: 16, bits: 7, val: 6 }, { op: 0, bits: 8, val: 89 }, { op: 0, bits: 8, val: 25 }, { op: 0, bits: 9, val: 147 }, { op: 19, bits: 7, val: 59 }, { op: 0, bits: 8, val: 121 }, { op: 0, bits: 8, val: 57 }, { op: 0, bits: 9, val: 211 }, { op: 17, bits: 7, val: 17 }, { op: 0, bits: 8, val: 105 }, { op: 0, bits: 8, val: 41 }, { op: 0, bits: 9, val: 179 }, { op: 0, bits: 8, val: 9 }, { op: 0, bits: 8, val: 137 }, { op: 0, bits: 8, val: 73 }, { op: 0, bits: 9, val: 243 }, { op: 16, bits: 7, val: 4 }, { op: 0, bits: 8, val: 85 }, { op: 0, bits: 8, val: 21 }, { op: 16, bits: 8, val: 258 }, { op: 19, bits: 7, val: 43 }, { op: 0, bits: 8, val: 117 }, { op: 0, bits: 8, val: 53 }, { op: 0, bits: 9, val: 203 }, { op: 17, bits: 7, val: 13 }, { op: 0, bits: 8, val: 101 }, { op: 0, bits: 8, val: 37 }, { op: 0, bits: 9, val: 171 }, { op: 0, bits: 8, val: 5 }, { op: 0, bits: 8, val: 133 }, { op: 0, bits: 8, val: 69 }, { op: 0, bits: 9, val: 235 }, { op: 16, bits: 7, val: 8 }, { op: 0, bits: 8, val: 93 }, { op: 0, bits: 8, val: 29 }, { op: 0, bits: 9, val: 155 }, { op: 20, bits: 7, val: 83 }, { op: 0, bits: 8, val: 125 }, { op: 0, bits: 8, val: 61 }, { op: 0, bits: 9, val: 219 }, { op: 18, bits: 7, val: 23 }, { op: 0, bits: 8, val: 109 }, { op: 0, bits: 8, val: 45 }, { op: 0, bits: 9, val: 187 }, { op: 0, bits: 8, val: 13 }, { op: 0, bits: 8, val: 141 }, { op: 0, bits: 8, val: 77 }, { op: 0, bits: 9, val: 251 }, { op: 16, bits: 7, val: 3 }, { op: 0, bits: 8, val: 83 }, { op: 0, bits: 8, val: 19 }, { op: 21, bits: 8, val: 195 }, { op: 19, bits: 7, val: 35 }, { op: 0, bits: 8, val: 115 }, { op: 0, bits: 8, val: 51 }, { op: 0, bits: 9, val: 199 }, { op: 17, bits: 7, val: 11 }, { op: 0, bits: 8, val: 99 }, { op: 0, bits: 8, val: 35 }, { op: 0, bits: 9, val: 167 }, { op: 0, bits: 8, val: 3 }, { op: 0, bits: 8, val: 131 }, { op: 0, bits: 8, val: 67 }, { op: 0, bits: 9, val: 231 }, { op: 16, bits: 7, val: 7 }, { op: 0, bits: 8, val: 91 }, { op: 0, bits: 8, val: 27 }, { op: 0, bits: 9, val: 151 }, { op: 20, bits: 7, val: 67 }, { op: 0, bits: 8, val: 123 }, { op: 0, bits: 8, val: 59 }, { op: 0, bits: 9, val: 215 }, { op: 18, bits: 7, val: 19 }, { op: 0, bits: 8, val: 107 }, { op: 0, bits: 8, val: 43 }, { op: 0, bits: 9, val: 183 }, { op: 0, bits: 8, val: 11 }, { op: 0, bits: 8, val: 139 }, { op: 0, bits: 8, val: 75 }, { op: 0, bits: 9, val: 247 }, { op: 16, bits: 7, val: 5 }, { op: 0, bits: 8, val: 87 }, { op: 0, bits: 8, val: 23 }, { op: 64, bits: 8, val: 0 }, { op: 19, bits: 7, val: 51 }, { op: 0, bits: 8, val: 119 }, { op: 0, bits: 8, val: 55 }, { op: 0, bits: 9, val: 207 }, { op: 17, bits: 7, val: 15 }, { op: 0, bits: 8, val: 103 }, { op: 0, bits: 8, val: 39 }, { op: 0, bits: 9, val: 175 }, { op: 0, bits: 8, val: 7 }, { op: 0, bits: 8, val: 135 }, { op: 0, bits: 8, val: 71 }, { op: 0, bits: 9, val: 239 }, { op: 16, bits: 7, val: 9 }, { op: 0, bits: 8, val: 95 }, { op: 0, bits: 8, val: 31 }, { op: 0, bits: 9, val: 159 }, { op: 20, bits: 7, val: 99 }, { op: 0, bits: 8, val: 127 }, { op: 0, bits: 8, val: 63 }, { op: 0, bits: 9, val: 223 }, { op: 18, bits: 7, val: 27 }, { op: 0, bits: 8, val: 111 }, { op: 0, bits: 8, val: 47 }, { op: 0, bits: 9, val: 191 }, { op: 0, bits: 8, val: 15 }, { op: 0, bits: 8, val: 143 }, { op: 0, bits: 8, val: 79 }, { op: 0, bits: 9, val: 255 }];
+ if (!distfix_ary) distfix_ary = [{ op: 16, bits: 5, val: 1 }, { op: 23, bits: 5, val: 257 }, { op: 19, bits: 5, val: 17 }, { op: 27, bits: 5, val: 4097 }, { op: 17, bits: 5, val: 5 }, { op: 25, bits: 5, val: 1025 }, { op: 21, bits: 5, val: 65 }, { op: 29, bits: 5, val: 16385 }, { op: 16, bits: 5, val: 3 }, { op: 24, bits: 5, val: 513 }, { op: 20, bits: 5, val: 33 }, { op: 28, bits: 5, val: 8193 }, { op: 18, bits: 5, val: 9 }, { op: 26, bits: 5, val: 2049 }, { op: 22, bits: 5, val: 129 }, { op: 64, bits: 5, val: 0 }, { op: 16, bits: 5, val: 2 }, { op: 23, bits: 5, val: 385 }, { op: 19, bits: 5, val: 25 }, { op: 27, bits: 5, val: 6145 }, { op: 17, bits: 5, val: 7 }, { op: 25, bits: 5, val: 1537 }, { op: 21, bits: 5, val: 97 }, { op: 29, bits: 5, val: 24577 }, { op: 16, bits: 5, val: 4 }, { op: 24, bits: 5, val: 769 }, { op: 20, bits: 5, val: 49 }, { op: 28, bits: 5, val: 12289 }, { op: 18, bits: 5, val: 13 }, { op: 26, bits: 5, val: 3073 }, { op: 22, bits: 5, val: 193 }, { op: 64, bits: 5, val: 0 }];
+ state.lencode = 0;
+ state.distcode = 512;
+ for(i = 0; i < 512; i++) {
+ state.codes[i] = lenfix_ary[i];
+ }
+ for(i = 0; i < 32; i++) {
+ state.codes[i + 512] = distfix_ary[i];
+ }
+ state.lenbits = 9;
+ state.distbits = 5;
+}
+
+/*
+ Update the window with the last wsize (normally 32K) bytes written before
+ returning. If window does not exist yet, create it. This is only called
+ when a window is already in use, or when output has been written during this
+ inflate call, but the end of the deflate stream has not been reached yet.
+ It is also called to create a window for dictionary data when a dictionary
+ is loaded.
+
+ Providing output buffers larger than 32K to inflate() should provide a speed
+ advantage, since only the last 32K of output is copied to the sliding window
+ upon return from inflate(), and since all distances after the first 32K of
+ output will fall in the output data, making match copies simpler and faster.
+ The advantage may be dependent on the size of the processor's data caches.
+*/
+function updatewindow(strm)
+{
+ var state = strm.state;
+ var out = strm.output_data.length;
+
+ /* if it hasn't been done already, allocate space for the window */
+ if (state.window === null) {
+ state.window = '';
+ }
+
+ /* if window not in use yet, initialize */
+ if (state.wsize == 0) {
+ state.wsize = 1 << state.wbits;
+ }
+
+ // zlib.js: Sliding window
+ if (out >= state.wsize) {
+ state.window = strm.output_data.substring(out - state.wsize);
+ } else {
+ if(state.whave + out < state.wsize) {
+ state.window += strm.output_data;
+ } else {
+ state.window = state.window.substring(state.whave - (state.wsize - out)) + strm.output_data;
+ }
+ }
+ state.whave = state.window.length;
+ if(state.whave < state.wsize) {
+ state.wnext = state.whave;
+ } else {
+ state.wnext = 0;
+ }
+ return 0;
+}
+
+
+// #ifdef GUNZIP
+function CRC2(strm, word)
+{
+ var hbuf = [word & 0xff, (word >>> 8) & 0xff];
+ strm.state.check = strm.checksum_function(strm.state.check, hbuf, 0, 2);
+}
+
+function CRC4(strm, word)
+{
+ var hbuf = [word & 0xff,
+ (word >>> 8) & 0xff,
+ (word >>> 16) & 0xff,
+ (word >>> 24) & 0xff];
+ strm.state.check = strm.checksum_function(strm.state.check, hbuf, 0, 4);
+}
+
+/* Load registers with state in inflate() for speed */
+function LOAD(strm, s)
+{
+ s.strm = strm; /* z_stream */
+ s.left = strm.avail_out; /* available output */
+ s.next = strm.next_in; /* next input */
+ s.have = strm.avail_in; /* available input */
+ s.hold = strm.state.hold; /* bit buffer */
+ s.bits = strm.state.bits; /* bits in bit buffer */
+ return s;
+}
+
+/* Restore state from registers in inflate() */
+function RESTORE(s)
+{
+ var strm = s.strm;
+ strm.next_in = s.next;
+ strm.avail_out = s.left;
+ strm.avail_in = s.have;
+ strm.state.hold = s.hold;
+ strm.state.bits = s.bits;
+}
+
+/* Clear the input bit accumulator */
+function INITBITS(s)
+{
+ s.hold = 0;
+ s.bits = 0;
+}
+
+/* Get a byte of input into the bit accumulator, or return from inflate()
+ if there is no input available. */
+function PULLBYTE(s)
+{
+ if (s.have == 0) return false;
+ s.have--;
+ s.hold += (s.strm.input_data.charCodeAt(s.next++) & 0xff) << s.bits;
+ s.bits += 8;
+ return true;
+}
+
+/* Assure that there are at least n bits in the bit accumulator. If there is
+ not enough available input to do that, then return from inflate(). */
+function NEEDBITS(s, n)
+{
+ // if(typeof n != 'number') throw 'ERROR';
+ while (s.bits < n) {
+ if(!PULLBYTE(s))
+ return false;
+ }
+ return true;
+}
+
+/* Return the low n bits of the bit accumulator (n < 16) */
+function BITS(s, n)
+{
+ return s.hold & ((1 << n) - 1);
+}
+
+/* Remove n bits from the bit accumulator */
+function DROPBITS(s, n)
+{
+ // if(typeof n != 'number') throw 'ERROR';
+ s.hold >>>= n;
+ s.bits -= n;
+}
+
+/* Remove zero to seven bits as needed to go to a byte boundary */
+function BYTEBITS(s)
+{
+ s.hold >>>= s.bits & 7;
+ s.bits -= s.bits & 7;
+}
+
+/* Reverse the bytes in a 32-bit value */
+function REVERSE(q)
+{
+ return ((q >>> 24) & 0xff) +
+ ((q >>> 8) & 0xff00) +
+ ((q & 0xff00) << 8) +
+ ((q & 0xff) << 24);
+}
+
+/*
+ inflate() uses a state machine to process as much input data and generate as
+ much output data as possible before returning. The state machine is
+ structured roughly as follows:
+
+ for (;;) switch (state) {
+ ...
+ case STATEn:
+ if (not enough input data or output space to make progress)
+ return;
+ ... make progress ...
+ state = STATEm;
+ break;
+ ...
+ }
+
+ so when inflate() is called again, the same case is attempted again, and
+ if the appropriate resources are provided, the machine proceeds to the
+ next state. The NEEDBITS() macro is usually the way the state evaluates
+ whether it can proceed or should return. NEEDBITS() does the return if
+ the requested bits are not available. The typical use of the BITS macros
+ is:
+
+ NEEDBITS(n);
+ ... do something with BITS(n) ...
+ DROPBITS(n);
+
+ where NEEDBITS(n) either returns from inflate() if there isn't enough
+ input left to load n bits into the accumulator, or it continues. BITS(n)
+ gives the low n bits in the accumulator. When done, DROPBITS(n) drops
+ the low n bits off the accumulator. INITBITS() clears the accumulator
+ and sets the number of available bits to zero. BYTEBITS() discards just
+ enough bits to put the accumulator on a byte boundary. After BYTEBITS()
+ and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
+
+ NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
+ if there is no input available. The decoding of variable length codes uses
+ PULLBYTE() directly in order to pull just enough bytes to decode the next
+ code, and no more.
+
+ Some states loop until they get enough input, making sure that enough
+ state information is maintained to continue the loop where it left off
+ if NEEDBITS() returns in the loop. For example, want, need, and keep
+ would all have to actually be part of the saved state in case NEEDBITS()
+ returns:
+
+ case STATEw:
+ while (want < need) {
+ NEEDBITS(n);
+ keep[want++] = BITS(n);
+ DROPBITS(n);
+ }
+ state = STATEx;
+ case STATEx:
+
+ As shown above, if the next state is also the next case, then the break
+ is omitted.
+
+ A state may also return if there is not enough output space available to
+ complete that state. Those states are copying stored data, writing a
+ literal byte, and copying a matching string.
+
+ When returning, a "goto inf_leave" is used to update the total counters,
+ update the check value, and determine whether any progress has been made
+ during that inflate() call in order to return the proper return code.
+ Progress is defined as a change in either strm->avail_in or strm->avail_out.
+ When there is a window, goto inf_leave will update the window with the last
+ output written. If a goto inf_leave occurs in the middle of decompression
+ and there is no window currently, goto inf_leave will create one and copy
+ output to the window for the next call of inflate().
+
+ In this implementation, the flush parameter of inflate() only affects the
+ return code (per zlib.h). inflate() always writes as much as possible to
+ strm->next_out, given the space available and the provided input--the effect
+ documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers
+ the allocation of and copying into a sliding window until necessary, which
+ provides the effect documented in zlib.h for Z_FINISH when the entire input
+ stream available. So the only thing the flush parameter actually does is:
+ when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it
+ will return Z_BUF_ERROR if it has not reached the end of the stream.
+ */
+
+/* permutation of code lengths */
+var inflate_order = [
+ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+ZLIB.inflate = function(strm, flush)
+{
+ var state;
+ var s;
+ var _in, out; /* save starting available input and output */
+ var copy; /* number of stored or match bytes to copy */
+ var from_window_offset = -1; /* index of window[] */
+ var from_out_offset = -1; /* index of next_out[] */
+ var here; /* current decoding table entry */
+ var last; /* parent table entry */
+ var len; /* length to copy for repeats, bits to drop */
+ var ret; /* return code */
+
+ if (!strm || !strm.state ||
+ (!strm.input_data && strm.avail_in != 0))
+ return ZLIB.Z_STREAM_ERROR;
+
+ state = strm.state;
+ if (state.mode == TYPE) state.mode = TYPEDO; /* skip check */
+
+ // LOAD
+ s = {};
+ LOAD(strm, s);
+
+ _in = s.have;
+ out = s.left;
+ ret = ZLIB.Z_OK;
+inf_leave: for (;;) {
+ switch (state.mode) {
+ case HEAD:
+ if (state.wrap == 0) {
+ state.mode = TYPEDO;
+ break;
+ }
+ if(!NEEDBITS(s, 16)) break inf_leave;
+// #ifdef GUNZIP
+ if ((state.wrap & 2) && s.hold == 0x8b1f) { /* gzip header */
+ state.check = strm.checksum_function(0, null, 0, 0);
+ CRC2(strm, s.hold);
+ INITBITS(s);
+ state.mode = FLAGS;
+ break;
+ }
+ state.flags = 0; /* expect zlib header */
+ if (state.head !== null)
+ state.head.done = -1;
+ if (!(state.wrap & 1) || /* check if zlib header allowed */
+//#else
+// if (
+//#endif
+ ((BITS(s, 8) << 8) + (s.hold >>> 8)) % 31) {
+ strm.msg = 'incorrect header check';
+ state.mode = BAD;
+ break;
+ }
+ if (BITS(s, 4) != ZLIB.Z_DEFLATED) {
+ strm.msg = 'unknown compression method';
+ state.mode = BAD;
+ break;
+ }
+
+ DROPBITS(s, 4);
+ len = BITS(s, 4) + 8;
+ if (state.wbits == 0)
+ state.wbits = len;
+ else if (len > state.wbits) {
+ strm.msg = 'invalid window size';
+ state.mode = BAD;
+ break;
+ }
+ state.dmax = 1 << len;
+// Tracev((stderr, "inflate: zlib header ok\n"));
+ strm.adler = state.check = strm.checksum_function(0, null, 0, 0);
+ state.mode = s.hold & 0x200 ? DICTID : TYPE;
+ INITBITS(s);
+ break;
+// #ifdef GUNZIP
+ case FLAGS:
+ if(!NEEDBITS(s, 16)) break inf_leave;
+ state.flags = s.hold;
+ if ((state.flags & 0xff) != ZLIB.Z_DEFLATED) {
+ strm.msg = "unknown compression method";
+ state.mode = BAD;
+ break;
+ }
+ if (state.flags & 0xe000) {
+ strm.msg = "unknown header flags set";
+ state.mode = BAD;
+ break;
+ }
+ if (state.head !== null)
+ state.head.text = (s.hold >>> 8) & 1;
+ if (state.flags & 0x0200) {
+ CRC2(strm, s.hold);
+ }
+ INITBITS(s);
+ state.mode = TIME;
+ case TIME:
+ if(!NEEDBITS(s, 32)) break inf_leave;
+ if (state.head !== null)
+ state.head.time = s.hold;
+ if (state.flags & 0x0200) {
+ CRC4(strm, s.hold);
+ }
+ INITBITS(s);
+ state.mode = OS;
+ case OS:
+ if(!NEEDBITS(s, 16)) break inf_leave;
+ if (state.head !== null) {
+ state.head.xflags = s.hold & 0xff;
+ state.head.os = s.hold >>> 8;
+ }
+ if (state.flags & 0x0200) {
+ CRC2(strm, s.hold);
+ }
+ INITBITS(s);
+ state.mode = EXLEN;
+ case EXLEN:
+ if (state.flags & 0x0400) {
+ if(!NEEDBITS(s, 16)) break inf_leave;
+ state.length = s.hold;
+ if (state.head !== null) {
+ state.head.extra_len = s.hold;
+ }
+ if (state.flags & 0x0200) {
+ CRC2(strm, s.hold);
+ }
+ INITBITS(s);
+ state.head.extra = "";
+ }
+ else if (state.head !== null) {
+ state.head.extra = null;
+ }
+ state.mode = EXTRA;
+ case EXTRA:
+ if (state.flags & 0x0400) {
+ copy = state.length;
+ if (copy > s.have) copy = s.have;
+ if (copy) {
+ if (state.head !== null &&
+ state.head.extra !== null) {
+ len = state.head.extra_len - state.length;
+/*
+ zmemcpy(state->head->extra + len, next,
+ len + copy > state->head->extra_max ?
+ state->head->extra_max - len : copy);
+*/
+ state.head.extra += strm.input_data.substring(
+ s.next, s.next + (len + copy > state.head.extra_max ?
+ state.head.extra_max - len : copy));
+
+ }
+ if (state.flags & 0x0200)
+ state.check = strm.checksum_function(state.check, strm.input_data, s.next, copy);
+ s.have -= copy;
+ s.next += copy;
+ state.length -= copy;
+ }
+ if (state.length) break inf_leave;
+ }
+ state.length = 0;
+ state.mode = NAME;
+ case NAME:
+ if (state.flags & 0x0800) {
+ if (s.have == 0) break inf_leave;
+ if (state.head !== null && state.head.name === null) {
+ state.head.name = "";
+ }
+ copy = 0;
+ // TODO end = strm.input_data.indexOf("\0", s.next);
+ // TODO state.length => state.head.name.length
+ do {
+ len = strm.input_data.charAt(s.next + copy); copy++;
+ if(len === "\0")
+ break;
+ if (state.head !== null &&
+ state.length < state.head.name_max) {
+ state.head.name += len;
+ state.length++;
+ }
+ } while (copy < s.have);
+ if (state.flags & 0x0200) {
+ state.check = strm.checksum_function(state.check, strm.input_data, s.next, copy);
+ }
+ s.have -= copy;
+ s.next += copy;
+ if (len !== "\0") break inf_leave;
+ }
+ else if (state.head !== null)
+ state.head.name = null;
+ state.length = 0;
+ state.mode = COMMENT;
+ case COMMENT:
+ if (state.flags & 0x1000) {
+ if (s.have == 0) break inf_leave;
+ copy = 0;
+ if (state.head !== null && state.head.comment === null) {
+ state.head.comment = "";
+ }
+ // TODO end = strm.input_data.indexOf("\0", s.next);
+ // TODO state.length => state.head.comment.length
+ do {
+ len = strm.input_data.charAt(s.next + copy); copy++;
+ if(len === "\0")
+ break;
+ if (state.head !== null &&
+ state.length < state.head.comm_max) {
+ state.head.comment += len;
+ state.length++;
+ }
+ } while (copy < s.have);
+ if (state.flags & 0x0200)
+ state.check = strm.checksum_function(state.check, strm.input_data, s.next, copy);
+ s.have -= copy;
+ s.next += copy;
+ if (len !== "\0") break inf_leave;
+ }
+ else if (state.head !== null)
+ state.head.comment = null;
+ state.mode = HCRC;
+ case HCRC:
+ if (state.flags & 0x0200) {
+ if(!NEEDBITS(s, 16)) break inf_leave;
+ if (s.hold != (state.check & 0xffff)) {
+ strm.msg = "header crc mismatch";
+ state.mode = BAD;
+ break;
+ }
+ INITBITS(s);
+ }
+ if (state.head !== null) {
+ state.head.hcrc = (state.flags >>> 9) & 1;
+ state.head.done = 1;
+ }
+ strm.adler = state.check = strm.checksum_function(0, null, 0, 0);
+ state.mode = TYPE;
+ break;
+//#endif
+ case DICTID:
+ if(!NEEDBITS(s, 32)) break inf_leave;
+ strm.adler = state.check = REVERSE(s.hold);
+ INITBITS(s);
+ state.mode = DICT;
+ case DICT:
+ if (state.havedict == 0) {
+ RESTORE(s);
+ return ZLIB.Z_NEED_DICT;
+ }
+ strm.adler = state.check = strm.checksum_function(0, null, 0, 0);
+ state.mode = TYPE;
+ case TYPE:
+ if (flush == ZLIB.Z_BLOCK || flush == ZLIB.Z_TREES) break inf_leave;
+ case TYPEDO:
+ if (state.last) {
+ BYTEBITS(s);
+ state.mode = CHECK;
+ break;
+ }
+ if(!NEEDBITS(s, 3)) break inf_leave;
+ state.last = BITS(s, 1);
+ DROPBITS(s, 1);
+ switch (BITS(s, 2)) {
+ case 0: /* stored block */
+// Tracev((stderr, "inflate: stored block%s\n",
+// state->last ? " (last)" : ""));
+ state.mode = STORED;
+ break;
+ case 1: /* fixed block */
+ fixedtables(state);
+// Tracev((stderr, "inflate: fixed codes block%s\n",
+// state->last ? " (last)" : ""));
+ state.mode = LEN_; /* decode codes */
+ if (flush == ZLIB.Z_TREES) {
+ DROPBITS(s, 2);
+ break inf_leave;
+ }
+ break;
+ case 2: /* dynamic block */
+// Tracev((stderr, "inflate: dynamic codes block%s\n",
+// state->last ? " (last)" : ""));
+ state.mode = TABLE;
+ break;
+ case 3:
+ strm.msg = 'invalid block type';
+ state.mode = BAD;
+ }
+ DROPBITS(s, 2);
+ break;
+ case STORED:
+ BYTEBITS(s); /* go to byte boundary */
+ if(!NEEDBITS(s, 32)) break inf_leave;
+ if ((s.hold & 0xffff) != (((s.hold >>> 16) & 0xffff) ^ 0xffff)) {
+ strm.msg = 'invalid stored block lengths';
+ state.mode = BAD;
+ break;
+ }
+ state.length = s.hold & 0xffff;
+// Tracev((stderr, "inflate: stored length %u\n",
+// state->length));
+ INITBITS(s);
+ state.mode = COPY_;
+ if (flush == ZLIB.Z_TREES) break inf_leave;
+ case COPY_:
+ state.mode = COPY;
+ case COPY:
+ copy = state.length;
+ if (copy) {
+ if (copy > s.have) copy = s.have;
+ if (copy > s.left) copy = s.left;
+ if (copy == 0) break inf_leave;
+ strm.output_data += strm.input_data.substring(s.next, s.next + copy);
+ strm.next_out += copy;
+ s.have -= copy;
+ s.next += copy;
+ s.left -= copy;
+ state.length -= copy;
+ break;
+ }
+// Tracev((stderr, "inflate: stored end\n"));
+ state.mode = TYPE;
+ break;
+ case TABLE:
+ if(!NEEDBITS(s, 14)) break inf_leave;
+ state.nlen = BITS(s, 5) + 257;
+ DROPBITS(s, 5);
+ state.ndist = BITS(s, 5) + 1;
+ DROPBITS(s, 5);
+ state.ncode = BITS(s, 4) + 4;
+ DROPBITS(s, 4);
+//#ifndef PKZIP_BUG_WORKAROUND
+ if (state.nlen > 286 || state.ndist > 30) {
+ strm.msg = 'too many length or distance symbols';
+ state.mode = BAD;
+ break;
+ }
+//#endif
+// Tracev((stderr, "inflate: table sizes ok\n"));
+ state.have = 0;
+ state.mode = LENLENS;
+ case LENLENS:
+ while (state.have < state.ncode) {
+ if(!NEEDBITS(s, 3)) break inf_leave;
+ var tmp = BITS(s, 3);
+ state.lens[inflate_order[state.have++]] = tmp;
+ DROPBITS(s, 3);
+ }
+ while (state.have < 19)
+ state.lens[inflate_order[state.have++]] = 0;
+ state.next = 0;
+ state.lencode = 0;
+ state.lenbits = 7;
+
+// ret = inflate_table(CODES, state->lens, 19, &(state->next),
+// &(state->lenbits), state->work);
+ ret = inflate_table(state, CODES);
+
+ if (ret) {
+ strm.msg = 'invalid code lengths set';
+ state.mode = BAD;
+ break;
+ }
+// Tracev((stderr, "inflate: code lengths ok\n"));
+ state.have = 0;
+ state.mode = CODELENS;
+ case CODELENS:
+ while (state.have < state.nlen + state.ndist) {
+ for (;;) {
+ here = state.codes[state.lencode + BITS(s, state.lenbits)];
+ if (here.bits <= s.bits) break;
+ if(!PULLBYTE(s)) break inf_leave;
+ }
+ if (here.val < 16) {
+ DROPBITS(s, here.bits);
+ state.lens[state.have++] = here.val;
+ }
+ else {
+ if (here.val == 16) {
+ if(!NEEDBITS(s, here.bits + 2)) break inf_leave;
+ DROPBITS(s, here.bits);
+ if (state.have == 0) {
+ strm.msg = 'invalid bit length repeat';
+ state.mode = BAD;
+ break;
+ }
+ len = state.lens[state.have - 1];
+ copy = 3 + BITS(s, 2);
+ DROPBITS(s, 2);
+ }
+ else if (here.val == 17) {
+ if(!NEEDBITS(s, here.bits + 3)) break inf_leave;
+ DROPBITS(s, here.bits);
+ len = 0;
+ copy = 3 + BITS(s, 3);
+ DROPBITS(s, 3);
+ }
+ else {
+ if(!NEEDBITS(s, here.bits + 7)) break inf_leave;
+ DROPBITS(s, here.bits);
+ len = 0;
+ copy = 11 + BITS(s, 7);
+ DROPBITS(s, 7);
+ }
+ if (state.have + copy > state.nlen + state.ndist) {
+ strm.msg = 'invalid bit length repeat';
+ state.mode = BAD;
+ break;
+ }
+ while (copy--)
+ state.lens[state.have++] = len;
+ }
+ }
+
+ /* handle error breaks in while */
+ if (state.mode == BAD) break;
+
+ /* check for end-of-block code (better have one) */
+ if (state.lens[256] == 0) {
+ strm.msg = 'invalid code -- missing end-of-block';
+ state.mode = BAD;
+ break;
+ }
+
+ /* build code tables -- note: do not change the lenbits or distbits
+ values here (9 and 6) without reading the comments in inftrees.h
+ concerning the ENOUGH constants, which depend on those values */
+ state.next = 0;
+ state.lencode = state.next;
+ state.lenbits = 9;
+// ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+// &(state->lenbits), state->work);
+ ret = inflate_table(state, LENS);
+ if (ret) {
+ strm.msg = 'invalid literal/lengths set';
+ state.mode = BAD;
+ break;
+ }
+ state.distcode = state.next;
+ state.distbits = 6;
+// ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, &(state->next),
+// &(state->distbits), state->work);
+ ret = inflate_table(state, DISTS);
+ if (ret) {
+ strm.msg = 'invalid distances set';
+ state.mode = BAD;
+ break;
+ }
+// Tracev((stderr, "inflate: codes ok\n"));
+ state.mode = LEN_;
+ if (flush == ZLIB.Z_TREES) break inf_leave;
+ case LEN_:
+ state.mode = LEN;
+ case LEN:
+ if (s.have >= 6 && s.left >= 258) {
+ RESTORE(s);
+ inflate_fast(strm, out);
+ LOAD(strm, s);
+ if (state.mode == TYPE)
+ state.back = -1;
+ break;
+ }
+ state.back = 0;
+ for (;;) {
+ here = state.codes[state.lencode + BITS(s, state.lenbits)];
+ if (here.bits <= s.bits) break;
+ if(!PULLBYTE(s)) break inf_leave;
+ }
+ if (here.op && (here.op & 0xf0) == 0) {
+ last = here;
+ for (;;) {
+ here = state.codes[state.lencode + last.val +
+ (BITS(s, last.bits + last.op) >>> last.bits)];
+ if (last.bits + here.bits <= s.bits) break;
+ if(!PULLBYTE(s)) break inf_leave;
+ }
+ DROPBITS(s, last.bits);
+ state.back += last.bits;
+ }
+ DROPBITS(s, here.bits);
+ state.back += here.bits;
+ state.length = here.val;
+ if (here.op == 0) {
+// Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
+// "inflate: literal '%c'\n" :
+// "inflate: literal 0x%02x\n", here.val));
+ state.mode = LIT;
+ break;
+ }
+ if (here.op & 32) {
+// Tracevv((stderr, "inflate: end of block\n"));
+ state.back = -1;
+ state.mode = TYPE;
+ break;
+ }
+ if (here.op & 64) {
+ strm.msg = 'invalid literal/length code';
+ state.mode = BAD;
+ break;
+ }
+ state.extra = here.op & 15;
+ state.mode = LENEXT;
+ case LENEXT:
+ if (state.extra) {
+ if(!NEEDBITS(s, state.extra)) break inf_leave;
+ state.length += BITS(s, state.extra);
+ DROPBITS(s, state.extra);
+ state.back += state.extra;
+ }
+ //Tracevv((stderr, "inflate: length %u\n", state->length));
+ state.was = state.length;
+ state.mode = DIST;
+ case DIST:
+ for (;;) {
+ here = state.codes[state.distcode + BITS(s, state.distbits)];
+ if (here.bits <= s.bits) break;
+ if(!PULLBYTE(s)) break inf_leave;
+ }
+ if ((here.op & 0xf0) == 0) {
+ last = here;
+ for (;;) {
+ here = state.codes[state.distcode + last.val +
+ (BITS(s, last.bits + last.op) >>> last.bits)];
+ if ((last.bits + here.bits) <= s.bits) break;
+ if(!PULLBYTE(s)) break inf_leave;
+ }
+ DROPBITS(s, last.bits);
+ state.back += last.bits;
+ }
+ DROPBITS(s, here.bits);
+ state.back += here.bits;
+ if (here.op & 64) {
+ strm.msg = 'invalid distance code';
+ state.mode = BAD;
+ break;
+ }
+ state.offset = here.val;
+ state.extra = here.op & 15;
+ state.mode = DISTEXT;
+ case DISTEXT:
+ if (state.extra) {
+ if(!NEEDBITS(s, state.extra)) break inf_leave;
+ state.offset += BITS(s, state.extra);
+ DROPBITS(s, state.extra);
+ state.back += state.extra;
+ }
+//NOSPRT #ifdef INFLATE_STRICT
+// if (state->offset > state->dmax) {
+// strm->msg = (char *)"invalid distance too far back";
+// state->mode = BAD;
+// break;
+// }
+//#endif
+// Tracevv((stderr, "inflate: distance %u\n", state->offset));
+ state.mode = MATCH;
+ case MATCH:
+ if (s.left == 0) break inf_leave;
+ copy = out - s.left;
+ if (state.offset > copy) { /* copy from window */
+ copy = state.offset - copy;
+ if (copy > state.whave) {
+ if (state.sane) {
+ strm.msg = 'invalid distance too far back';
+ state.mode = BAD;
+ break;
+ }
+//NOSPRT #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+// Trace((stderr, "inflate.c too far\n"));
+// copy -= state->whave;
+// if (copy > state->length) copy = state->length;
+// if (copy > left) copy = left;
+// left -= copy;
+// state->length -= copy;
+// do {
+// *put++ = 0;
+// } while (--copy);
+// if (state->length == 0) state->mode = LEN;
+// break;
+//#endif
+ }
+ if (copy > state.wnext) {
+ copy -= state.wnext;
+ // from = state->window + (state->wsize - copy);
+ from_window_offset = state.wsize - copy;
+ from_out_offset = -1;
+ }
+ else {
+ // from = state->window + (state->wnext - copy);
+ from_window_offset = state.wnext - copy;
+ from_out_offset = -1;
+ }
+ if (copy > state.length) copy = state.length;
+ }
+ else { /* copy from output */
+ // from = put - state->offset;
+ from_window_offset = -1;
+ from_out_offset = strm.next_out - state.offset;
+ copy = state.length;
+ }
+ if (copy > s.left) copy = s.left;
+ s.left -= copy;
+ state.length -= copy;
+ if( from_window_offset >= 0 ) {
+ strm.output_data += state.window.substring(from_window_offset, from_window_offset + copy);
+ strm.next_out += copy;
+ copy = 0;
+ } else {
+ strm.next_out += copy;
+ do {
+ strm.output_data += strm.output_data.charAt(from_out_offset++);
+ } while (--copy);
+ }
+ if (state.length == 0) state.mode = LEN;
+ break;
+ case LIT:
+ if (s.left == 0) break inf_leave;
+
+ strm.output_data += String.fromCharCode(state.length);
+ strm.next_out++;
+ //*put++ = (unsigned char)(state->length);
+
+ s.left--;
+ state.mode = LEN;
+ break;
+ case CHECK:
+ if (state.wrap) {
+ if(!NEEDBITS(s, 32)) break inf_leave;
+ out -= s.left;
+ strm.total_out += out;
+ state.total += out;
+ if (out)
+ strm.adler = state.check =
+ strm.checksum_function(state.check, strm.output_data, strm.output_data.length - out, out);
+ out = s.left;
+ if ((
+// #ifdef GUNZIP
+ state.flags ? s.hold :
+//#endif
+ REVERSE(s.hold)) != state.check) {
+ strm.msg = "incorrect data check";
+ state.mode = BAD;
+ break;
+ }
+ INITBITS(s);
+//debug("## inflate: check matches trailer\n");
+// Tracev((stderr, "inflate: check matches trailer\n"));
+ }
+//#ifdef GUNZIP
+ state.mode = LENGTH;
+ case LENGTH:
+ if (state.wrap && state.flags) {
+ if(!NEEDBITS(s, 32)) break inf_leave;
+ if (s.hold != (state.total & 0xffffffff)) {
+ strm.msg = 'incorrect length check';
+ state.mode = BAD;
+ break;
+ }
+ INITBITS(s);
+ //Tracev((stderr, "inflate: length matches trailer\n"));
+ }
+//#endif
+ state.mode = DONE;
+ case DONE:
+ ret = ZLIB.Z_STREAM_END;
+ break inf_leave;
+ case BAD:
+ ret = ZLIB.Z_DATA_ERROR;
+ break inf_leave;
+ case MEM:
+ return ZLIB.Z_MEM_ERROR;
+ case SYNC:
+ default:
+ return ZLIB.Z_STREAM_ERROR;
+ } }
+
+ /*
+ Return from inflate(), updating the total counts and the check value.
+ If there was no progress during the inflate() call, return a buffer
+ error. Call updatewindow() to create and/or update the window state.
+ Note: a memory error from inflate() is non-recoverable.
+ */
+inf_leave:
+ RESTORE(s);
+ if (state.wsize || (out != strm.avail_out && state.mode < BAD &&
+ (state.mode < CHECK || flush != ZLIB.Z_FINISH)))
+ if (updatewindow(strm)) {
+ state.mode = MEM;
+ return ZLIB.Z_MEM_ERROR;
+ }
+ _in -= strm.avail_in;
+ out -= strm.avail_out;
+ strm.total_in += _in;
+ strm.total_out += out;
+ state.total += out;
+ if (state.wrap && out)
+ strm.adler = state.check = strm.checksum_function(state.check, strm.output_data, 0, strm.output_data.length);
+ strm.data_type = state.bits + (state.last ? 64 : 0) +
+ (state.mode == TYPE ? 128 : 0) +
+ (state.mode == LEN_ || state.mode == COPY_ ? 256 : 0);
+ if (((_in == 0 && out == 0) || flush == ZLIB.Z_FINISH) && ret == ZLIB.Z_OK)
+ ret = ZLIB.Z_BUF_ERROR;
+ return ret;
+};
+
+ZLIB.inflateEnd = function(strm)
+{
+ var state;
+ if (!strm || !strm.state )
+ return ZLIB.Z_STREAM_ERROR;
+ state = strm.state;
+ state.window = null;
+ strm.state = null;
+ // Tracev((stderr, "inflate: end\n"));
+ return ZLIB.Z_OK;
+};
+
+ZLIB.z_stream.prototype.inflate = function(input_string, opts)
+{
+ var flush;
+ var avail_out;
+ var DEFAULT_BUFFER_SIZE = 16384;
+
+ this.input_data = input_string;
+ this.next_in = getarg(opts, 'next_in', 0);
+ this.avail_in = getarg(opts, 'avail_in', input_string.length - this.next_in);
+
+ flush = getarg(opts, 'flush', ZLIB.Z_SYNC_FLUSH);
+ avail_out = getarg(opts, 'avail_out', -1);
+
+ var result = '';
+ do {
+ this.avail_out = (avail_out >= 0 ? avail_out : DEFAULT_BUFFER_SIZE);
+ this.output_data = '';
+ this.next_out = 0;
+ this.error = ZLIB.inflate(this, flush);
+ if(avail_out >= 0) {
+ return this.output_data;
+ }
+ result += this.output_data;
+ if(this.avail_out > 0) {
+ break;
+ }
+ } while(this.error == ZLIB.Z_OK);
+
+ return result;
+};
+
+ZLIB.z_stream.prototype.inflateReset = function(windowBits)
+{
+ return ZLIB.inflateReset(this, windowBits);
+};
+
+}());
diff --git a/zlib.js b/zlib.js
new file mode 100644
index 0000000..1b6fbba
--- /dev/null
+++ b/zlib.js
@@ -0,0 +1,111 @@
+/* zlib.js -- JavaScript implementation for the zlib.
+ Version: 0.2.0
+ LastModified: Apr 12 2012
+ Copyright (C) 2012 Masanao Izumo
+
+ The original copyright notice (zlib 1.2.6):
+
+ Copyright (C) 1995-2012 Jean-loup Gailly and Mark Adler
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ Jean-loup Gailly Mark Adler
+ jloup@gzip.org madler@alumni.caltech.edu
+
+
+ The data format used by the zlib library is described by RFCs (Request for
+ Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
+ (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
+*/
+
+var ZLIB = ( ZLIB || {} ); // ZLIB namespace initialization
+
+// common definitions
+if(typeof ZLIB.common_initialized === 'undefined') {
+ ZLIB.Z_NO_FLUSH = 0;
+ ZLIB.Z_PARTIAL_FLUSH = 1;
+ ZLIB.Z_SYNC_FLUSH = 2;
+ ZLIB.Z_FULL_FLUSH = 3;
+ ZLIB.Z_FINISH = 4;
+ ZLIB.Z_BLOCK = 5;
+ ZLIB.Z_TREES = 6;
+ /* Allowed flush values; see deflate() and inflate() below for details */
+
+ ZLIB.Z_OK = 0;
+ ZLIB.Z_STREAM_END = 1;
+ ZLIB.Z_NEED_DICT = 2;
+ ZLIB.Z_ERRNO = (-1);
+ ZLIB.Z_STREAM_ERROR = (-2);
+ ZLIB.Z_DATA_ERROR = (-3);
+ ZLIB.Z_MEM_ERROR = (-4);
+ ZLIB.Z_BUF_ERROR = (-5);
+ ZLIB.Z_VERSION_ERROR = (-6);
+ /* Return codes for the compression/decompression functions. Negative values
+ * are errors, positive values are used for special but normal events.
+ */
+
+ ZLIB.Z_DEFLATED = 8; /* The deflate compression method (the only one supported in this version) */
+
+ /**
+ * z_stream constructor
+ * @constructor
+ */
+ ZLIB.z_stream = function() {
+ this.next_in = 0; /* next input byte */
+ this.avail_in = 0; /* number of bytes available in input_data */
+ this.total_in = 0; /* total number of input bytes read so far */
+
+ this.next_out = 0; /* next output byte */
+ this.avail_out = 0; /* remaining free space at next_out */
+ this.total_out = 0; /* total number of bytes output so far */
+
+ this.msg = null; /* last error message, null if no error */
+ this.state = null; /* not visible by applications */
+
+ this.data_type = 0; /* best guess about the data type: binary or text */
+ this.adler = 0; /* TODO: adler32 value of the uncompressed data */
+
+ // zlib.js
+ this.input_data = ''; /* input data */
+ this.output_data = ''; /* output data */
+ this.error = 0; /* error code */
+ this.checksum_function = null; /* crc32(for gzip) or adler32(for zlib) */
+ };
+
+ /**
+ * TODO
+ * @constructor
+ */
+ ZLIB.gz_header = function() {
+ this.text = 0; /* true if compressed data believed to be text */
+ this.time = 0; /* modification time */
+ this.xflags = 0; /* extra flags (not used when writing a gzip file) */
+ this.os = 0xff; /* operating system */
+ this.extra = null; /* extra field string or null if none */
+ this.extra_len = 0; /* this.extra.length (only when reading header) */
+ this.extra_max = 0; /* space at extra (only when reading header) */
+ this.name = null; /* file name string or null if none */
+ this.name_max = 0; /* space at name (only when reading header) */
+ this.comment = null; /* comment string or null if none */
+ this.comm_max = 0; /* space at comment (only when reading header) */
+ this.hcrc = 0; /* true if there was or will be a header crc */
+ this.done = 0; /* true when done reading gzip header (not used
+ when writing a gzip file) */
+ };
+
+ ZLIB.common_initialized = true;
+} // common definitions
+ 
+ 
+
+
+
+
+ 
TLS Secured
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+ 
+ 
TLS Secured