diff --git a/agents/MeshCmd-signed.exe b/agents/MeshCmd-signed.exe
index b4e37588..728078b3 100644
Binary files a/agents/MeshCmd-signed.exe and b/agents/MeshCmd-signed.exe differ
diff --git a/agents/MeshCmd64-signed.exe b/agents/MeshCmd64-signed.exe
index aaee20d6..1539f1bf 100644
Binary files a/agents/MeshCmd64-signed.exe and b/agents/MeshCmd64-signed.exe differ
diff --git a/agents/MeshService-signed.exe b/agents/MeshService-signed.exe
index a46f9bd9..7ed930ce 100644
Binary files a/agents/MeshService-signed.exe and b/agents/MeshService-signed.exe differ
diff --git a/agents/MeshService.exe b/agents/MeshService.exe
index 41f1142e..bfe38e5c 100644
Binary files a/agents/MeshService.exe and b/agents/MeshService.exe differ
diff --git a/agents/MeshService64-signed.exe b/agents/MeshService64-signed.exe
index c1bc727c..245e2595 100644
Binary files a/agents/MeshService64-signed.exe and b/agents/MeshService64-signed.exe differ
diff --git a/agents/MeshService64.exe b/agents/MeshService64.exe
index 83f6b819..9a661d42 100644
Binary files a/agents/MeshService64.exe and b/agents/MeshService64.exe differ
diff --git a/agents/meshcmd.js b/agents/meshcmd.js
index af54659d..c5d511ff 100644
--- a/agents/meshcmd.js
+++ b/agents/meshcmd.js
@@ -1532,7 +1532,7 @@ if (serviceName == null) {
if (serviceInstall == 0) {
run(process.argv);
} else {
- var serviceHost = require('serviceHost');
+ var serviceHost = require('service-host');
var meshcmdService = new serviceHost({ name: serviceName, startType: 'AUTO_START' });
// Called when the background service is started.
diff --git a/agents/meshcore.js b/agents/meshcore.js
index 364c8305..523b31b5 100644
--- a/agents/meshcore.js
+++ b/agents/meshcore.js
@@ -14,12 +14,59 @@ See the License for the specific language governing permissions and
limitations under the License.
*/
+
+function borderController()
+{
+ this.container = null;
+ this.Start = function Start(user)
+ {
+ if (this.container == null) {
+ if (process.platform == 'win32') {
+ this.container = require('ScriptContainer').Create({ processIsolation: 1, sessionId: user.SessionId });
+ }
+ else {
+ this.container = require('ScriptContainer').Create({ processIsolation: 1, sessionId: user.uid });
+ }
+ this.container.addModule('monitor-info', getJSModule('monitor-info'));
+ this.container.addModule('monitor-border', getJSModule('monitor-border'));
+ this.container.addModule('promise', getJSModule('promise'));
+ this.container.ExecuteString("var border = require('monitor-border'); border.Start();");
+ }
+ }
+ this.Stop = function Stop()
+ {
+ if (this.container != null)
+ {
+ this._container = this.container;
+ this._container.parent = this;
+ this.container = null;
+
+ this._container.once('exit', function () { this.parent._container = null; });
+ this._container.exit();
+ }
+ }
+}
+
function createMeshCore(agent) {
var obj = {};
+ require('events').EventEmitter.call(obj, true).createEvent('loggedInUsers_Updated');
+ obj.on('loggedInUsers_Updated', function ()
+ {
+ var users = []
+ for(var i = 0; i < obj.loggedInUsers.length; ++i)
+ {
+ users.push((obj.loggedInUsers[i].Domain ? (obj.loggedInUsers[i].Domain + '\\') : '') + obj.loggedInUsers[i].Username);
+ }
+ sendConsoleText('LogOn Status Changed. Active Users => [' + users.join(', ') + ']');
+ });
+ obj.borderManager = new borderController();
+
// MeshAgent JavaScript Core Module. This code is sent to and running on the mesh agent.
obj.meshCoreInfo = "MeshCore v5";
obj.meshCoreCapabilities = 14; // Capability bitmask: 1 = Desktop, 2 = Terminal, 4 = Files, 8 = Console, 16 = JavaScript
+ obj.loggedInUsers = [];
+
var meshServerConnectionState = 0;
var tunnels = {};
var lastSelfInfo = null;
@@ -863,9 +910,36 @@ function createMeshCore(agent) {
var response = null;
switch (cmd) {
case 'help': { // Displays available commands
- response = 'Available commands: help, info, args, print, type, dbget, dbset, dbcompact, eval, parseuri, httpget,\r\nwslist, wsconnect, wssend, wsclose, notify, ls, ps, kill, amt, netinfo, location, power, wakeonlan, scanwifi,\r\nscanamt, setdebug, smbios, rawsmbios, toast, lock.';
+ response = 'Available commands: help, info, args, print, type, dbget, dbset, dbcompact, eval, parseuri, httpget,\r\nwslist, wsconnect, wssend, wsclose, notify, ls, ps, kill, amt, netinfo, location, power, wakeonlan, scanwifi,\r\nscanamt, setdebug, smbios, rawsmbios, toast, lock, users, border.';
break;
}
+ case 'border':
+ {
+ if ((args['_'].length == 1) && (args['_'][0] == 'on')) {
+ if (obj.loggedInUsers.length > 0) {
+ obj.borderManager.Start(obj.loggedInUsers[0]);
+ response = 'Border blinking is on.';
+ } else {
+ response = 'Cannot turn on border blinking, no logged in users.';
+ }
+ } else if ((args['_'].length == 1) && (args['_'][0] == 'off')) {
+ obj.borderManager.Stop();
+ response = 'Border blinking is off.';
+ } else {
+ response = 'Proper usage: border "on|off"'; // Display correct command usage
+ }
+ }
+ break;
+ case 'users':
+ {
+ var retList = [];
+ for(var i = 0; i < obj.loggedInUsers.length; ++i)
+ {
+ retList.push((obj.loggedInUsers[i].Domain ? (obj.loggedInUsers[i].Domain + '\\') : '') + obj.loggedInUsers[i].Username);
+ }
+ response = 'Active Users => [' + retList.join(', ') + ']';
+ }
+ break;
case 'toast': {
if (process.platform == 'win32') {
if (args['_'].length < 1) { response = 'Proper usage: toast "message"'; } else {
@@ -878,8 +952,8 @@ function createMeshCore(agent) {
break;
}
case 'setdebug': {
- if (args['_'].length < 1) { response = 'Proper usage: setdebug (target), 0 = StdOut, 1 = This Console, * = All Consoles, 2 = WebLog, 3 = Disabled'; } // Display usage
- else { if (args['_'][0] == '*') { console.setDestination(1); } else { console.setDestination(parseInt(args['_'][0]), sessionid); } }
+ if (args['_'].length < 1) { response = 'Proper usage: setdebug (target), 0 = Disabled, 1 = StdOut, 2 = This Console, * = All Consoles, 4 = WebLog, 8 = Logfile'; } // Display usage
+ else { if (args['_'][0] == '*') { console.setDestination(2); } else { console.setDestination(parseInt(args['_'][0]), sessionid); } }
break;
}
case 'ps': {
@@ -1373,6 +1447,16 @@ function createMeshCore(agent) {
sendPeriodicServerUpdate(true); // Send the server update
}
+ require('user-sessions').on('changed', function onUserSessionChanged()
+ {
+ require('user-sessions').enumerateUsers().then(function (users)
+ {
+ obj.loggedInUsers = users.Active;
+ obj.emit('loggedInUsers_Updated');
+ });
+ });
+
+ require('user-sessions').emit('changed');
//console.log('Stopping.');
//process.exit();
}
diff --git a/agents/modules_meshcmd/serviceHost.js b/agents/modules_meshcmd/service-host.js
similarity index 63%
rename from agents/modules_meshcmd/serviceHost.js
rename to agents/modules_meshcmd/service-host.js
index ebe0c7c3..7bfe0e49 100644
--- a/agents/modules_meshcmd/serviceHost.js
+++ b/agents/modules_meshcmd/service-host.js
@@ -1,24 +1,61 @@
+/*
+Copyright 2018 Intel Corporation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
var SERVICE_WIN32 = 0x00000010 | 0x00000020;
var SERVICE_STATE = { STOPPED: 0x00000001, SERVICE_START_PENDING: 0x00000002, SERVICE_STOP_PENDING: 0x00000003, RUNNING: 0x00000004 };
-var SERVICE_ACCEPT = { SERVICE_ACCEPT_STOP: 0x00000001, SERVICE_ACCEPT_SHUTDOWN: 0x00000004 };
-var SERVICE_CONTROL = { SERVICE_CONTROL_SHUTDOWN: 0x00000005, SERVICE_CONTROL_STOP: 0x00000001 };
+var SERVICE_ACCEPT = { SERVICE_ACCEPT_STOP: 0x00000001, SERVICE_ACCEPT_SHUTDOWN: 0x00000004, SERVICE_ACCEPT_POWEREVENT: 0x00000040, SERVICE_ACCEPT_SESSIONCHANGE: 0x00000080 };
+
+var SERVICE_CONTROL = { SERVICE_CONTROL_SHUTDOWN: 0x00000005, SERVICE_CONTROL_STOP: 0x00000001, SERVICE_CONTROL_POWEREVENT: 0x0000000D, SERVICE_CONTROL_SESSIONCHANGE: 0x0000000E};
+var SESSION_CHANGE_TYPE =
+{
+ WTS_CONSOLE_CONNECT: 0x1,
+ WTS_CONSOLE_DISCONNECT: 0x2,
+ WTS_REMOTE_CONNECT: 0x3,
+ WTS_REMOTE_DISCONNECT: 0x4,
+ WTS_SESSION_LOGON: 0x5,
+ WTS_SESSION_LOGOFF: 0x6,
+ WTS_SESSION_LOCK: 0x7,
+ WTS_SESSION_UNLOCK: 0x8,
+ WTS_SESSION_REMOTE_CONTROL: 0x9,
+ WTS_SESSION_CREATE: 0xa,
+ WTS_SESSION_TERMINATE: 0xb
+};
+
+
var NO_ERROR = 0;
-var serviceManager = require('serviceManager');
+var serviceManager = require('service-manager');
-function serviceHost(serviceName) {
- this._ObjectID = 'serviceHost';
+function serviceHost(serviceName)
+{
+ this._ObjectID = 'service-host';
var emitterUtils = require('events').inherits(this);
emitterUtils.createEvent('serviceStart');
emitterUtils.createEvent('serviceStop');
emitterUtils.createEvent('normalStart');
+ emitterUtils.createEvent('session');
+ emitterUtils.createEvent('powerStateChange');
- if (process.platform == 'win32') {
+ if (process.platform == 'win32')
+ {
this.GM = require('_GenericMarshal');
this.Advapi = this.GM.CreateNativeProxy('Advapi32.dll');
this.Advapi.CreateMethod({ method: 'StartServiceCtrlDispatcherA', threadDispatch: 1 });
- this.Advapi.CreateMethod('RegisterServiceCtrlHandlerA');
+ this.Advapi.CreateMethod('RegisterServiceCtrlHandlerExA');
this.Advapi.CreateMethod('SetServiceStatus');
this.Kernel32 = this.GM.CreateNativeProxy('Kernel32.dll');
this.Kernel32.CreateMethod('GetLastError');
@@ -31,7 +68,8 @@ function serviceHost(serviceName) {
this._ServiceMain = this.GM.GetGenericGlobalCallback(2);
this._ServiceMain.Parent = this;
this._ServiceMain.GM = this.GM;
- this._ServiceMain.on('GlobalCallback', function onGlobalCallback(argc, argv) {
+ this._ServiceMain.on('GlobalCallback', function onGlobalCallback(argc, argv)
+ {
//ToDo: Check to make sure this is for us
this.Parent._ServiceStatus = this.GM.CreateVariable(28);
@@ -48,8 +86,9 @@ function serviceHost(serviceName) {
// Initialise service status
this.Parent._ServiceStatus.toBuffer().writeUInt32LE(SERVICE_WIN32);
this.Parent._ServiceStatus.toBuffer().writeUInt32LE(SERVICE_STATE.SERVICE_STOPPED, 4);
- this.Parent._ServiceStatusHandle = this.Parent.Advapi.RegisterServiceCtrlHandlerA(this.Parent._ServiceName, this.Parent._ServiceControlHandler);
- if (this.Parent._ServiceStatusHandle.Val == 0) {
+ this.Parent._ServiceStatusHandle = this.Parent.Advapi.RegisterServiceCtrlHandlerExA(this.Parent._ServiceName, this.Parent._ServiceControlHandler, this.Parent.GM.StashObject(this.Parent._ServiceControlHandler));
+ if(this.Parent._ServiceStatusHandle.Val == 0)
+ {
process.exit(1);
}
@@ -59,11 +98,12 @@ function serviceHost(serviceName) {
// Service running
this.Parent._ServiceStatus.toBuffer().writeUInt32LE(SERVICE_STATE.RUNNING, 4);
- this.Parent._ServiceStatus.toBuffer().writeUInt32LE(SERVICE_ACCEPT.SERVICE_ACCEPT_STOP, 8);
+ this.Parent._ServiceStatus.toBuffer().writeUInt32LE(SERVICE_ACCEPT.SERVICE_ACCEPT_STOP | SERVICE_ACCEPT.SERVICE_ACCEPT_POWEREVENT | SERVICE_ACCEPT.SERVICE_ACCEPT_SESSIONCHANGE, 8);
this.Parent.Advapi.SetServiceStatus(this.Parent._ServiceStatusHandle, this.Parent._ServiceStatus);
this.Parent.Ole32.CoInitializeEx(0, 2);
- this.Parent.on('~', function OnServiceHostFinalizer() {
+ this.Parent.on('~', function OnServiceHostFinalizer()
+ {
var GM = require('_GenericMarshal');
var Advapi = GM.CreateNativeProxy('Advapi32.dll');
Advapi.CreateMethod('SetServiceStatus');
@@ -82,22 +122,39 @@ function serviceHost(serviceName) {
this.Ole32.CoUninitialize();
});
+
this.Parent.emit('serviceStart');
});
- this._ServiceControlHandler = this.GM.GetGenericGlobalCallback(1);
+ this._ServiceControlHandler = this.GM.GetGenericGlobalCallback(4);
this._ServiceControlHandler.Parent = this;
this._ServiceControlHandler.GM = this.GM;
- this._ServiceControlHandler.on('GlobalCallback', function onServiceControlHandler(code) {
- switch (code.Val) {
- case SERVICE_CONTROL.SERVICE_CONTROL_SHUTDOWN:
- case SERVICE_CONTROL.SERVICE_CONTROL_STOP:
- this.Parent.emit('serviceStop');
- return;
- default:
- break;
- }
+ this._ServiceControlHandler.on('GlobalCallback', function onServiceControlHandler(code, eventType, eventData, context)
+ {
+ var j = this.Parent.GM.UnstashObject(context);
+ if (j != null && j == this)
+ {
+ switch (code.Val)
+ {
+ case SERVICE_CONTROL.SERVICE_CONTROL_SHUTDOWN:
+ case SERVICE_CONTROL.SERVICE_CONTROL_STOP:
+ this.Parent.emit('serviceStop');
+ return;
+ case SERVICE_CONTROL.SERVICE_CONTROL_SESSIONCHANGE:
+ var sessionId = eventData.Deref(4, 4).toBuffer().readUInt32LE();
+ switch(eventType.Val)
+ {
+ case SESSION_CHANGE_TYPE.WTS_SESSION_LOGON:
+ case SESSION_CHANGE_TYPE.WTS_SESSION_LOGOFF:
+ require('user-sessions').emit('changed');
+ break;
+ }
+ break;
+ default:
+ break;
+ }
- this.Parent.Advapi.SetServiceStatus(this.Parent._ServiceStatusHandle, this.Parent._ServiceStatus);
+ this.Parent.Advapi.SetServiceStatus(this.Parent._ServiceStatusHandle, this.Parent._ServiceStatus);
+ }
});
}
@@ -106,42 +163,54 @@ function serviceHost(serviceName) {
{
throw ('Must specify either ServiceName or Options');
}
- if (!this._ServiceOptions.servicePath) {
+ if (!this._ServiceOptions.servicePath)
+ {
this._ServiceOptions.servicePath = process.execPath;
}
-
- this.run = function run() {
+
+ this.run = function run()
+ {
var serviceOperation = 0;
- for (var i = 0; i < process.argv.length; ++i) {
- switch (process.argv[i].toLowerCase()) {
- case 'install':
+ for(var i = 0; i 0 && tokens[x]) { tokenList.push(tokens[x]); }
+ if (i > 0 && tokens[x]) { tokenList.push(tokens[x]);}
}
- if ((i > 0) && (tokenList[key.PID])) {
- retVal[tokenList[key.PID]] = { user: tokenList[key.USER], cmd: tokenList[key.COMMAND] };
+ if(i>0)
+ {
+ if (tokenList[key.PID])
+ {
+ retVal.push({ pid: tokenList[key.PID], user: tokenList[key.USER], command: tokenList[key.COMMAND] });
+ }
}
}
- if (this.callback) {
+ if (this.callback)
+ {
this.args.unshift(retVal);
this.callback.apply(this.parent, this.args);
}
@@ -81,18 +99,25 @@ function processManager() {
break;
}
};
- this.getProcessInfo = function getProcessInfo(pid) {
- switch (process.platform) {
+ this.getProcessInfo = function getProcessInfo(pid)
+ {
+ switch(process.platform)
+ {
default:
throw ('getProcessInfo() not supported for ' + process.platform);
+ break;
case 'linux':
- var status = require('fs').readFileSync('/proc/' + pid + '/status'), info = {}, lines = status.toString().split('\n');
- for (var i in lines) {
+ var status = require('fs').readFileSync('/proc/' + pid + '/status');
+ var info = {};
+ var lines = status.toString().split('\n');
+ for(var i in lines)
+ {
var tokens = lines[i].split(':');
if (tokens.length > 1) { tokens[1] = tokens[1].trim(); }
info[tokens[0]] = tokens[1];
}
return (info);
+ break;
}
};
}
diff --git a/agents/modules_meshcore/promise.js b/agents/modules_meshcore/promise.js
new file mode 100644
index 00000000..e764a630
--- /dev/null
+++ b/agents/modules_meshcore/promise.js
@@ -0,0 +1,185 @@
+/*
+Copyright 2018 Intel Corporation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+var refTable = {};
+
+function Promise(promiseFunc)
+{
+ this._ObjectID = 'promise';
+ this._internal = { promise: this, func: promiseFunc, completed: false, errors: false, completedArgs: [] };
+ require('events').EventEmitter.call(this._internal);
+ this._internal.on('_eventHook', function (eventName, eventCallback)
+ {
+ //console.log('hook', eventName, 'errors/' + this.errors + ' completed/' + this.completed);
+ var r = null;
+
+ if (eventName == 'resolved' && !this.errors && this.completed)
+ {
+ r = eventCallback.apply(this, this.completedArgs);
+ if(r!=null)
+ {
+ this.emit_returnValue('resolved', r);
+ }
+ }
+ if (eventName == 'rejected' && this.errors && this.completed)
+ {
+ eventCallback.apply(this, this.completedArgs);
+ }
+ if (eventName == 'settled' && this.completed)
+ {
+ eventCallback.apply(this, []);
+ }
+ });
+ this._internal.resolver = function _resolver()
+ {
+ _resolver._self.errors = false;
+ _resolver._self.completed = true;
+ _resolver._self.completedArgs = [];
+ var args = ['resolved'];
+ if (this.emit_returnValue && this.emit_returnValue('resolved') != null)
+ {
+ _resolver._self.completedArgs.push(this.emit_returnValue('resolved'));
+ args.push(this.emit_returnValue('resolved'));
+ }
+ else
+ {
+ for (var a in arguments)
+ {
+ _resolver._self.completedArgs.push(arguments[a]);
+ args.push(arguments[a]);
+ }
+ }
+ _resolver._self.emit.apply(_resolver._self, args);
+ _resolver._self.emit('settled');
+ };
+ this._internal.rejector = function _rejector()
+ {
+ _rejector._self.errors = true;
+ _rejector._self.completed = true;
+ _rejector._self.completedArgs = [];
+ var args = ['rejected'];
+ for (var a in arguments)
+ {
+ _rejector._self.completedArgs.push(arguments[a]);
+ args.push(arguments[a]);
+ }
+
+ _rejector._self.emit.apply(_rejector._self, args);
+ _rejector._self.emit('settled');
+ };
+ this.catch = function(func)
+ {
+ this._internal.once('settled', func);
+ }
+ this.finally = function (func)
+ {
+ this._internal.once('settled', func);
+ };
+ this.then = function (resolved, rejected)
+ {
+ if (resolved) { this._internal.once('resolved', resolved); }
+ if (rejected) { this._internal.once('rejected', rejected); }
+
+ var retVal = new Promise(function (r, j) { });
+
+ this._internal.once('resolved', retVal._internal.resolver);
+ this._internal.once('rejected', retVal._internal.rejector);
+ return (retVal);
+ };
+
+ this._internal.resolver._self = this._internal;
+ this._internal.rejector._self = this._internal;;
+
+ try
+ {
+ promiseFunc.call(this, this._internal.resolver, this._internal.rejector);
+ }
+ catch(e)
+ {
+ this._internal.errors = true;
+ this._internal.completed = true;
+ this._internal.completedArgs = [e];
+ this._internal.emit('rejected', e);
+ this._internal.emit('settled');
+ }
+
+ if(!this._internal.completed)
+ {
+ // Save reference of this object
+ refTable[this._internal._hashCode()] = this._internal;
+ this._internal.once('settled', function () { refTable[this._hashCode()] = null; });
+ }
+}
+
+Promise.resolve = function resolve()
+{
+ var retVal = new Promise(function (r, j) { });
+ var args = [];
+ for (var i in arguments)
+ {
+ args.push(arguments[i]);
+ }
+ retVal._internal.resolver.apply(retVal._internal, args);
+ return (retVal);
+};
+Promise.reject = function reject() {
+ var retVal = new Promise(function (r, j) { });
+ var args = [];
+ for (var i in arguments) {
+ args.push(arguments[i]);
+ }
+ retVal._internal.rejector.apply(retVal._internal, args);
+ return (retVal);
+};
+Promise.all = function all(promiseList)
+{
+ var ret = new Promise(function (res, rej)
+ {
+ this.__rejector = rej;
+ this.__resolver = res;
+ this.__promiseList = promiseList;
+ this.__done = false;
+ this.__count = 0;
+ });
+
+ for (var i in promiseList)
+ {
+ promiseList[i].then(function ()
+ {
+ // Success
+ if(++ret.__count == ret.__promiseList.length)
+ {
+ ret.__done = true;
+ ret.__resolver(ret.__promiseList);
+ }
+ }, function (arg)
+ {
+ // Failure
+ if(!ret.__done)
+ {
+ ret.__done = true;
+ ret.__rejector(arg);
+ }
+ });
+ }
+ if (promiseList.length == 0)
+ {
+ ret.__resolver(promiseList);
+ }
+ return (ret);
+};
+
+module.exports = Promise;
\ No newline at end of file
diff --git a/agents/modules_meshcore/user-sessions.js b/agents/modules_meshcore/user-sessions.js
index d8fe2d96..4672596e 100644
--- a/agents/modules_meshcore/user-sessions.js
+++ b/agents/modules_meshcore/user-sessions.js
@@ -16,9 +16,27 @@ limitations under the License.
function UserSessions()
{
- this._ObjectID = 'UserSessions';
+ this._ObjectID = 'user-sessions';
+ require('events').EventEmitter.call(this, true).createEvent('changed');
- if (process.platform == 'win32') {
+ this.enumerateUsers = function enumerateUsers()
+ {
+ var promise = require('promise');
+ var p = new promise(function (res, rej)
+ {
+ this.__resolver = res;
+ this.__rejector = rej;
+ });
+ p.__handler = function __handler(users)
+ {
+ p.__resolver(users);
+ };
+ this.Current(p.__handler);
+ return (p);
+ }
+
+ if (process.platform == 'win32')
+ {
this._marshal = require('_GenericMarshal');
this._kernel32 = this._marshal.CreateNativeProxy('Kernel32.dll');
this._kernel32.CreateMethod('GetLastError');
@@ -77,7 +95,7 @@ function UserSessions()
return (retVal);
};
- this.Current = function Current()
+ this.Current = function Current(cb)
{
var retVal = {};
var pinfo = this._marshal.CreatePointer();
@@ -102,36 +120,152 @@ function UserSessions()
this._wts.WTSFreeMemory(pinfo.Deref());
- Object.defineProperty(retVal, 'connected', { value: showActiveOnly(retVal) });
+ Object.defineProperty(retVal, 'Active', { value: showActiveOnly(retVal) });
+ if (cb) { cb(retVal); }
return (retVal);
};
}
else
{
- this.Current = function Current()
+ this.Self = function Self()
+ {
+ var promise = require('promise');
+ var p = new promise(function (res, rej)
+ {
+ this.__resolver = res; this.__rejector = rej;
+ this.__child = require('child_process').execFile('/usr/bin/id', ['id', '-u']);
+ this.__child.promise = this;
+ this.__child.stdout._txt = '';
+ this.__child.stdout.on('data', function (chunk) { this._txt += chunk.toString(); });
+ this.__child.on('exit', function (code)
+ {
+ try
+ {
+ parseInt(this.stdout._txt);
+ }
+ catch (e)
+ {
+ this.promise.__rejector('invalid uid');
+ return;
+ }
+
+ var id = parseInt(this.stdout._txt);
+ this.promise.__resolver(id);
+ });
+ });
+ return (p);
+ };
+ this.Current = function Current(cb)
{
var retVal = {};
- var emitterUtils = require('events').inherits(retVal);
- emitterUtils.createEvent('logon');
+ retVal._ObjectID = 'UserSession'
+ Object.defineProperty(retVal, '_callback', { value: cb });
+ Object.defineProperty(retVal, '_child', { value: require('child_process').execFile('/usr/bin/last', ['last', '-f', '/var/run/utmp']) });
- retVal._child = require('child_process').execFile('/usr/bin/last', ['last', '-f', '/var/run/utmp']);
retVal._child.Parent = retVal;
retVal._child._txt = '';
retVal._child.on('exit', function (code)
{
var lines = this._txt.split('\n');
var sessions = [];
+ var users = {};
+
for(var i in lines)
{
if (lines[i])
{
- console.log(getTokens(lines[i]));
- var user = lines[i].substring(0, lines[i].indexOf(' '));
- sessions.push(user);
+ var tokens = getTokens(lines[i]);
+ var s = { Username: tokens[0], SessionId: tokens[1] }
+ if (tokens[3].includes('still logged in'))
+ {
+ s.State = 'Active';
+ }
+ else
+ {
+ s.LastActive = tokens[3];
+ }
+
+ sessions.push(s);
}
}
sessions.pop();
- console.log(sessions);
+
+
+ var usernames = {};
+ var promises = [];
+
+ for (var i in sessions)
+ {
+ if (sessions[i].Username != 'reboot')
+ {
+ users[sessions[i].SessionId] = sessions[i];
+ if(usernames[sessions[i].Username] == null)
+ {
+ usernames[sessions[i].Username] = -1;
+ }
+ }
+ }
+
+ try
+ {
+ require('promise');
+ }
+ catch(e)
+ {
+ Object.defineProperty(users, 'Active', { value: showActiveOnly(users) });
+ if (this.Parent._callback) { this.Parent._callback.call(this.Parent, users); }
+ return;
+ }
+
+ var promise = require('promise');
+ for (var n in usernames)
+ {
+ var p = new promise(function (res, rej)
+ {
+ this.__username = n;
+ this.__resolver = res; this.__rejector = rej;
+ this.__child = require('child_process').execFile('/usr/bin/id', ['id', '-u', n]);
+ this.__child.promise = this;
+ this.__child.stdout._txt = '';
+ this.__child.stdout.on('data', function (chunk) { this._txt += chunk.toString(); });
+ this.__child.on('exit', function (code)
+ {
+ try
+ {
+ parseInt(this.stdout._txt);
+ }
+ catch(e)
+ {
+ this.promise.__rejector('invalid uid');
+ return;
+ }
+
+ var id = parseInt(this.stdout._txt);
+ this.promise.__resolver(id);
+ });
+ });
+ promises.push(p);
+ }
+ promise.all(promises).then(function (plist)
+ {
+ // Done
+ var table = {};
+ for(var i in plist)
+ {
+ table[plist[i].__username] = plist[i]._internal.completedArgs[0];
+ }
+ for(var i in users)
+ {
+ users[i].uid = table[users[i].Username];
+ }
+ Object.defineProperty(users, 'Active', { value: showActiveOnly(users) });
+ if (retVal._callback) { retVal._callback.call(retVal, users); }
+ }, function (reason)
+ {
+ // Failed
+ Object.defineProperty(users, 'Active', { value: showActiveOnly(users) });
+ if (retVal._callback) { retVal._callback.call(retVal, users); }
+ });
});
retVal._child.stdout.Parent = retVal._child;
retVal._child.stdout.on('data', function (chunk) { this.Parent._txt += chunk.toString(); });
@@ -145,7 +279,7 @@ function showActiveOnly(source)
var retVal = [];
for (var i in source)
{
- if (source[i].State == 'Active' || source[i].State == 'Connected')
+ if (source[i].State == 'Active')
{
retVal.push(source[i]);
}
@@ -159,8 +293,13 @@ function getTokens(str)
columns.push(str.substring(0, (i=str.indexOf(' '))));
while (str[++i] == ' ');
- columns.push(str.substring(i, str.substring(i).indexOf(' ') + i));
-
+ columns.push(str.substring(i, (i=str.substring(i).indexOf(' ') + i)));
+ while (str[++i] == ' ');
+ columns.push(str.substring(i, (i=str.substring(i).indexOf(' ') + i)));
+ while (str[++i] == ' ');
+ var status = str.substring(i).trim();
+ columns.push(status);
+
return (columns);
}
diff --git a/agents/modules_meshcore_backup/amt-lme.js b/agents/modules_meshcore_backup/amt-lme.js
new file mode 100644
index 00000000..a7bb12ec
--- /dev/null
+++ b/agents/modules_meshcore_backup/amt-lme.js
@@ -0,0 +1,893 @@
+/*
+Copyright 2018 Intel Corporation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+
+var MemoryStream = require('MemoryStream');
+var lme_id = 0; // Our next channel identifier
+var lme_port_offset = 0; // Debug: Set this to "-100" to bind to 16892 & 16893 and IN_ADDRANY. This is for LMS debugging.
+var xmlParser = require('amt-xml');
+
+// Documented in: https://software.intel.com/sites/manageability/AMT_Implementation_and_Reference_Guide/HTMLDocuments/MPSDocuments/Intel%20AMT%20Port%20Forwarding%20Protocol%20Reference%20Manual.pdf
+var APF_DISCONNECT = 1;
+var APF_SERVICE_REQUEST = 5;
+var APF_SERVICE_ACCEPT = 6;
+var APF_USERAUTH_REQUEST = 50;
+var APF_USERAUTH_FAILURE = 51;
+var APF_USERAUTH_SUCCESS = 52;
+var APF_GLOBAL_REQUEST = 80;
+var APF_REQUEST_SUCCESS = 81;
+var APF_REQUEST_FAILURE = 82;
+var APF_CHANNEL_OPEN = 90;
+var APF_CHANNEL_OPEN_CONFIRMATION = 91;
+var APF_CHANNEL_OPEN_FAILURE = 92;
+var APF_CHANNEL_WINDOW_ADJUST = 93;
+var APF_CHANNEL_DATA = 94;
+var APF_CHANNEL_CLOSE = 97;
+var APF_PROTOCOLVERSION = 192;
+
+function lme_object() {
+ this.ourId = ++lme_id;
+ this.amtId = -1;
+ this.LME_CHANNEL_STATUS = 'LME_CS_FREE';
+ this.txWindow = 0;
+ this.rxWindow = 0;
+ this.localPort = 0;
+ this.errorCount = 0;
+}
+
+function stream_bufferedWrite() {
+ var emitterUtils = require('events').inherits(this);
+ this.buffer = [];
+ this._readCheckImmediate = undefined;
+ this._ObjectID = "bufferedWriteStream";
+ // Writable Events
+ emitterUtils.createEvent('close');
+ emitterUtils.createEvent('drain');
+ emitterUtils.createEvent('error');
+ emitterUtils.createEvent('finish');
+ emitterUtils.createEvent('pipe');
+ emitterUtils.createEvent('unpipe');
+
+ // Readable Events
+ emitterUtils.createEvent('readable');
+ this.isEmpty = function () {
+ return (this.buffer.length == 0);
+ };
+ this.isWaiting = function () {
+ return (this._readCheckImmediate == undefined);
+ };
+ this.write = function (chunk) {
+ for (var args in arguments) { if (typeof (arguments[args]) == 'function') { this.once('drain', arguments[args]); break; } }
+ var tmp = Buffer.alloc(chunk.length);
+ chunk.copy(tmp);
+ this.buffer.push({ offset: 0, data: tmp });
+ this.emit('readable');
+ return (this.buffer.length == 0 ? true : false);
+ };
+ this.read = function () {
+ var size = arguments.length == 0 ? undefined : arguments[0];
+ var bytesRead = 0;
+ var list = [];
+ while ((size == undefined || bytesRead < size) && this.buffer.length > 0) {
+ var len = this.buffer[0].data.length - this.buffer[0].offset;
+ var offset = this.buffer[0].offset;
+
+ if (len > (size - bytesRead)) {
+ // Only reading a subset
+ list.push(this.buffer[0].data.slice(offset, offset + size - bytesRead));
+ this.buffer[0].offset += (size - bytesRead);
+ bytesRead += (size - bytesRead);
+ } else {
+ // Reading the entire thing
+ list.push(this.buffer[0].data.slice(offset));
+ bytesRead += len;
+ this.buffer.shift();
+ }
+ }
+ this._readCheckImmediate = setImmediate(function (buffered) {
+ buffered._readCheckImmediate = undefined;
+ if (buffered.buffer.length == 0) {
+ buffered.emit('drain'); // Drained
+ } else {
+ buffered.emit('readable'); // Not drained
+ }
+ }, this);
+ return (Buffer.concat(list));
+ };
+}
+
+
+function lme_heci(options) {
+ var emitterUtils = require('events').inherits(this);
+ emitterUtils.createEvent('error');
+ emitterUtils.createEvent('connect');
+ emitterUtils.createEvent('notify');
+ emitterUtils.createEvent('bind');
+
+ if ((options != null) && (options.debug == true)) { lme_port_offset = -100; } // LMS debug mode
+
+ var heci = require('heci');
+ this.INITIAL_RXWINDOW_SIZE = 4096;
+
+ this._ObjectID = "lme";
+ this._LME = heci.create();
+ this._LME._binded = {};
+ this._LME.LMS = this;
+ this._LME.on('error', function (e) { this.LMS.emit('error', e); });
+ this._LME.on('connect', function () {
+ this.on('data', function (chunk) {
+ // this = HECI
+ var cmd = chunk.readUInt8(0);
+ //console.log('LME Command ' + cmd + ', ' + chunk.length + ' byte(s).');
+
+ switch (cmd) {
+ default:
+ console.log('Unhandled LME Command ' + cmd + ', ' + chunk.length + ' byte(s).');
+ break;
+ case APF_SERVICE_REQUEST:
+ var nameLen = chunk.readUInt32BE(1);
+ var name = chunk.slice(5, nameLen + 5);
+ //console.log("Service Request for: " + name);
+ if (name == 'pfwd@amt.intel.com' || name == 'auth@amt.intel.com') {
+ var outBuffer = Buffer.alloc(5 + nameLen);
+ outBuffer.writeUInt8(6, 0);
+ outBuffer.writeUInt32BE(nameLen, 1);
+ outBuffer.write(name.toString(), 5);
+ this.write(outBuffer);
+ //console.log('Answering APF_SERVICE_REQUEST');
+ } else {
+ //console.log('UNKNOWN APF_SERVICE_REQUEST');
+ }
+ break;
+ case APF_GLOBAL_REQUEST:
+ var nameLen = chunk.readUInt32BE(1);
+ var name = chunk.slice(5, nameLen + 5).toString();
+
+ switch (name) {
+ case 'tcpip-forward':
+ var len = chunk.readUInt32BE(nameLen + 6);
+ var port = chunk.readUInt32BE(nameLen + 10 + len);
+ //console.log("[" + chunk.length + "/" + len + "] APF_GLOBAL_REQUEST for: " + name + " on port " + port);
+ if (this[name] == undefined) { this[name] = {}; }
+ if (this[name][port] != null) { // Close the existing binding
+ for (var i in this.sockets) {
+ var channel = this.sockets[i];
+ if (channel.localPort == port) { this.sockets[i].end(); delete this.sockets[i]; } // Close this socket
+ }
+ }
+ if (this[name][port] == null)
+ { // Bind a new server socket if not already present
+ this[name][port] = require('net').createServer();
+ this[name][port].HECI = this;
+ if (lme_port_offset == 0) {
+ this[name][port].listen({ port: port, host: '127.0.0.1' }); // Normal mode
+ } else {
+ this[name][port].listen({ port: (port + lme_port_offset) }); // Debug mode
+ }
+ this[name][port].on('connection', function (socket) {
+ //console.log('New [' + socket.remoteFamily + '] TCP Connection on: ' + socket.remoteAddress + ' :' + socket.localPort);
+ this.HECI.LMS.bindDuplexStream(socket, socket.remoteFamily, socket.localPort - lme_port_offset);
+ });
+ this._binded[port] = true;
+ this.LMS.emit('bind', this._binded);
+ }
+ var outBuffer = Buffer.alloc(5);
+ outBuffer.writeUInt8(81, 0);
+ outBuffer.writeUInt32BE(port, 1);
+ this.write(outBuffer);
+ break;
+ case 'cancel-tcpip-forward':
+ var outBuffer = Buffer.alloc(1);
+ outBuffer.writeUInt8(APF_REQUEST_SUCCESS, 0);
+ this.write(outBuffer);
+ break;
+ case 'udp-send-to@amt.intel.com':
+ var outBuffer = Buffer.alloc(1);
+ outBuffer.writeUInt8(APF_REQUEST_FAILURE, 0);
+ this.write(outBuffer);
+ break;
+ default:
+ //console.log("Unknown APF_GLOBAL_REQUEST for: " + name);
+ break;
+ }
+ break;
+ case APF_CHANNEL_OPEN_CONFIRMATION:
+ var rChannel = chunk.readUInt32BE(1);
+ var sChannel = chunk.readUInt32BE(5);
+ var wSize = chunk.readUInt32BE(9);
+ //console.log('rChannel/' + rChannel + ', sChannel/' + sChannel + ', wSize/' + wSize);
+ if (this.sockets[rChannel] != undefined) {
+ this.sockets[rChannel].lme.amtId = sChannel;
+ this.sockets[rChannel].lme.rxWindow = wSize;
+ this.sockets[rChannel].lme.txWindow = wSize;
+ this.sockets[rChannel].lme.LME_CHANNEL_STATUS = 'LME_CS_CONNECTED';
+ //console.log('LME_CS_CONNECTED');
+ this.sockets[rChannel].bufferedStream = new stream_bufferedWrite();
+ this.sockets[rChannel].bufferedStream.socket = this.sockets[rChannel];
+ this.sockets[rChannel].bufferedStream.on('readable', function () {
+ if (this.socket.lme.txWindow > 0) {
+ var buffer = this.read(this.socket.lme.txWindow);
+ var packet = Buffer.alloc(9 + buffer.length);
+ packet.writeUInt8(APF_CHANNEL_DATA, 0);
+ packet.writeUInt32BE(this.socket.lme.amtId, 1);
+ packet.writeUInt32BE(buffer.length, 5);
+ buffer.copy(packet, 9);
+ this.socket.lme.txWindow -= buffer.length;
+ this.socket.HECI.write(packet);
+ }
+ });
+ this.sockets[rChannel].bufferedStream.on('drain', function () {
+ this.socket.resume();
+ });
+ this.sockets[rChannel].on('data', function (chunk) {
+ if (!this.bufferedStream.write(chunk)) { this.pause(); }
+ });
+ this.sockets[rChannel].on('end', function () {
+ var outBuffer = Buffer.alloc(5);
+ outBuffer.writeUInt8(APF_CHANNEL_CLOSE, 0);
+ outBuffer.writeUInt32BE(this.lme.amtId, 1);
+ this.HECI.write(outBuffer);
+ });
+ this.sockets[rChannel].resume();
+ }
+
+ break;
+ case APF_PROTOCOLVERSION:
+ var major = chunk.readUInt32BE(1);
+ var minor = chunk.readUInt32BE(5);
+ var reason = chunk.readUInt32BE(9);
+ var outBuffer = Buffer.alloc(93);
+ outBuffer.writeUInt8(192, 0);
+ outBuffer.writeUInt32BE(1, 1);
+ outBuffer.writeUInt32BE(0, 5);
+ outBuffer.writeUInt32BE(reason, 9);
+ //console.log('Answering PROTOCOL_VERSION');
+ this.write(outBuffer);
+ break;
+ case APF_CHANNEL_WINDOW_ADJUST:
+ var rChannelId = chunk.readUInt32BE(1);
+ var bytesToAdd = chunk.readUInt32BE(5);
+ if (this.sockets[rChannelId] != undefined) {
+ this.sockets[rChannelId].lme.txWindow += bytesToAdd;
+ if (!this.sockets[rChannelId].bufferedStream.isEmpty() && this.sockets[rChannelId].bufferedStream.isWaiting()) {
+ this.sockets[rChannelId].bufferedStream.emit('readable');
+ }
+ } else {
+ console.log('Unknown Recipient ID/' + rChannelId + ' for APF_CHANNEL_WINDOW_ADJUST');
+ }
+ break;
+ case APF_CHANNEL_DATA:
+ var rChannelId = chunk.readUInt32BE(1);
+ var dataLen = chunk.readUInt32BE(5);
+ var data = chunk.slice(9, 9 + dataLen);
+ if ((this.sockets != null) && (this.sockets[rChannelId] != undefined)) {
+ this.sockets[rChannelId].pendingBytes.push(data.length);
+ this.sockets[rChannelId].write(data, function () {
+ var written = this.pendingBytes.shift();
+ //console.log('adjust', this.lme.amtId, written);
+ var outBuffer = Buffer.alloc(9);
+ outBuffer.writeUInt8(APF_CHANNEL_WINDOW_ADJUST, 0);
+ outBuffer.writeUInt32BE(this.lme.amtId, 1);
+ outBuffer.writeUInt32BE(written, 5);
+ this.HECI.write(outBuffer);
+ });
+ } else if ((this.insockets != null) && (this.insockets[rChannelId] != undefined)) {
+ var channel = this.insockets[rChannelId];
+ if (channel.data == null) { channel.data = data.toString(); } else { channel.data += data.toString(); }
+ channel.rxWindow += dataLen;
+ //console.log('IN DATA', channel.rxWindow, channel.data.length, dataLen, channel.amtId, data.toString());
+ var httpData = parseHttp(channel.data);
+ if ((httpData != null) || (channel.data.length >= 8000)) {
+ // Parse the WSMAN
+ var notify = null;
+ try { notify = xmlParser.ParseWsman(httpData); } catch (e) { }
+
+ // Event the http data
+ if (notify != null) { this.LMS.emit('notify', notify, channel.options, _lmsNotifyToString(notify), _lmsNotifyToCode(notify)); }
+
+ // Send channel close
+ var buffer = Buffer.alloc(5);
+ buffer.writeUInt8(APF_CHANNEL_CLOSE, 0);
+ buffer.writeUInt32BE(amtId, 1);
+ this.write(buffer);
+ } else {
+ if (channel.rxWindow > 6000) {
+ // Send window adjust
+ var buffer = Buffer.alloc(9);
+ buffer.writeUInt8(APF_CHANNEL_WINDOW_ADJUST, 0);
+ buffer.writeUInt32BE(channel.amtId, 1);
+ buffer.writeUInt32BE(channel.rxWindow, 5);
+ this.write(buffer);
+ channel.rxWindow = 0;
+ }
+ }
+ } else {
+ console.log('Unknown Recipient ID/' + rChannelId + ' for APF_CHANNEL_DATA');
+ }
+ break;
+ case APF_CHANNEL_OPEN_FAILURE:
+ var rChannelId = chunk.readUInt32BE(1);
+ var reasonCode = chunk.readUInt32BE(5);
+ if ((this.sockets != null) && (this.sockets[rChannelId] != undefined)) {
+ this.sockets[rChannelId].end();
+ delete this.sockets[rChannelId];
+ } else if ((this.insockets != null) && (this.insockets[rChannelId] != undefined)) {
+ delete this.insockets[rChannelId];
+ } else {
+ console.log('Unknown Recipient ID/' + rChannelId + ' for APF_CHANNEL_OPEN_FAILURE');
+ }
+ break;
+ case APF_CHANNEL_CLOSE:
+ var rChannelId = chunk.readUInt32BE(1);
+ if ((this.sockets != null) && (this.sockets[rChannelId] != undefined)) {
+ this.sockets[rChannelId].end();
+ var amtId = this.sockets[rChannelId].lme.amtId;
+ var buffer = Buffer.alloc(5);
+ delete this.sockets[rChannelId];
+
+ buffer.writeUInt8(APF_CHANNEL_CLOSE, 0); // ????????????????????????????
+ buffer.writeUInt32BE(amtId, 1);
+ this.write(buffer);
+ } else if ((this.insockets != null) && (this.insockets[rChannelId] != undefined)) {
+ delete this.insockets[rChannelId];
+ // Should I send a close back????
+ } else {
+ console.log('Unknown Recipient ID/' + rChannelId + ' for APF_CHANNEL_CLOSE');
+ }
+ break;
+ case APF_CHANNEL_OPEN:
+ var nameLen = chunk.readUInt32BE(1);
+ var name = chunk.slice(5, nameLen + 5).toString();
+ var channelSender = chunk.readUInt32BE(nameLen + 5);
+ var initialWindowSize = chunk.readUInt32BE(nameLen + 9);
+ var hostToConnectLen = chunk.readUInt32BE(nameLen + 17);
+ var hostToConnect = chunk.slice(nameLen + 21, nameLen + 21 + hostToConnectLen).toString();
+ var portToConnect = chunk.readUInt32BE(nameLen + 21 + hostToConnectLen);
+ var originatorIpLen = chunk.readUInt32BE(nameLen + 25 + hostToConnectLen);
+ var originatorIp = chunk.slice(nameLen + 29 + hostToConnectLen, nameLen + 29 + hostToConnectLen + originatorIpLen).toString();
+ var originatorPort = chunk.readUInt32BE(nameLen + 29 + hostToConnectLen + originatorIpLen);
+ //console.log('APF_CHANNEL_OPEN', name, channelSender, initialWindowSize, 'From: ' + originatorIp + ':' + originatorPort, 'To: ' + hostToConnect + ':' + portToConnect);
+
+ if (this.insockets == null) { this.insockets = {}; }
+ var ourId = ++lme_id;
+ var insocket = new lme_object();
+ insocket.ourId = ourId;
+ insocket.amtId = channelSender;
+ insocket.txWindow = initialWindowSize;
+ insocket.rxWindow = 0;
+ insocket.options = { target: hostToConnect, targetPort: portToConnect, source: originatorIp, sourcePort: originatorPort };
+ this.insockets[ourId] = insocket;
+
+ var buffer = Buffer.alloc(17);
+ buffer.writeUInt8(APF_CHANNEL_OPEN_CONFIRMATION, 0);
+ buffer.writeUInt32BE(channelSender, 1); // Intel AMT sender channel
+ buffer.writeUInt32BE(ourId, 5); // Our receiver channel id
+ buffer.writeUInt32BE(4000, 9); // Initial Window Size
+ buffer.writeUInt32BE(0xFFFFFFFF, 13); // Reserved
+ this.write(buffer);
+
+ //var buffer = Buffer.alloc(17);
+ //buffer.writeUInt8(APF_CHANNEL_OPEN_FAILURE, 0);
+ //buffer.writeUInt32BE(channelSender, 1); // Intel AMT sender channel
+ //buffer.writeUInt32BE(2, 5); // Reason code
+ //buffer.writeUInt32BE(0, 9); // Reserved
+ //buffer.writeUInt32BE(0, 13); // Reserved
+ //this.write(buffer);
+ //console.log('Sent APF_CHANNEL_OPEN_FAILURE', channelSender);
+
+ break;
+ }
+ });
+ this.LMS.emit('connect');
+ this.resume();
+
+ });
+
+ this.bindDuplexStream = function (duplexStream, remoteFamily, localPort) {
+ var socket = duplexStream;
+ //console.log('New [' + remoteFamily + '] Virtual Connection/' + socket.localPort);
+ socket.pendingBytes = [];
+ socket.HECI = this._LME;
+ socket.LMS = this;
+ socket.lme = new lme_object();
+ socket.lme.Socket = socket;
+ socket.localPort = localPort;
+ var buffer = new MemoryStream();
+ buffer.writeUInt8(0x5A);
+ buffer.writeUInt32BE(15);
+ buffer.write('forwarded-tcpip');
+ buffer.writeUInt32BE(socket.lme.ourId);
+ buffer.writeUInt32BE(this.INITIAL_RXWINDOW_SIZE);
+ buffer.writeUInt32BE(0xFFFFFFFF);
+ for (var i = 0; i < 2; ++i) {
+ if (remoteFamily == 'IPv6') {
+ buffer.writeUInt32BE(3);
+ buffer.write('::1');
+ } else {
+ buffer.writeUInt32BE(9);
+ buffer.write('127.0.0.1');
+ }
+ buffer.writeUInt32BE(localPort);
+ }
+ this._LME.write(buffer.buffer);
+ if (this._LME.sockets == undefined) { this._LME.sockets = {}; }
+ this._LME.sockets[socket.lme.ourId] = socket;
+ socket.pause();
+ };
+
+ this._LME.connect(heci.GUIDS.LME, { noPipeline: 0 });
+}
+
+function parseHttp(httpData) {
+ var i = httpData.indexOf('\r\n\r\n');
+ if ((i == -1) || (httpData.length < (i + 2))) { return null; }
+ var headers = require('http-headers')(httpData.substring(0, i), true);
+ var contentLength = parseInt(headers['content-length']);
+ if (httpData.length >= contentLength + i + 4) { return httpData.substring(i + 4, i + 4 + contentLength); }
+ return null;
+}
+
+function _lmsNotifyToCode(notify) {
+ if ((notify == null) || (notify.Body == null) || (notify.Body.MessageID == null)) return null;
+ var msgid = notify.Body.MessageID;
+ try { msgid += '-' + notify.Body.MessageArguments[0]; } catch (e) { }
+ return msgid;
+}
+
+function _lmsNotifyToString(notify) {
+ if ((notify == null) || (notify.Body == null) || (notify.Body.MessageID == null)) return null;
+ var msgid = notify.Body.MessageID;
+ try { msgid += '-' + notify.Body.MessageArguments[0]; } catch (e) { }
+ if (lmsEvents[msgid]) { return lmsEvents[msgid]; }
+ return null;
+}
+
+var lmsEvents = {
+ "iAMT0001": "System Defense Policy %1s triggered.",
+ "iAMT0002": "Agent Presence Agent %1s not started.",
+ "iAMT0003": "Agent Presence Agent %1s stopped.",
+ "iAMT0004": "Agent Presence Agent %1s running.",
+ "iAMT0005": "Agent Presence Agent %1s expired.",
+ "iAMT0006": "Agent Presence Agent %1s suspended.",
+ "iAMT0007": "Host software attempt to disable AMT Network link detected.",
+ "iAMT0008": "Host software attempt to disable AMT Network link detected -- Host Network link blocked.",
+ "iAMT0009": "AMT clock or FLASH wear-out protection disabled.",
+ "iAMT0010": "Intel(R) AMT Network Interface %1s heuristics defense slow threshold trespassed.",
+ "iAMT0011": "Intel(R) AMT Network Interface %1s heuristics defense fast threshold trespassed.",
+ "iAMT0012": "Intel(R) AMT Network Interface %1s heuristics defense factory defined threshold trespassed.",
+ "iAMT0013": "Intel(R) AMT Network Interface %1s heuristics defense Encounter timeout expired.",
+ "iAMT0014": "General certificate error.",
+ "iAMT0015": "Certificate expired.",
+ "iAMT0016": "No trusted root certificate.",
+ "iAMT0017": "Not configured to work with server certificate.",
+ "iAMT0018": "Certificate revoked.",
+ "iAMT0019": "RSA exponent too large.",
+ "iAMT0020": "RSA modulus too large.",
+ "iAMT0021": "Unsupported digest.",
+ "iAMT0022": "Distinguished name too long.",
+ "iAMT0023": "Key usage missing.",
+ "iAMT0024": "General SSL handshake error.",
+ "iAMT0025": "General 802.1x error.",
+ "iAMT0026": "AMT Diagnostic AlertEAC error - General NAC error.",
+ "iAMT0027": "AMT Diagnostic AlertEAC error - attempt to get a NAC posture while AMT NAC is disabled.",
+ "iAMT0028": "AMT Diagnostic AlertEAC error - attempt to get a posture of an unsupported type.",
+ "iAMT0029": "Audit log storage is 50% full.",
+ "iAMT0030": "Audit log storage is 75% full.",
+ "iAMT0031": "Audit log storage is 85% full.",
+ "iAMT0032": "Audit log storage is 95% full.",
+ "iAMT0033": "Audit log storage is full.",
+ "iAMT0034": "Firmware Update Event - Partial.",
+ "iAMT0035": "Firmware Update Event - Failure.",
+ "iAMT0036": "Remote connectivity initiated.",
+ "iAMT0037": "ME Presence event.",
+ "iAMT0038-0": "AMT is being unprovisioned using BIOS command.",
+ "iAMT0038-1": "AMT is being unprovisioned using Local MEI command.",
+ "iAMT0038-2": "AMT is being unprovisioned using Local WS-MAN/SOAP command.",
+ "iAMT0038-3": "AMT is being unprovisioned using Remote WS-MAN/SOAP command.",
+ "iAMT0039": "HW Asset Error.",
+ "iAMT0050": "User Notification Alert - General Notification.",
+ "iAMT0050-16": "User Notification Alert - Circuit Breaker notification (CB Drop TX filter hit.).",
+ "iAMT0050-17": "User Notification Alert - Circuit Breaker notification (CB Rate Limit TX filter hit.).",
+ "iAMT0050-18": "User Notification Alert - Circuit Breaker notification (CB Drop RX filter hit.).",
+ "iAMT0050-19": "User Notification Alert - Circuit Breaker notification (CB Rate Limit RX filter hit.).",
+ "iAMT0050-32": "User Notification Alert - EAC notification.",
+ "iAMT0050-48": "User Notification Alert - Remote diagnostics - (Remote Redirection session started - SOL).",
+ "iAMT0050-49": "User Notification Alert - Remote diagnostics - (Remote Redirection session stopped - SOL).",
+ "iAMT0050-50": "User Notification Alert - Remote diagnostics. (Remote Redirection session started - IDE-R).",
+ "iAMT0050-51": "User Notification Alert - Remote diagnostics. (Remote Redirection session stopped - IDE-R).",
+ "iAMT0050-66": "User Notification Alert - WLAN notification (Host profile mismatch - Management Interface ignored).",
+ "iAMT0050-67": "User Notification Alert - WLAN notification (Management device overrides host radio).",
+ "iAMT0050-68": "User Notification Alert - WLAN notification (Host profile security mismatch).",
+ "iAMT0050-69": "User Notification Alert - WLAN notification (Management device relinquishes control over host Radio).",
+ "iAMT0051": "User Notification Alert - SecIo event.",
+ "iAMT0051-0": "User Notification Alert - SecIo event semaphore at host.",
+ "iAMT0051-1": "User Notification Alert - semaphore at ME.",
+ "iAMT0051-2": "User Notification Alert - SecIo event - semaphore timeout.",
+ "iAMT0052": "User Notification Alert - KVM session event.",
+ "iAMT0052-0": "User Notification Alert - KVM session requested.",
+ "iAMT0052-1": "User Notification Alert - KVM session started.",
+ "iAMT0052-2": "User Notification Alert - KVM session stopped.",
+ "iAMT0052-3": "User Notification Alert - KVM data channel.",
+ "iAMT0053": "User Notification Alert - RCS notification.",
+ "iAMT0053-50": "User Notification Alert - RCS notification (HW button pressed. Connection initiated automatically).",
+ "iAMT0053-52": "User Notification Alert - RCS notification (HW button pressed. Connection wasn't initiated automatically).",
+ "iAMT0053-53": "User Notification Alert - RCS notification (Contracts updated).",
+ "iAMT0054": "User Notification Alert - WLAN notification. Wireless Profile sync enablement state changed.",
+ "iAMT0055": "User Notification Alert - Provisioning state change notification.",
+ "iAMT0055-0": "User Notification Alert - Provisioning state change notification - Pre-configuration.",
+ "iAMT0055-1": "User Notification Alert - Provisioning state change notification - In configuration.",
+ "iAMT0055-2": "User Notification Alert - Provisioning state change notification - Post-configuration.",
+ "iAMT0055-3": "User Notification Alert - Provisioning state change notification - Unprovision process has started.",
+ "iAMT0056": "User Notification Alert - System Defense change notification.",
+ "iAMT0057": "User Notification Alert - Network State change notification.",
+ "iAMT0058": "User Notification Alert - Remote Access change notification.",
+ "iAMT0058-1": "User Notification Alert - Remote Access change notification - tunnel is closed.",
+ //"iAMT0058-1": "User Notification Alert - Remote Access change notification - tunnel is open.", // TODO
+ "iAMT0059": "User Notification Alert - KVM enabled event.",
+ "iAMT0059-0": "User Notification Alert - KVM enabled event - KVM disabled.",
+ "iAMT0059-1": "User Notification Alert - KVM enabled event - KVM enabled (both from MEBx and PTNI).",
+ "iAMT0060": "User Notification Alert - SecIO configuration event.",
+ "iAMT0061": "ME FW reset occurred.",
+ "iAMT0062": "User Notification Alert - IpSyncEnabled event.",
+ "iAMT0062-0": "User Notification Alert - IpSyncEnabled event - IpSync disabled.",
+ "iAMT0062-1": "User Notification Alert - IpSyncEnabled event - IpSync enabled.",
+ "iAMT0063": "User Notification Alert - HTTP Proxy sync enabled event.",
+ "iAMT0063-0": "User Notification Alert - HTTP Proxy sync enabled event - HTTP Proxy Sync disabled.",
+ "iAMT0063-1": "User Notification Alert - HTTP Proxy sync enabled event - HTTP Proxy Sync enabled.",
+ "iAMT0064": "User Notification Alert - User Consent event.",
+ "iAMT0064-1": "User Notification Alert - User Consent event - User Consent granted.",
+ "iAMT0064-2": "User Notification Alert - User Consent event - User Consent ended.",
+ "iAMT0067-0": "Graceful Remote Control Operation - Shutdown.",
+ "iAMT0067-1": "Graceful Remote Control Operation - Reset.",
+ "iAMT0067-2": "Graceful Remote Control Operation - Hibernate.",
+ "iAMT0068-0": "Link Protection Notification - No link protection.",
+ "iAMT0068-1": "Link Protection Notification - Passive link protection.",
+ "iAMT0068-2": "Link Protection Notification - High link protection.",
+ "iAMT0069-0": "Local Time Sync Enablement Notification - Local Time Sync Disabled.",
+ "iAMT0069-1": "Local Time Sync Enablement Notification - Local Time Sync Enabled.",
+ "iAMT0070": "Host Reset Triggered by WD Expiration Notification.",
+ "PLAT0004": "The chassis %1s was opened.",
+ "PLAT0005": "The chassis %1s was closed.",
+ "PLAT0006": "The drive bay %1s was opened.",
+ "PLAT0007": "The drive bay %1s was closed.",
+ "PLAT0008": "The I/O card area %1s was opened.",
+ "PLAT0009": "The I/O card area %1s was closed.",
+ "PLAT0010": "The processor area %1s was opened.",
+ "PLAT0011": "The processor area %1s was closed.",
+ "PLAT0012": "The LAN %1s has been disconnected.",
+ "PLAT0013": "The LAN %1s has been connected.",
+ "PLAT0016": "The permission to insert package %1s has been granted.",
+ "PLAT0017": "The permission to insert package %1s has been removed.",
+ "PLAT0018": "The fan card area %1s is open.",
+ "PLAT0019": "The fan card area %1s is closed.",
+ "PLAT0022": "The computer system %1s has detected a secure mode violation.",
+ "PLAT0024": "The computer system %1s has detected a pre-boot user password violation.",
+ "PLAT0026": "The computer system %1s has detected a pre-boot setup password violation.",
+ "PLAT0028": "The computer system %1s has detected a network boot password violation.",
+ "PLAT0030": "The computer system %1s has detected a password violation.",
+ "PLAT0032": "The management controller %1s has detected an out-of-band password violation.",
+ "PLAT0034": "The processor %1s has been added.",
+ "PLAT0035": "The processor %1s has been removed.",
+ "PLAT0036": "An over-temperature condition has been detected on the processor %1s.",
+ "PLAT0037": "An over-temperature condition has been removed on the processor %1s.",
+ "PLAT0038": "The processor %1s is operating in a degraded State.",
+ "PLAT0039": "The processor %1s is no longer operating in a degraded State.",
+ "PLAT0040": "The processor %1s has failed.",
+ "PLAT0042": "The processor %1s has failed.",
+ "PLAT0044": "The processor %1s has failed.",
+ "PLAT0046": "The processor %1s has failed.",
+ "PLAT0048": "The processor %1s has failed.",
+ "PLAT0060": "The processor %1s has been enabled.",
+ "PLAT0061": "The processor %1s has been disabled.",
+ "PLAT0062": "The processor %1s has a configuration mismatch.",
+ "PLAT0064": "A terminator has been detected on the processor %1s.",
+ "PLAT0084": "The Power Supply %1s has been added.",
+ "PLAT0085": "The Power Supply %1s has been removed.",
+ "PLAT0086": "The Power Supply %1s has failed.",
+ "PLAT0088": "Failure predicted on power supply %1s.",
+ "PLAT0096": "The input to power supply %1s has been lost or fallen out of range.",
+ "PLAT0098": "The power supply %1s is operating in an input state that is out of range.",
+ "PLAT0099": "The power supply %1s has returned to a normal input state.",
+ "PLAT0100": "The power supply %1s has lost input.",
+ "PLAT0104": "The power supply %1s has a configuration mismatch.",
+ "PLAT0106": "Power supply %1s has been disabled.",
+ "PLAT0107": "Power supply %1s has been enabled.",
+ "PLAT0108": "Power supply %1s has been power cycled.",
+ "PLAT0110": "Power supply %1s has encountered an error during power down.",
+ "PLAT0112": "Power supply %1s has lost power.",
+ "PLAT0114": "Soft power control has failed for power supply %1s.",
+ "PLAT0116": "Power supply %1s has failed.",
+ "PLAT0118": "Failure predicted on power supply %1s.",
+ "PLAT0120": "Memory subsystem failure.",
+ "PLAT0122": "DIMM missing.",
+ "PLAT0124": "Memory error detected & corrected for DIMM %1s.",
+ "PLAT0128": "Memory DIMM %1s added.",
+ "PLAT0129": "Memory DIMM %1s removed.",
+ "PLAT0130": "Memory DIMM %1s enabled.",
+ "PLAT0131": "Memory DIMM %1s disabled.",
+ "PLAT0134": "Memory parity error for DIMM %1s.",
+ "PLAT0136": "Memory scrub failure for DIMM %1s.",
+ "PLAT0138": "Memory uncorrectable error detected for DIMM %1s.",
+ "PLAT0140": "Memory sparing initiated for DIMM %1s.",
+ "PLAT0141": "Memory sparing concluded for DIMM %1s.",
+ "PLAT0142": "Memory DIMM %1s Throttled.",
+ "PLAT0144": "Memory logging limit reached for DIMM %1s.",
+ "PLAT0145": "Memory logging limit removed for DIMM %1s.",
+ "PLAT0146": "An over-temperature condition has been detected on the Memory DIMM %1s.",
+ "PLAT0147": "An over-temperature condition has been removed on the Memory DIMM %1s.",
+ "PLAT0162": "The drive %1s has been added.",
+ "PLAT0163": "The drive %1s has been removed.",
+ "PLAT0164": "The drive %1s has been disabled due to a detected fault.",
+ "PLAT0167": "The drive %1s has been enabled.",
+ "PLAT0168": "Failure predicted on drive %1s.",
+ "PLAT0170": "Hot spare enabled for %1s.",
+ "PLAT0171": "Hot spare disabled for %1s.",
+ "PLAT0172": "Consistency check has begun for %1s.",
+ "PLAT0173": "Consistency check completed for %1s.",
+ "PLAT0174": "Array %1s is in critical condition.",
+ "PLAT0176": "Array %1s has failed.",
+ "PLAT0177": "Array %1s has been restored.",
+ "PLAT0178": "Rebuild in progress for array %1s.",
+ "PLAT0179": "Rebuild completed for array %1s.",
+ "PLAT0180": "Rebuild Aborted for array %1s.",
+ "PLAT0184": "The system %1s encountered a POST error.",
+ "PLAT0186": "The system %1s encountered a firmware hang.",
+ "PLAT0188": "The system %1s encountered firmware progress.",
+ "PLAT0192": "The log %1s has been disabled.",
+ "PLAT0193": "The log %1s has been enabled.",
+ "PLAT0194": "The log %1s has been disabled.",
+ "PLAT0195": "The log %1s has been enabled.",
+ "PLAT0196": "The log %1s has been disabled.",
+ "PLAT0198": "The log %1s has been enabled.",
+ "PLAT0200": "The log %1s has been cleared.",
+ "PLAT0202": "The log %1s is full.",
+ "PLAT0203": "The log %1s is no longer full.",
+ "PLAT0204": "The log %1s is almost full.",
+ "PLAT0208": "The log %1s has a configuration error.",
+ "PLAT0210": "The system %1s has been reconfigured.",
+ "PLAT0212": "The system %1s has encountered an OEM system boot event.",
+ "PLAT0214": "The system %1s has encountered an unknown system hardware fault.",
+ "PLAT0216": "The system %1s has generated an auxiliary log entry.",
+ "PLAT0218": "The system %1s has executed a PEF action.",
+ "PLAT0220": "The system %1s has synchronized the system clock.",
+ "PLAT0222": "A diagnostic interrupt has occurred on system %1s.",
+ "PLAT0224": "A bus timeout has occurred on system %1s.",
+ "PLAT0226": "An I/O channel check NMI has occurred on system %1s.",
+ "PLAT0228": "A software NMI has occurred on system %1s.",
+ "PLAT0230": "System %1s has recovered from an NMI.",
+ "PLAT0232": "A PCI PERR has occurred on system %1s.",
+ "PLAT0234": "A PCI SERR has occurred on system %1s.",
+ "PLAT0236": "An EISA fail safe timeout occurred on system %1s.",
+ "PLAT0238": "A correctable bus error has occurred on system %1s.",
+ "PLAT0240": "An uncorrectable bus error has occurred on system %1s.",
+ "PLAT0242": "A fatal NMI error has occurred on system %1s.",
+ "PLAT0244": "A fatal bus error has occurred on system %1s.",
+ "PLAT0246": "A bus on system %1s is operating in a degraded state.",
+ "PLAT0247": "A bus on system %1s is no longer operating in a degraded state.",
+ "PLAT0248": "The power button %1s has been pressed.",
+ "PLAT0249": "The power button %1s has been released.",
+ "PLAT0250": "The sleep button %1s has been pressed.",
+ "PLAT0251": "The sleep button %1s has been released.",
+ "PLAT0252": "The reset button %1s has been pressed.",
+ "PLAT0253": "The reset button %1s has been released.",
+ "PLAT0254": "The latch to %1s has been opened.",
+ "PLAT0255": "The latch to %1s has been closed.",
+ "PLAT0256": "The service request %1s has been enabled.",
+ "PLAT0257": "The service request %1s has been completed.",
+ "PLAT0258": "Power control of system %1s has failed.",
+ "PLAT0262": "The network port %1s has been connected.",
+ "PLAT0263": "The network port %1s has been disconnected.",
+ "PLAT0266": "The connector %1s has encountered a configuration error.",
+ "PLAT0267": "The connector %1s configuration error has been repaired.",
+ "PLAT0272": "Power on for system %1s.",
+ "PLAT0274": "Power cycle hard requested for system %1s.",
+ "PLAT0276": "Power cycle soft requested for system %1s.",
+ "PLAT0278": "PXE boot requested for system %1s.",
+ "PLAT0280": "Diagnostics boot requested for system %1s.",
+ "PLAT0282": "System restart requested for system %1s.",
+ "PLAT0284": "System restart begun for system %1s.",
+ "PLAT0286": "No bootable media available for system %1s.",
+ "PLAT0288": "Non-bootable media selected for system %1s.",
+ "PLAT0290": "PXE server not found for system %1s.",
+ "PLAT0292": "User timeout on boot for system %1s.",
+ "PLAT0296": "System %1s boot from floppy initiated.",
+ "PLAT0298": "System %1s boot from local drive initiated.",
+ "PLAT0300": "System %1s boot from PXE on network port initiated.",
+ "PLAT0302": "System %1s boot diagnostics initiated.",
+ "PLAT0304": "System %1s boot from CD initiated.",
+ "PLAT0306": "System %1s boot from ROM initiated.",
+ "PLAT0312": "System %1s boot initiated.",
+ "PLAT0320": "Critical stop during OS load on system %1s.",
+ "PLAT0322": "Run-time critical stop on system %1s.",
+ "PLAT0324": "OS graceful stop on system %1s.",
+ "PLAT0326": "OS graceful shutdown begun on system %1s.",
+ "PLAT0327": "OS graceful shutdown completed on system %1s.",
+ "PLAT0328": "Agent not responding on system %1s.",
+ "PLAT0329": "Agent has begun responding on system %1s.",
+ "PLAT0330": "Fault in slot on system %1s.",
+ "PLAT0331": "Fault condition removed on system %1s.",
+ "PLAT0332": "Identifying slot on system %1s.",
+ "PLAT0333": "Identify stopped on slot for system %1s.",
+ "PLAT0334": "Package installed in slot for system %1s.",
+ "PLAT0336": "Slot empty system %1s.",
+ "PLAT0338": "Slot in system %1s is ready for installation.",
+ "PLAT0340": "Slot in system %1s is ready for removal.",
+ "PLAT0342": "Power is off on slot of system %1s.",
+ "PLAT0344": "Power is on for slot of system %1s.",
+ "PLAT0346": "Removal requested for slot of system %1s.",
+ "PLAT0348": "Interlock activated on slot of system %1s.",
+ "PLAT0349": "Interlock de-asserted on slot of system %1s.",
+ "PLAT0350": "Slot disabled on system %1s.",
+ "PLAT0351": "Slot enabled on system %1s.",
+ "PLAT0352": "Slot of system %1s holds spare.",
+ "PLAT0353": "Slot of system %1s no longer holds spare.",
+ "PLAT0354": "Computer system %1s enabled.",
+ "PLAT0356": "Computer system %1s is in sleep - light mode.",
+ "PLAT0358": "Computer system %1s is in hibernate.",
+ "PLAT0360": "Computer system %1s is in standby.",
+ "PLAT0362": "Computer system %1s is in soft off mode.",
+ "PLAT0364": "Computer system %1s is in hard off mode.",
+ "PLAT0366": "Computer system %1s is sleeping.",
+ "PLAT0368": "Watchdog timer expired for %1s.",
+ "PLAT0370": "Reboot of system initiated by watchdog %1s.",
+ "PLAT0372": "Powering off system initiated by watchdog %1s.",
+ "PLAT0374": "Power cycle of system initiated by watchdog %1s.",
+ "PLAT0376": "Watchdog timer interrupt occurred for %1s.",
+ "PLAT0378": "A page alert has been generated for system %1s.",
+ "PLAT0380": "A LAN alert has been generated for system %1s.",
+ "PLAT0382": "An event trap has been generated for system %1s.",
+ "PLAT0384": "An SNMP trap has been generated for system %1s.",
+ "PLAT0390": "%1s detected as present.",
+ "PLAT0392": "%1s detected as absent.",
+ "PLAT0394": "%1s has been disabled.",
+ "PLAT0395": "%1s has been enabled.",
+ "PLAT0396": "Heartbeat lost for LAN %1s.",
+ "PLAT0397": "Heartbeat detected for LAN %1s.",
+ "PLAT0398": "Sensor %1s is unavailable or degraded on management system.",
+ "PLAT0399": "Sensor %1s has returned to normal on management system.",
+ "PLAT0400": "Controller %1s is unavailable or degraded on management system.",
+ "PLAT0401": "Controller %1s has returned to normal on management system.",
+ "PLAT0402": "Management system %1s is off-line.",
+ "PLAT0404": "Management system %1s is disabled.",
+ "PLAT0405": "Management system %1s is enabled.",
+ "PLAT0406": "Sensor %1s has failed on management system.",
+ "PLAT0408": "FRU %1s has failed on management system.",
+ "PLAT0424": "The battery %1s is critically low.",
+ "PLAT0427": "The battery %1s is no longer critically low.",
+ "PLAT0430": "The battery %1s has been removed from unit.",
+ "PLAT0431": "The battery %1s has been added.",
+ "PLAT0432": "The battery %1s has failed.",
+ "PLAT0434": "Session audit is deactivated on system %1s.",
+ "PLAT0435": "Session audit is activated on system %1s.",
+ "PLAT0436": "A hardware change occurred on system %1s.",
+ "PLAT0438": "A firmware or software change occurred on system %1s.",
+ "PLAT0440": "A hardware incompatibility was detected on system %1s.",
+ "PLAT0442": "A firmware or software incompatibility was detected on system %1s.",
+ "PLAT0444": "Invalid or unsupported hardware was detected on system %1s.",
+ "PLAT0446": "Invalid or unsupported firmware or software was detected on system %1s.",
+ "PLAT0448": "A successful hardware change was detected on system %1s.",
+ "PLAT0450": "A successful software or firmware change was detected on system %1s.",
+ "PLAT0464": "FRU %1s not installed on system.",
+ "PLAT0465": "FRU %1s installed on system.",
+ "PLAT0466": "Activation requested for FRU %1s on system.",
+ "PLAT0467": "FRU %1s on system is active.",
+ "PLAT0468": "Activation in progress for FRU %1s on system.",
+ "PLAT0470": "Deactivation request for FRU %1s on system.",
+ "PLAT0471": "FRU %1s on system is in standby or \"hot spare\" state.",
+ "PLAT0472": "Deactivation in progress for FRU %1s on system.",
+ "PLAT0474": "Communication lost with FRU %1s on system.",
+ "PLAT0476": "Numeric sensor %1s going low (lower non-critical).",
+ "PLAT0478": "Numeric sensor %1s going high (lower non-critical).",
+ "PLAT0480": "Numeric sensor %1s going low (lower critical).",
+ "PLAT0482": "Numeric sensor %1s going high (lower critical).",
+ "PLAT0484": "Numeric sensor %1s going low (lower non-recoverable).",
+ "PLAT0486": "Numeric sensor %1s going high (lower non-critical).",
+ "PLAT0488": "Numeric sensor %1s going low (upper non-critical).",
+ "PLAT0490": "Numeric sensor %1s going high (upper non-critical).",
+ "PLAT0492": "Numeric sensor %1s going low (upper critical).",
+ "PLAT0494": "Numeric sensor %1s going high (upper critical).",
+ "PLAT0496": "Numeric sensor %1s going low (upper non-recoverable).",
+ "PLAT0498": "Numeric sensor %1s going high (upper non-recoverable).",
+ "PLAT0500": "Sensor %1s has transitioned to idle.",
+ "PLAT0502": "Sensor %1s has transitioned to active.",
+ "PLAT0504": "Sensor %1s has transitioned to busy.",
+ "PLAT0508": "Sensor %1s has asserted.",
+ "PLAT0509": "Sensor %1s has de-asserted.",
+ "PLAT0510": "Sensor %1s is asserting predictive failure.",
+ "PLAT0511": "Sensor %1s is de-asserting predictive failure.",
+ "PLAT0512": "Sensor %1s has indicated limit exceeded.",
+ "PLAT0513": "Sensor %1s has indicated limit no longer exceeded.",
+ "PLAT0514": "Sensor %1s has indicated performance met.",
+ "PLAT0516": "Sensor %1s has indicated performance lags.",
+ "PLAT0518": "Sensor %1s has transitioned to normal state.",
+ "PLAT0520": "Sensor %1s has transitioned from normal to non-critical state.",
+ "PLAT0522": "Sensor %1s has transitioned to critical from a less severe state.",
+ "PLAT0524": "Sensor %1s has transitioned to non-recoverable from a less severe state.",
+ "PLAT0526": "Sensor %1s has transitioned to non-critical from a more severe state.",
+ "PLAT0528": "Sensor %1s has transitioned to critical from a non-recoverable state.",
+ "PLAT0530": "Sensor %1s has transitioned to non-recoverable.",
+ "PLAT0532": "Sensor %1s indicates a monitor state.",
+ "PLAT0534": "Sensor %1s has an informational state.",
+ "PLAT0536": "Device %1s has been added.",
+ "PLAT0537": "Device %1s has been removed from unit.",
+ "PLAT0538": "Device %1s has been enabled.",
+ "PLAT0539": "Device %1s has been disabled.",
+ "PLAT0540": "Sensor %1s has indicated a running state.",
+ "PLAT0544": "Sensor %1s has indicated a power off state.",
+ "PLAT0546": "Sensor %1s has indicated an on-line state.",
+ "PLAT0548": "Sensor %1s has indicated an off-line state.",
+ "PLAT0550": "Sensor %1s has indicated an off-duty state.",
+ "PLAT0552": "Sensor %1s has indicated a degraded state.",
+ "PLAT0554": "Sensor %1s has indicated a power save state.",
+ "PLAT0556": "Sensor %1s has indicated an install error.",
+ "PLAT0558": "Redundancy %1s has been lost.",
+ "PLAT0560": "Redundancy %1s has been reduced.",
+ "PLAT0561": "Redundancy %1s has been restored.",
+ "PLAT0562": "%1s has transitioned to a D0 power state.",
+ "PLAT0564": "%1s has transitioned to a D1 power state.",
+ "PLAT0566": "%1s has transitioned to a D2 power state.",
+ "PLAT0568": "%1s has transitioned to a D3 power state.",
+ "PLAT0720": "The System %1s encountered firmware progress - memory initialization entry.",
+ "PLAT0721": "The System %1s encountered firmware progress - memory initialization exit.",
+ "PLAT0722": "The System %1s encountered firmware progress - hard drive initialization entry.",
+ "PLAT0723": "The System %1s encountered firmware progress - hard drive initialization exit.",
+ "PLAT0724": "The System %1s encountered firmware progress - user authentication.",
+ "PLAT0728": "The System %1s encountered firmware progress - USR resource configuration entry.",
+ "PLAT0729": "The System %1s encountered firmware progress - USR resource configuration exit.",
+ "PLAT0730": "The System %1s encountered firmware progress - PCI recource configuration entry.",
+ "PLAT0731": "The System %1s encountered firmware progress - PCI recource configuration exit.",
+ "PLAT0732": "The System %1s encountered firmware progress - Option ROM initialization entry.",
+ "PLAT0733": "The System %1s encountered firmware progress - Option ROM initialization entry exit.",
+ "PLAT0734": "The System %1s encountered firmware progress -video initialization entry entry.",
+ "PLAT0735": "The System %1s encountered firmware progress - video initialization entry exit.",
+ "PLAT0736": "The System %1s encountered firmware progress - cache initialization entry.",
+ "PLAT0737": "The System %1s encountered firmware progress - cache initialization exit.",
+ "PLAT0738": "The System %1s encountered firmware progress - keyboard controller initialization entry.",
+ "PLAT0739": "The System %1s encountered firmware progress - keyboard controller initialization exit.",
+ "PLAT0740": "The System %1s encountered firmware progress - motherboard initialization entry.",
+ "PLAT0741": "The System %1s encountered firmware progress - motherboard initialization exit.",
+ "PLAT0742": "The System %1s encountered firmware progress - floppy disk initialization entry.",
+ "PLAT0743": "The System %1s encountered firmware progress - floppy disk initialization exit.",
+ "PLAT0744": "The System %1s encountered firmware progress - keyboard test entry.",
+ "PLAT0745": "The System %1s encountered firmware progress - keyboard test exit.",
+ "PLAT0746": "The System %1s encountered firmware progress - pointing device test entry.",
+ "PLAT0747": "The System %1s encountered firmware progress - pointing device test exit.",
+ "PLAT0750": "The System %1s encountered firmware progress - dock enable entry.",
+ "PLAT0751": "The System %1s encountered firmware progress - dock enable exit.",
+ "PLAT0752": "The System %1s encountered firmware progress - dock disable entry.",
+ "PLAT0753": "The System %1s encountered firmware progress - dock disable exit.",
+ "PLAT0760": "The System %1s encountered firmware progress - start OS boot process.",
+ "PLAT0762": "The System %1s encountered firmware progress - call OS wake vector.",
+ "PLAT0764": "The System %1s encountered firmware progress - unrecoverable keyboard failure.",
+ "PLAT0766": "The System %1s encountered firmware progress - no video device detected.",
+ "PLAT0768": "The System %1s encountered firmware progress - SMART alert detected on drive.",
+ "PLAT0770": "The System %1s encountered firmware progress - unrecoverable boot device failure.",
+ "PLAT0789": "Corrupt BIOS detected.",
+ "PLAT0790": "The System %1s encountered PCI configuration failure.",
+ "PLAT0791": "The System %1s encountered a video subsystem failure.",
+ "PLAT0792": "The System %1s encountered a storage subsystem failure.",
+ "PLAT0793": "The System %1s encountered a USB subsystem failure.",
+ "PLAT0794": "The System %1s has detected no memory in the system.",
+ "PLAT0795": "The System %1s encountered a motherboard failure.",
+ "PLAT0796": "The System %1s encountered a memory Regulator Voltage Bad.",
+ "PLAT0797": "%1s PCI reset is not deasserting.",
+ "PLAT0798": "%1s Non-Motherboard Regulator Failure.",
+ "PLAT0799": "%1s Power Supply Cable failure.",
+ "PLAT0800": "%1s Motherboard regulator failure.",
+ "PLAT0801": "%1s System component compatibility mismatch."
+}
+
+module.exports = lme_heci;
diff --git a/agents/modules_meshcore_backup/amt-mei.js b/agents/modules_meshcore_backup/amt-mei.js
new file mode 100644
index 00000000..a6f0b17b
--- /dev/null
+++ b/agents/modules_meshcore_backup/amt-mei.js
@@ -0,0 +1,387 @@
+/*
+Copyright 2018 Intel Corporation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+var Q = require('queue');
+function amt_heci() {
+ var emitterUtils = require('events').inherits(this);
+ emitterUtils.createEvent('error');
+
+ var heci = require('heci');
+
+ this._ObjectID = "pthi";
+ this._rq = new Q();
+ this._setupPTHI = function _setupPTHI()
+ {
+ this._amt = heci.create();
+ this._amt.BiosVersionLen = 65;
+ this._amt.UnicodeStringLen = 20;
+
+ this._amt.Parent = this;
+ this._amt.on('error', function _amtOnError(e) { this.Parent.emit('error', e); });
+ this._amt.on('connect', function _amtOnConnect()
+ {
+ this.on('data', function _amtOnData(chunk)
+ {
+ //console.log("Received: " + chunk.length + " bytes");
+ var header = this.Parent.getCommand(chunk);
+ //console.log("CMD = " + header.Command + " (Status: " + header.Status + ") Response = " + header.IsResponse);
+
+ var user = this.Parent._rq.deQueue();
+ var params = user.optional;
+ var callback = user.func;
+
+ params.unshift(header);
+ callback.apply(this.Parent, params);
+
+ if(this.Parent._rq.isEmpty())
+ {
+ // No More Requests, we can close PTHI
+ this.Parent._amt.disconnect();
+ this.Parent._amt = null;
+ }
+ else
+ {
+ // Send the next request
+ this.write(this.Parent._rq.peekQueue().send);
+ }
+ });
+
+ // Start sending requests
+ this.write(this.Parent._rq.peekQueue().send);
+ });
+ };
+ function trim(x) { var y = x.indexOf('\0'); if (y >= 0) { return x.substring(0, y); } else { return x; } }
+ this.getCommand = function getCommand(chunk) {
+ var command = chunk.length == 0 ? (this._rq.peekQueue().cmd | 0x800000) : chunk.readUInt32LE(4);
+ var ret = { IsResponse: (command & 0x800000) == 0x800000 ? true : false, Command: (command & 0x7FFFFF), Status: chunk.length != 0 ? chunk.readUInt32LE(12) : -1, Data: chunk.length != 0 ? chunk.slice(16) : null };
+ return (ret);
+ };
+
+ this.sendCommand = function sendCommand() {
+ if (arguments.length < 3 || typeof (arguments[0]) != 'number' || typeof (arguments[1]) != 'object' || typeof (arguments[2]) != 'function') { throw ('invalid parameters'); }
+ var args = [];
+ for (var i = 3; i < arguments.length; ++i) { args.push(arguments[i]); }
+
+ var header = Buffer.from('010100000000000000000000', 'hex');
+ header.writeUInt32LE(arguments[0] | 0x04000000, 4);
+ header.writeUInt32LE(arguments[1] == null ? 0 : arguments[1].length, 8);
+ this._rq.enQueue({ cmd: arguments[0], func: arguments[2], optional: args , send: (arguments[1] == null ? header : Buffer.concat([header, arguments[1]]))});
+
+ if(!this._amt)
+ {
+ this._setupPTHI();
+ this._amt.connect(heci.GUIDS.AMT, { noPipeline: 1 });
+ }
+ }
+
+ this.getVersion = function getVersion(callback) {
+ var optional = [];
+ for (var i = 1; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(26, null, function (header, fn, opt) {
+ if (header.Status == 0) {
+ var i, CodeVersion = header.Data, val = { BiosVersion: CodeVersion.slice(0, this._amt.BiosVersionLen).toString(), Versions: [] }, v = CodeVersion.slice(this._amt.BiosVersionLen + 4);
+ for (i = 0; i < CodeVersion.readUInt32LE(this._amt.BiosVersionLen) ; ++i) {
+ val.Versions[i] = { Description: v.slice(2, v.readUInt16LE(0) + 2).toString(), Version: v.slice(4 + this._amt.UnicodeStringLen, 4 + this._amt.UnicodeStringLen + v.readUInt16LE(2 + this._amt.UnicodeStringLen)).toString() };
+ v = v.slice(4 + (2 * this._amt.UnicodeStringLen));
+ }
+ if (val.BiosVersion.indexOf('\0') > 0) { val.BiosVersion = val.BiosVersion.substring(0, val.BiosVersion.indexOf('\0')); }
+ opt.unshift(val);
+ } else {
+ opt.unshift(null);
+ }
+ fn.apply(this, opt);
+ }, callback, optional);
+ };
+
+ // Fill the left with zeros until the string is of a given length
+ function zeroLeftPad(str, len) {
+ if ((len == null) && (typeof (len) != 'number')) { return null; }
+ if (str == null) str = ''; // If null, this is to generate zero leftpad string
+ var zlp = '';
+ for (var i = 0; i < len - str.length; i++) { zlp += '0'; }
+ return zlp + str;
+ }
+
+ this.getUuid = function getUuid(callback) {
+ var optional = [];
+ for (var i = 1; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(0x5c, null, function (header, fn, opt) {
+ if (header.Status == 0) {
+ var result = {};
+ result.uuid = [zeroLeftPad(header.Data.readUInt32LE(0).toString(16), 8),
+ zeroLeftPad(header.Data.readUInt16LE(4).toString(16), 4),
+ zeroLeftPad(header.Data.readUInt16LE(6).toString(16), 4),
+ zeroLeftPad(header.Data.readUInt16BE(8).toString(16), 4),
+ zeroLeftPad(header.Data.slice(10).toString('hex').toLowerCase(), 12)].join('-');
+ opt.unshift(result);
+ } else {
+ opt.unshift(null);
+ }
+ fn.apply(this, opt);
+ }, callback, optional);
+ };
+
+ this.getProvisioningState = function getProvisioningState(callback) {
+ var optional = [];
+ for (var i = 1; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(17, null, function (header, fn, opt) {
+ if (header.Status == 0) {
+ var result = {};
+ result.state = header.Data.readUInt32LE(0);
+ if (result.state < 3) { result.stateStr = ["PRE", "IN", "POST"][result.state]; }
+ opt.unshift(result);
+ } else {
+ opt.unshift(null);
+ }
+ fn.apply(this, opt);
+ }, callback, optional);
+ };
+ this.getProvisioningMode = function getProvisioningMode(callback) {
+ var optional = [];
+ for (var i = 1; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(8, null, function (header, fn, opt) {
+ if (header.Status == 0) {
+ var result = {};
+ result.mode = header.Data.readUInt32LE(0);
+ if (result.mode < 4) { result.modeStr = ["NONE", "ENTERPRISE", "SMALL_BUSINESS", "REMOTE_ASSISTANCE"][result.mode]; }
+ result.legacy = header.Data.readUInt32LE(4) == 0 ? false : true;
+ opt.unshift(result);
+ } else {
+ opt.unshift(null);
+ }
+ fn.apply(this, opt);
+ }, callback, optional);
+ };
+ this.getEHBCState = function getEHBCState(callback) {
+ var optional = [];
+ for (var i = 1; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(132, null, function (header, fn, opt) {
+ if (header.Status == 0) {
+ opt.unshift({ EHBC: header.Data.readUInt32LE(0) != 0 });
+ } else {
+ opt.unshift(null);
+ }
+ fn.apply(this, opt);
+ }, callback, optional);
+ };
+ this.getControlMode = function getControlMode(callback) {
+ var optional = [];
+ for (var i = 1; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(107, null, function (header, fn, opt) {
+ if (header.Status == 0) {
+ var result = {};
+ result.controlMode = header.Data.readUInt32LE(0);
+ if (result.controlMode < 3) { result.controlModeStr = ["NONE_RPAT", "CLIENT", "ADMIN", "REMOTE_ASSISTANCE"][result.controlMode]; }
+ opt.unshift(result);
+ } else {
+ opt.unshift(null);
+ }
+ fn.apply(this, opt);
+ }, callback, optional);
+ };
+ this.getMACAddresses = function getMACAddresses(callback) {
+ var optional = [];
+ for (var i = 1; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(37, null, function (header, fn, opt) {
+ if (header.Status == 0) {
+ opt.unshift({ DedicatedMAC: header.Data.slice(0, 6).toString('hex:'), HostMAC: header.Data.slice(6, 12).toString('hex:') });
+ } else { opt.unshift({ DedicatedMAC: null, HostMAC: null }); }
+ fn.apply(this, opt);
+ }, callback, optional);
+ };
+ this.getDnsSuffix = function getDnsSuffix(callback) {
+ var optional = [];
+ for (var i = 1; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(54, null, function (header, fn, opt) {
+ if (header.Status == 0) {
+ var resultLen = header.Data.readUInt16LE(0);
+ if (resultLen > 0) { opt.unshift(header.Data.slice(2, 2 + resultLen).toString()); } else { opt.unshift(null); }
+ } else {
+ opt.unshift(null);
+ }
+ fn.apply(this, opt);
+ }, callback, optional);
+ };
+ this.getHashHandles = function getHashHandles(callback) {
+ var optional = [];
+ for (var i = 1; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(0x2C, null, function (header, fn, opt) {
+ var result = [];
+ if (header.Status == 0) {
+ var resultLen = header.Data.readUInt32LE(0);
+ for (var i = 0; i < resultLen; ++i) {
+ result.push(header.Data.readUInt32LE(4 + (4 * i)));
+ }
+ }
+ opt.unshift(result);
+ fn.apply(this, opt);
+ }, callback, optional);
+ };
+ this.getCertHashEntry = function getCertHashEntry(handle, callback) {
+ var optional = [];
+ for (var i = 2; i < arguments.length; ++i) { optional.push(arguments[i]); }
+
+ var data = new Buffer(4);
+ data.writeUInt32LE(handle, 0);
+
+ this.sendCommand(0x2D, data, function (header, fn, opt) {
+ if (header.Status == 0) {
+ var result = {};
+ result.isDefault = header.Data.readUInt32LE(0);
+ result.isActive = header.Data.readUInt32LE(4);
+ result.hashAlgorithm = header.Data.readUInt8(72);
+ if (result.hashAlgorithm < 4) {
+ result.hashAlgorithmStr = ["MD5", "SHA1", "SHA256", "SHA512"][result.hashAlgorithm];
+ result.hashAlgorithmSize = [16, 20, 32, 64][result.hashAlgorithm];
+ result.certificateHash = header.Data.slice(8, 8 + result.hashAlgorithmSize).toString('hex');
+ }
+ result.name = header.Data.slice(73 + 2, 73 + 2 + header.Data.readUInt16LE(73)).toString();
+ opt.unshift(result);
+ } else {
+ opt.unshift(null);
+ }
+ fn.apply(this, opt);
+ }, callback, optional);
+ };
+ this.getCertHashEntries = function getCertHashEntries(callback) {
+ var optional = [];
+ for (var i = 1; i < arguments.length; ++i) { optional.push(arguments[i]); }
+
+ this.getHashHandles(function (handles, fn, opt) {
+ var entries = [];
+ this.getCertHashEntry(handles.shift(), this._getHashEntrySink, fn, opt, entries, handles);
+ }, callback, optional);
+ };
+
+ this._getHashEntrySink = function _getHashEntrySink(result, fn, opt, entries, handles) {
+ entries.push(result);
+ if (handles.length > 0) {
+ this.getCertHashEntry(handles.shift(), this._getHashEntrySink, fn, opt, entries, handles);
+ } else {
+ opt.unshift(entries);
+ fn.apply(this, opt);
+ }
+ }
+ this.getLocalSystemAccount = function getLocalSystemAccount(callback) {
+ var optional = [];
+ for (var i = 1; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(103, Buffer.alloc(40), function (header, fn, opt) {
+ if (header.Data.length == 68) { opt.unshift({ user: trim(header.Data.slice(0, 33).toString()), pass: trim(header.Data.slice(33, 67).toString()), raw: header.Data }); } else { opt.unshift(null); }
+ fn.apply(this, opt);
+ }, callback, optional);
+ }
+ this.getLanInterfaceSettings = function getLanInterfaceSettings(index, callback)
+ {
+ var optional = [];
+ for (var i = 2; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ var ifx = Buffer.alloc(4);
+ ifx.writeUInt32LE(index);
+ this.sendCommand(0x48, ifx, function onGetLanInterfaceSettings(header, fn, opt)
+ {
+ if(header.Status == 0)
+ {
+ var info = {};
+ info.enabled = header.Data.readUInt32LE(0);
+ info.dhcpEnabled = header.Data.readUInt32LE(8);
+ switch(header.Data[12])
+ {
+ case 1:
+ info.dhcpMode = 'ACTIVE'
+ break;
+ case 2:
+ info.dhcpMode = 'PASSIVE'
+ break;
+ default:
+ info.dhcpMode = 'UNKNOWN';
+ break;
+ }
+ info.mac = header.Data.slice(14).toString('hex:');
+
+ var addr = header.Data.readUInt32LE(4);
+ info.address = ((addr >> 24) & 255) + '.' + ((addr >> 16) & 255) + '.' + ((addr >> 8) & 255) + '.' + (addr & 255);
+ opt.unshift(info);
+ fn.apply(this, opt);
+ }
+ else
+ {
+ opt.unshift(null);
+ fn.apply(this, opt);
+ }
+ }, callback, optional);
+
+ };
+ this.unprovision = function unprovision(mode, callback) {
+ var optional = [];
+ for (var i = 2; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ var data = new Buffer(4);
+ data.writeUInt32LE(mode, 0);
+ this.sendCommand(16, data, function (header, fn, opt) {
+ opt.unshift(header.Status);
+ fn.apply(this, opt);
+ }, callback, optional);
+ }
+ this.startConfiguration = function startConfiguration() {
+ var optional = [];
+ for (var i = 2; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(0x29, data, function (header, fn, opt) { opt.unshift(header.Status); fn.apply(this, opt); }, callback, optional);
+ }
+ this.stopConfiguration = function stopConfiguration() {
+ var optional = [];
+ for (var i = 2; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(0x5E, data, function (header, fn, opt) { opt.unshift(header.Status); fn.apply(this, opt); }, callback, optional);
+ }
+ this.openUserInitiatedConnection = function openUserInitiatedConnection() {
+ var optional = [];
+ for (var i = 2; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(0x44, data, function (header, fn, opt) { opt.unshift(header.Status); fn.apply(this, opt); }, callback, optional);
+ }
+ this.closeUserInitiatedConnection = function closeUnserInitiatedConnected() {
+ var optional = [];
+ for (var i = 2; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(0x45, data, function (header, fn, opt) { opt.unshift(header.Status); fn.apply(this, opt); }, callback, optional);
+ }
+ this.getRemoteAccessConnectionStatus = function getRemoteAccessConnectionStatus() {
+ var optional = [];
+ for (var i = 2; i < arguments.length; ++i) { optional.push(arguments[i]); }
+ this.sendCommand(0x46, data, function (header, fn, opt) {
+ if (header.Status == 0) {
+ var hostname = v.slice(14, header.Data.readUInt16LE(12) + 14).toString()
+ opt.unshift({ status: header.Status, networkStatus: header.Data.readUInt32LE(0), remoteAccessStatus: header.Data.readUInt32LE(4), remoteAccessTrigger: header.Data.readUInt32LE(8), mpsHostname: hostname, raw: header.Data });
+ } else {
+ opt.unshift({ status: header.Status });
+ }
+ fn.apply(this, opt);
+ }, callback, optional);
+ }
+ this.getProtocolVersion = function getProtocolVersion(callback) {
+ var optional = [];
+ for (var i = 1; i < arguments.length; ++i) { opt.push(arguments[i]); }
+
+ heci.doIoctl(heci.IOCTL.HECI_VERSION, Buffer.alloc(5), Buffer.alloc(5), function (status, buffer, self, fn, opt) {
+ if (status == 0) {
+ var result = buffer.readUInt8(0).toString() + '.' + buffer.readUInt8(1).toString() + '.' + buffer.readUInt8(2).toString() + '.' + buffer.readUInt16BE(3).toString();
+ opt.unshift(result);
+ fn.apply(self, opt);
+ }
+ else {
+ opt.unshift(null);
+ fn.apply(self, opt);
+ }
+ }, this, callback, optional);
+ }
+}
+
+module.exports = amt_heci;
\ No newline at end of file
diff --git a/agents/modules_meshcore_backup/amt-scanner.js b/agents/modules_meshcore_backup/amt-scanner.js
new file mode 100644
index 00000000..d82b6d8c
--- /dev/null
+++ b/agents/modules_meshcore_backup/amt-scanner.js
@@ -0,0 +1,105 @@
+/*
+Copyright 2018 Intel Corporation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+* @description Meshcentral Intel AMT Local Scanner
+* @author Ylian Saint-Hilaire & Joko Sastriawan
+* @version v0.0.1
+*/
+
+// Construct a Intel AMT Scanner object
+
+function AMTScanner() {
+ var emitterUtils = require('events').inherits(this);
+ emitterUtils.createEvent('found');
+
+ this.dgram = require('dgram');
+
+ this.buildRmcpPing = function (tag) {
+ var packet = Buffer.from('06000006000011BE80000000', 'hex');
+ packet[9] = tag;
+ return packet;
+ };
+
+ this.parseRmcpPacket = function (server, data, rinfo, func) {
+ if (data == null || data.length < 20) return;
+ var res = {};
+ if (((data[12] == 0) || (data[13] != 0) || (data[14] != 1) || (data[15] != 0x57)) && (data[21] & 32)) {
+ res.servertag = data[9];
+ res.minorVersion = data[18] & 0x0F;
+ res.majorVersion = (data[18] >> 4) & 0x0F;
+ res.provisioningState = data[19] & 0x03; // Pre = 0, In = 1, Post = 2
+
+ var openPort = (data[16] * 256) + data[17];
+ var dualPorts = ((data[19] & 0x04) != 0) ? true : false;
+ res.openPorts = [openPort];
+ res.address = rinfo.address;
+ if (dualPorts == true) { res.openPorts = [16992, 16993]; }
+ if (func !== undefined) {
+ func(server, res);
+ }
+ }
+ }
+
+ this.parseIPv4Range = function (range) {
+ if (range == undefined || range == null) return null;
+ var x = range.split('-');
+ if (x.length == 2) { return { min: this.parseIpv4Addr(x[0]), max: this.parseIpv4Addr(x[1]) }; }
+ x = range.split('/');
+ if (x.length == 2) {
+ var ip = this.parseIpv4Addr(x[0]), masknum = parseInt(x[1]), mask = 0;
+ if (masknum <= 16 || masknum > 32) return null;
+ masknum = 32 - masknum;
+ for (var i = 0; i < masknum; i++) { mask = (mask << 1); mask++; }
+ return { min: ip & (0xFFFFFFFF - mask), max: (ip & (0xFFFFFFFF - mask)) + mask };
+ }
+ x = this.parseIpv4Addr(range);
+ if (x == null) return null;
+ return { min: x, max: x };
+ };
+
+ // Parse IP address. Takes a
+ this.parseIpv4Addr = function (addr) {
+ var x = addr.split('.');
+ if (x.length == 4) { return (parseInt(x[0]) << 24) + (parseInt(x[1]) << 16) + (parseInt(x[2]) << 8) + (parseInt(x[3]) << 0); }
+ return null;
+ }
+
+ // IP address number to string
+ this.IPv4NumToStr = function (num) {
+ return ((num >> 24) & 0xFF) + '.' + ((num >> 16) & 0xFF) + '.' + ((num >> 8) & 0xFF) + '.' + (num & 0xFF);
+ }
+
+ this.scan = function (rangestr, timeout) {
+ var iprange = this.parseIPv4Range(rangestr);
+ var rmcp = this.buildRmcpPing(0);
+ var server = this.dgram.createSocket({ type: 'udp4' });
+ server.parent = this;
+ server.scanResults = [];
+ server.on('error', function (err) { console.log('Error:' + err); });
+ server.on('message', function (msg, rinfo) { if (rinfo.size > 4) { this.parent.parseRmcpPacket(this, msg, rinfo, function (s, res) { s.scanResults.push(res); }) }; });
+ server.on('listening', function () { for (var i = iprange.min; i <= iprange.max; i++) { server.send(rmcp, 623, server.parent.IPv4NumToStr(i)); } });
+ server.bind({ address: '0.0.0.0', port: 0, exclusive: true });
+ var tmout = setTimeout(function cb() {
+ //console.log("Server closed");
+ server.close();
+ server.parent.emit('found', server.scanResults);
+ delete server;
+ }, timeout);
+ };
+}
+
+module.exports = AMTScanner;
diff --git a/agents/modules_meshcore_backup/amt-wsman-duk.js b/agents/modules_meshcore_backup/amt-wsman-duk.js
new file mode 100644
index 00000000..7df52f1c
--- /dev/null
+++ b/agents/modules_meshcore_backup/amt-wsman-duk.js
@@ -0,0 +1,148 @@
+/*
+Copyright 2018 Intel Corporation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+* @description WSMAN communication using duktape http
+* @author Ylian Saint-Hilaire
+* @version v0.2.0c
+*/
+
+// Construct a WSMAN communication object
+function CreateWsmanComm(/*host, port, user, pass, tls, extra*/)
+{
+ var obj = {};
+ obj.PendingAjax = []; // List of pending AJAX calls. When one frees up, another will start.
+ obj.ActiveAjaxCount = 0; // Number of currently active AJAX calls
+ obj.MaxActiveAjaxCount = 1; // Maximum number of activate AJAX calls at the same time.
+ obj.FailAllError = 0; // Set this to non-zero to fail all AJAX calls with that error status, 999 causes responses to be silent.
+ obj.digest = null;
+ obj.RequestCount = 0;
+ obj.requests = {};
+
+ if (arguments.length == 1 && typeof(arguments[0] == 'object'))
+ {
+ obj.host = arguments[0].host;
+ obj.port = arguments[0].port;
+ obj.authToken = arguments[0].authToken;
+ obj.tls = arguments[0].tls;
+ }
+ else
+ {
+ obj.host = arguments[0];
+ obj.port = arguments[1];
+ obj.user = arguments[2];
+ obj.pass = arguments[3];
+ obj.tls = arguments[4];
+ }
+
+
+ // Private method
+ // pri = priority, if set to 1, the call is high priority and put on top of the stack.
+ obj.PerformAjax = function (postdata, callback, tag, pri, url, action) {
+ if ((obj.ActiveAjaxCount == 0 || ((obj.ActiveAjaxCount < obj.MaxActiveAjaxCount) && (obj.challengeParams != null))) && obj.PendingAjax.length == 0) {
+ // There are no pending AJAX calls, perform the call now.
+ obj.PerformAjaxEx(postdata, callback, tag, url, action);
+ } else {
+ // If this is a high priority call, put this call in front of the array, otherwise put it in the back.
+ if (pri == 1) { obj.PendingAjax.unshift([postdata, callback, tag, url, action]); } else { obj.PendingAjax.push([postdata, callback, tag, url, action]); }
+ }
+ }
+
+ // Private method
+ obj.PerformNextAjax = function () {
+ if (obj.ActiveAjaxCount >= obj.MaxActiveAjaxCount || obj.PendingAjax.length == 0) return;
+ var x = obj.PendingAjax.shift();
+ obj.PerformAjaxEx(x[0], x[1], x[2], x[3], x[4]);
+ obj.PerformNextAjax();
+ }
+
+ // Private method
+ obj.PerformAjaxEx = function (postdata, callback, tag, url, action) {
+ if (obj.FailAllError != 0) { if (obj.FailAllError != 999) { obj.gotNextMessagesError({ status: obj.FailAllError }, 'error', null, [postdata, callback, tag]); } return; }
+ if (!postdata) postdata = "";
+ //console.log("SEND: " + postdata); // DEBUG
+
+ // We are in a DukTape environement
+ if (obj.digest == null)
+ {
+ if (obj.authToken)
+ {
+ obj.digest = require('http-digest').create({ authToken: obj.authToken });
+ }
+ else
+ {
+ obj.digest = require('http-digest').create(obj.user, obj.pass);
+ }
+ obj.digest.http = require('http');
+ }
+ var request = { protocol: (obj.tls == 1 ? 'https:' : 'http:'), method: 'POST', host: obj.host, path: '/wsman', port: obj.port, rejectUnauthorized: false, checkServerIdentity: function (cert) { console.log('checkServerIdentity', JSON.stringify(cert)); } };
+ var req = obj.digest.request(request);
+ req.reqid = obj.RequestCount++;
+ obj.requests[req.reqid] = req; // Keep a reference to the request object so it does not get disposed.
+ //console.log('Request ' + (obj.RequestCount++));
+ req.on('error', function (e) { delete obj.requests[this.reqid]; obj.gotNextMessagesError({ status: 600 }, 'error', null, [postdata, callback, tag]); });
+ req.on('response', function (response) {
+ response.reqid = this.reqid;
+ //console.log('Response: ' + response.statusCode);
+ if (response.statusCode != 200) {
+ //console.log('ERR:' + JSON.stringify(response));
+ obj.gotNextMessagesError({ status: response.statusCode }, 'error', null, [postdata, callback, tag]);
+ } else {
+ response.acc = '';
+ response.on('data', function (data2) { this.acc += data2; });
+ response.on('end', function () { delete obj.requests[this.reqid]; obj.gotNextMessages(response.acc, 'success', { status: response.statusCode }, [postdata, callback, tag]); });
+ }
+ });
+
+ // Send POST body, this work with binary.
+ req.end(postdata);
+ obj.ActiveAjaxCount++;
+ return req;
+ }
+
+ // AJAX specific private method
+ obj.pendingAjaxCall = [];
+
+ // Private method
+ obj.gotNextMessages = function (data, status, request, callArgs) {
+ obj.ActiveAjaxCount--;
+ if (obj.FailAllError == 999) return;
+ //console.log("RECV: " + data); // DEBUG
+ if (obj.FailAllError != 0) { callArgs[1](null, obj.FailAllError, callArgs[2]); return; }
+ if (request.status != 200) { callArgs[1](null, request.status, callArgs[2]); return; }
+ callArgs[1](data, 200, callArgs[2]);
+ obj.PerformNextAjax();
+ }
+
+ // Private method
+ obj.gotNextMessagesError = function (request, status, errorThrown, callArgs) {
+ obj.ActiveAjaxCount--;
+ if (obj.FailAllError == 999) return;
+ if (obj.FailAllError != 0) { callArgs[1](null, obj.FailAllError, callArgs[2]); return; }
+ //if (status != 200) { console.log("ERROR, status=" + status + "\r\n\r\nreq=" + callArgs[0]); } // Debug: Display the request & response if something did not work.
+ if (obj.FailAllError != 999) { callArgs[1]({ Header: { HttpError: request.status } }, request.status, callArgs[2]); }
+ obj.PerformNextAjax();
+ }
+
+ // Cancel all pending queries with given status
+ obj.CancelAllQueries = function (s) {
+ while (obj.PendingAjax.length > 0) { var x = obj.PendingAjax.shift(); x[1](null, s, x[2]); }
+ }
+
+ return obj;
+}
+
+module.exports = CreateWsmanComm;
diff --git a/agents/modules_meshcore_backup/amt-wsman.js b/agents/modules_meshcore_backup/amt-wsman.js
new file mode 100644
index 00000000..5552917b
--- /dev/null
+++ b/agents/modules_meshcore_backup/amt-wsman.js
@@ -0,0 +1,211 @@
+/*
+Copyright 2018 Intel Corporation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+* @description Intel(r) AMT WSMAN Stack
+* @author Ylian Saint-Hilaire
+* @version v0.2.0
+*/
+
+// Construct a MeshServer object
+function WsmanStackCreateService(/*CreateWsmanComm, host, port, user, pass, tls, extra*/)
+{
+ var obj = {_ObjectID: 'WSMAN'};
+ //obj.onDebugMessage = null; // Set to a function if you want to get debug messages.
+ obj.NextMessageId = 1; // Next message number, used to label WSMAN calls.
+ obj.Address = '/wsman';
+ obj.xmlParser = require('amt-xml');
+
+ if (arguments.length == 1 && typeof (arguments[0] == 'object'))
+ {
+ var CreateWsmanComm = arguments[0].transport;
+ if (CreateWsmanComm) { obj.comm = new CreateWsmanComm(arguments[0]); }
+ }
+ else
+ {
+ var CreateWsmanComm = arguments[0];
+ if (CreateWsmanComm) { obj.comm = new CreateWsmanComm(arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6]); }
+ }
+
+ obj.PerformAjax = function PerformAjax(postdata, callback, tag, pri, namespaces) {
+ if (namespaces == null) namespaces = '';
+ obj.comm.PerformAjax('' + postdata, function (data, status, tag) {
+ if (status != 200) { callback(obj, null, { Header: { HttpError: status } }, status, tag); return; }
+ var wsresponse = obj.xmlParser.ParseWsman(data);
+ if (!wsresponse || wsresponse == null) { callback(obj, null, { Header: { HttpError: status } }, 601, tag); } else { callback(obj, wsresponse.Header["ResourceURI"], wsresponse, 200, tag); }
+ }, tag, pri);
+ }
+
+ // Private method
+ //obj.Debug = function (msg) { /*console.log(msg);*/ }
+
+ // Cancel all pending queries with given status
+ obj.CancelAllQueries = function CancelAllQueries(s) { obj.comm.CancelAllQueries(s); }
+
+ // Get the last element of a URI string
+ obj.GetNameFromUrl = function (resuri) {
+ var x = resuri.lastIndexOf("/");
+ return (x == -1)?resuri:resuri.substring(x + 1);
+ }
+
+ // Perform a WSMAN Subscribe operation
+ obj.ExecSubscribe = function ExecSubscribe(resuri, delivery, url, callback, tag, pri, selectors, opaque, user, pass) {
+ var digest = "", digest2 = "", opaque = "";
+ if (user != null && pass != null) { digest = 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#UsernameToken' + user + '' + pass + ''; digest2 = ''; }
+ if (opaque != null) { opaque = '' + opaque + ''; }
+ if (delivery == 'PushWithAck') { delivery = 'dmtf.org/wbem/wsman/1/wsman/PushWithAck'; } else if (delivery == 'Push') { delivery = 'xmlsoap.org/ws/2004/08/eventing/DeliveryModes/Push'; }
+ var data = "http://schemas.xmlsoap.org/ws/2004/08/eventing/Subscribe" + obj.Address + "" + resuri + "" + (obj.NextMessageId++) + "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous" + _PutObjToSelectorsXml(selectors) + digest + '' + url + '' + opaque + '' + digest2 + '';
+ obj.PerformAjax(data + "", callback, tag, pri, 'xmlns:e="http://schemas.xmlsoap.org/ws/2004/08/eventing" xmlns:m="http://x.com"');
+ }
+
+ // Perform a WSMAN UnSubscribe operation
+ obj.ExecUnSubscribe = function ExecUnSubscribe(resuri, callback, tag, pri, selectors) {
+ var data = "http://schemas.xmlsoap.org/ws/2004/08/eventing/Unsubscribe" + obj.Address + "" + resuri + "" + (obj.NextMessageId++) + "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous" + _PutObjToSelectorsXml(selectors) + '';
+ obj.PerformAjax(data + "", callback, tag, pri, 'xmlns:e="http://schemas.xmlsoap.org/ws/2004/08/eventing"');
+ }
+
+ // Perform a WSMAN PUT operation
+ obj.ExecPut = function ExecPut(resuri, putobj, callback, tag, pri, selectors) {
+ var data = "http://schemas.xmlsoap.org/ws/2004/09/transfer/Put" + obj.Address + "" + resuri + "" + (obj.NextMessageId++) + "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymousPT60.000S" + _PutObjToSelectorsXml(selectors) + '' + _PutObjToBodyXml(resuri, putobj);
+ obj.PerformAjax(data + "", callback, tag, pri);
+ }
+
+ // Perform a WSMAN CREATE operation
+ obj.ExecCreate = function ExecCreate(resuri, putobj, callback, tag, pri, selectors) {
+ var objname = obj.GetNameFromUrl(resuri);
+ var data = "http://schemas.xmlsoap.org/ws/2004/09/transfer/Create" + obj.Address + "" + resuri + "" + (obj.NextMessageId++) + "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymousPT60S" + _PutObjToSelectorsXml(selectors) + "";
+ for (var n in putobj) { data += "" + putobj[n] + "" }
+ obj.PerformAjax(data + "", callback, tag, pri);
+ }
+
+ // Perform a WSMAN DELETE operation
+ obj.ExecDelete = function ExecDelete(resuri, putobj, callback, tag, pri) {
+ var data = "http://schemas.xmlsoap.org/ws/2004/09/transfer/Delete" + obj.Address + "" + resuri + "" + (obj.NextMessageId++) + "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymousPT60S" + _PutObjToSelectorsXml(putobj) + "";
+ obj.PerformAjax(data, callback, tag, pri);
+ }
+
+ // Perform a WSMAN GET operation
+ obj.ExecGet = function ExecGet(resuri, callback, tag, pri) {
+ obj.PerformAjax("http://schemas.xmlsoap.org/ws/2004/09/transfer/Get" + obj.Address + "" + resuri + "" + (obj.NextMessageId++) + "http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymousPT60S", callback, tag, pri);
+ }
+
+ // Perform a WSMAN method call operation
+ obj.ExecMethod = function ExecMethod(resuri, method, args, callback, tag, pri, selectors) {
+ var argsxml = "";
+ for (var i in args) { if (args[i] != null) { if (Array.isArray(args[i])) { for (var x in args[i]) { argsxml += "