Tracking de l'application VApp (IHM du jeu)

VApp/node_modules/ping/LICENSE

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

VApp/node_modules/ping/README.md

@@ -0,0 +1,209 @@
+# NODE-PING [![Build Status](https://app.travis-ci.com/danielzzz/node-ping.svg?branch=master)](https://app.travis-ci.com/danielzzz/node-ping)
+
+a ping wrapper for nodejs
+
+@last-modified: 2020-12-26
+
+# License MIT
+
+(C) Daniel Zelisko
+
+http://github.com/danielzzz/node-ping
+
+# Description
+
+node-ping is a simple wrapper for the system ping utility
+
+# Installation
+
+npm install ping
+
+# Usage
+
+Below are examples extracted from `examples`
+
+## Tradition calls
+
+```js
+var ping = require('ping');
+
+var hosts = ['192.168.1.1', 'google.com', 'yahoo.com'];
+hosts.forEach(function(host){
+    ping.sys.probe(host, function(isAlive){
+        var msg = isAlive ? 'host ' + host + ' is alive' : 'host ' + host + ' is dead';
+        console.log(msg);
+    });
+});
+```
+
+## Tradition calls with configuration
+
+```js
+var cfg = {
+    timeout: 10,
+    // WARNING: -i 2 may not work in other platform like windows
+    extra: ['-i', '2'],
+};
+
+hosts.forEach(function(host){
+    ping.sys.probe(host, function(isAlive){
+        var msg = isAlive ? 'host ' + host + ' is alive' : 'host ' + host + ' is dead';
+        console.log(msg);
+    }, cfg);
+});
+```
+
+## Promise wrapper
+
+```js
+var ping = require('ping');
+
+var hosts = ['192.168.1.1', 'google.com', 'yahoo.com'];
+
+hosts.forEach(function (host) {
+    ping.promise.probe(host)
+        .then(function (res) {
+            console.log(res);
+        });
+});
+```
+
+## Promise Wrapper with configurable ping options
+
+```js
+hosts.forEach(function (host) {
+    // WARNING: -i 2 argument may not work in other platform like windows
+    ping.promise.probe(host, {
+        timeout: 10,
+        extra: ['-i', '2'],
+    }).then(function (res) {
+        console.log(res);
+    });
+});
+```
+
+
+## Async-Await
+```js
+var ping = require('ping');
+
+var hosts = ['192.168.1.1', 'google.com', 'yahoo.com'];
+
+for(let host of hosts){
+    let res = await ping.promise.probe(host);
+    console.log(res);
+}
+```
+
+## Async-Await with configurable ping options
+```js
+var ping = require('ping');
+
+var hosts = ['192.168.1.1', 'google.com', 'yahoo.com'];
+
+for(let host of hosts){
+     // WARNING: -i 2 argument may not work in other platform like windows
+    let res = await ping.promise.probe(host, {
+           timeout: 10,
+           extra: ['-i', '2'],
+       });
+    console.log(res);
+}
+```
+### Support configuration
+
+Below is the possible configuration
+
+```js
+/**
+ * Cross platform config representation
+ * @typedef {Object} PingConfig
+ * @property {boolean} numeric - Map IP address to hostname or not
+ * @property {number} timeout - Timeout in seconds for each ping request.
+ * Behaviour varies between platforms. Check platform ping documentation for more information.
+ * @property {number} deadline - Specify a timeout, in seconds, before ping exits regardless of
+              how many packets have been sent or received. In this case ping
+              does not stop after count packet are sent, it waits either for
+              deadline expire or until count probes are answered or for some
+              error notification from network. This option is only available on linux and mac.
+ * @property {number} min_reply - Exit after sending number of ECHO_REQUEST
+ * @property {boolean} v6 - Ping via ipv6 or not. Default is false
+ * @property {string} sourceAddr - source address for sending the ping
+ * @property {number} packetSize - Specifies the number of data bytes to be sent
+                                   Default: Linux / MAC: 56 Bytes, Windows: 32 Bytes
+ * @property {string[]} extra - Optional options does not provided
+ */
+```
+
+### Output specification
+
+* For callback based implementation:
+
+```js
+/**
+ * Callback after probing given host
+ * @callback probeCallback
+ * @param {boolean} isAlive - Whether target is alive or not
+ * @param {Object} error - Null if no error occurs
+ */
+```
+
+* For promise based implementation
+
+```js
+/**
+ * Parsed response
+ * @typedef {object} PingResponse
+ * @param {string} inputHost - The input IP address or HOST
+ * @param {string} host - Parsed host from system command's output
+ * @param {string} numeric_host - Target IP address
+ * @param {boolean} alive - True for existed host
+ * @param {string} output - Raw stdout from system ping
+ * @param {number} time - Time (float) in ms for first successful ping response
+ * @param {Array} times - Array of Time (float) in ms for each ping response
+ * @param {string} min - Minimum time for collection records
+ * @param {string} max - Maximum time for collection records
+ * @param {string} avg - Average time for collection records
+ * @param {string} packetLoss - Packet Losses in percent (100% -> "100.000")
+ * @param {string} stddev - Standard deviation time for collected records
+ */
+```
+
+#### Note
+
+* Since `ping` in this module relies on the `ping` from underlying platform,
+arguments in `PingConfig.extra` will definitely be varied across different
+platforms.
+
+* However, `numeric`, `timeout` and `min_reply` have been abstracted. Values for
+them are expected to be cross platform.
+
+* By setting `numeric`, `timeout` or `min_reply` to false, you can run `ping`
+without corresponding arguments.
+
+# FAQ
+
+* It does not work with busybox's ping implemetation [#89](https://github.com/danielzzz/node-ping/issues/89)
+
+Try to install package `iputils`. For example, running `apk add iputils`
+
+* For questions regarding to the implementation of `timeout`, and `deadline`, please checkout discussions in
+  [#101](https://github.com/danielzzz/node-ping/issues/101)
+
+* For questions regarding to the defintions of `host`, `inputHost`, and `numeric_host`, please checkout
+  discussions in [#133](https://github.com/danielzzz/node-ping/issues/133)
+
+# Contributing
+
+Before opening a pull request please make sure your changes follow the
+[contribution guidelines][1].
+
+[1]: https://github.com/danielzzz/node-ping/blob/master/CONTRIBUTING.md
+
+
+# Contributors
+<a href="https://github.com/danielzzz/node-ping/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=danielzzz/node-ping" />
+</a>
+
+Made with [contrib.rocks](https://contrib.rocks).

VApp/node_modules/ping/index.js

@@ -0,0 +1,7 @@
+var ping = {};
+
+ping.sys = require('./lib/ping-sys');
+//ping.pcap = require('./lib/ping-pcap');
+ping.promise = require("./lib/ping-promise");
+
+module.exports = ping;

VApp/node_modules/ping/lib/builder/factory.js

@@ -0,0 +1,108 @@
+'use strict';
+
+var util = require('util');
+
+// Our library
+var linuxBuilder = require('./linux');
+var macBuilder = require('./mac');
+var winBuilder = require('./win');
+
+/**
+ * A factory creates argument builders for different platform
+ * @constructor
+ */
+function factory() {}
+
+/**
+ * Check out linux platform
+ */
+factory.isLinux = function (p) {
+    var platforms = [
+        'aix',
+        'android',
+        'linux',
+    ];
+
+    return platforms.indexOf(p) >= 0;
+};
+
+/**
+ * Check out macos platform
+ */
+factory.isMacOS = function (p) {
+    var platforms = [
+        'darwin',
+        'freebsd',
+    ];
+
+    return platforms.indexOf(p) >= 0;
+};
+
+/**
+ * Check out window platform
+ */
+factory.isWindow = function (p) {
+    return p && p.match(/^win/) !== null;
+};
+
+/**
+ * Check whether given platform is supported
+ * @param {string} p - Name of the platform
+ * @return {bool} - True or False
+ */
+factory.isPlatformSupport = function (p) {
+    return this.isWindow(p) || this.isLinux(p) || this.isMacOS(p);
+};
+
+/**
+ * Return a path to the ping executable in the system
+ * @param {string} platform - Name of the platform
+ * @param {bool} v6 - Ping via ipv6 or not
+ * @return {string} - Executable path for system command ping
+ * @throw if given platform is not supported
+ */
+factory.getExecutablePath = function (platform, v6) {
+    if (!this.isPlatformSupport(platform)) {
+        throw new Error(util.format('Platform |%s| is not support', platform));
+    }
+
+    var ret = null;
+
+    if (platform === 'aix') {
+        ret = '/usr/sbin/ping';
+    } else if (factory.isLinux(platform)) {
+        ret = v6 ? 'ping6' : 'ping';
+    } else if (factory.isWindow(platform)) {
+        ret = process.env.SystemRoot + '/system32/ping.exe';
+    } else if (factory.isMacOS(platform)) {
+        ret = v6 ? '/sbin/ping6' : '/sbin/ping';
+    }
+
+    return ret;
+};
+
+/**
+ * Create a builder
+ * @param {string} platform - Name of the platform
+ * @return {object} - Argument builder
+ * @throw if given platform is not supported
+ */
+factory.createBuilder = function (platform) {
+    if (!this.isPlatformSupport(platform)) {
+        throw new Error(util.format('Platform |%s| is not support', platform));
+    }
+
+    var ret = null;
+
+    if (factory.isLinux(platform)) {
+        ret = linuxBuilder;
+    } else if (factory.isWindow(platform)) {
+        ret = winBuilder;
+    } else if (factory.isMacOS(platform)) {
+        ret = macBuilder;
+    }
+
+    return ret;
+};
+
+module.exports = factory;

VApp/node_modules/ping/lib/builder/linux.js

@@ -0,0 +1,125 @@
+'use strict';
+
+/**
+ * A builder builds command line arguments for ping in linux environment
+ * @module lib/builder/linux
+ */
+var util = require('util');
+
+var builder = {};
+
+/**
+ * Cross platform config representation
+ * @typedef {Object} PingConfig
+ * @property {boolean} numeric - Map IP address to hostname or not
+ * @property {number} timeout - Time to wait for a response, in seconds.
+ * The option affects only timeout  in  absence  of any responses,
+ * otherwise ping waits for two RTTs.
+ * @property {number} deadline - Specify a timeout, in seconds,
+ * before ping exits regardless of how many packets have been sent or received.
+ * In this case ping does not stop after count packet are sent,
+ * it waits either for deadline expire or until count probes are answered
+ * or for some error notification from network.
+ * This option is only available on linux and mac.
+ * @property {number} min_reply - Exit after sending number of ECHO_REQUEST
+ * @property {boolean} v6 - Use IPv4 (default) or IPv6
+ * @property {string} sourceAddr - source address for sending the ping
+ * @property {number} packetSize - Specifies the number of data bytes to be sent
+ *                                 Default: Linux / MAC: 56 Bytes,
+ *                                          Window: 32 Bytes
+ * @property {string[]} extra - Optional options does not provided
+ */
+
+var defaultConfig = {
+    numeric: true,
+    timeout: 2,
+    deadline: false,
+    min_reply: 1,
+    v6: false,
+    sourceAddr: '',
+    packetSize: 56,
+    extra: [],
+};
+
+/**
+ * Get the finalized array of command line arguments
+ * @param {string} target - hostname or ip address
+ * @param {PingConfig} [config] - Configuration object for cmd line argument
+ * @return {string[]} - Command line argument according to the configuration
+ */
+builder.getCommandArguments = function (target, config) {
+    var _config = config || {};
+
+    // Empty argument
+    var ret = [];
+
+    // Make every key in config has been setup properly
+    var keys = ['numeric', 'timeout', 'deadline', 'min_reply', 'v6',
+        'sourceAddr', 'extra', 'packetSize'];
+    keys.forEach(function (k) {
+        // Falsy value will be overridden without below checking
+        if (typeof(_config[k]) !== 'boolean') {
+            _config[k] = _config[k] || defaultConfig[k];
+        }
+    });
+
+    if (_config.numeric) {
+        ret.push('-n');
+    }
+
+    if (_config.timeout) {
+        ret = ret.concat([
+            '-W',
+            util.format('%d', _config.timeout),
+        ]);
+    }
+
+    if (_config.deadline) {
+        ret = ret.concat([
+            '-w',
+            util.format('%d', _config.deadline),
+        ]);
+    }
+
+    if (_config.min_reply) {
+        ret = ret.concat([
+            '-c',
+            util.format('%d', _config.min_reply),
+        ]);
+    }
+
+    if (_config.sourceAddr) {
+        ret = ret.concat([
+            '-I',
+            util.format('%s', _config.sourceAddr),
+        ]);
+    }
+
+    if (_config.packetSize) {
+        ret = ret.concat([
+            '-s',
+            util.format('%d', _config.packetSize),
+        ]);
+    }
+
+    if (_config.extra) {
+        ret = ret.concat(_config.extra);
+    }
+
+    ret.push(target);
+
+    return ret;
+};
+
+/**
+ * Compute an option object for child_process.spawn
+ * @return {object} - Refer to document of child_process.spawn
+ */
+builder.getSpawnOptions = function () {
+    return {
+        shell: false,
+        env: Object.assign(process.env, {LANG: 'C'}),
+    };
+};
+
+module.exports = builder;

VApp/node_modules/ping/lib/builder/mac.js

@@ -0,0 +1,129 @@
+'use strict';
+
+/**
+ * A builder builds command line arguments for ping in mac environment
+ * @module lib/builder/mac
+ */
+var util = require('util');
+
+var builder = {};
+
+/**
+ * Cross platform config representation
+ * @typedef {Object} PingConfig
+ * @property {boolean} numeric - Map IP address to hostname or not
+ * @property {number} timeout - Time to wait for a response, in seconds.
+ * The option affects only timeout  in  absence  of any responses,
+ * otherwise ping waits for two RTTs.
+ * @property {number} deadline - Specify a timeout, in seconds,
+ * before ping exits regardless of how many packets have been sent or received.
+ * In this case ping does not stop after count packet are sent,
+ * it waits either for deadline expire or until count probes are answered
+ * or for some error notification from network.
+ * This option is only available on linux and mac.
+ * @property {number} min_reply - Exit after sending number of ECHO_REQUEST
+ * @property {boolean} v6 - Use IPv4 (default) or IPv6
+ * @property {string} sourceAddr - source address for sending the ping
+ * @property {number} packetSize - Specifies the number of data bytes to be sent
+ *                                 Default: Linux / MAC: 56 Bytes,
+ *                                          Window: 32 Bytes
+ * @property {string[]} extra - Optional options does not provided
+ */
+
+var defaultConfig = {
+    numeric: true,
+    timeout: 2,
+    deadline: false,
+    min_reply: 1,
+    v6: false,
+    sourceAddr: '',
+    packetSize: 56,
+    extra: [],
+};
+
+/**
+ * Get the finalized array of command line arguments
+ * @param {string} target - hostname or ip address
+ * @param {PingConfig} [config] - Configuration object for cmd line argument
+ * @return {string[]} - Command line argument according to the configuration
+ * @throws If there are errors on building arguments with given inputs
+ */
+builder.getCommandArguments = function (target, config) {
+    var _config = config || {};
+
+    // Empty argument
+    var ret = [];
+
+    // Make every key in config has been setup properly
+    var keys = ['numeric', 'timeout', 'deadline', 'min_reply', 'v6',
+        'sourceAddr', 'extra', 'packetSize'];
+    keys.forEach(function (k) {
+        // Falsy value will be overridden without below checking
+        if (typeof(_config[k]) !== 'boolean') {
+            _config[k] = _config[k] || defaultConfig[k];
+        }
+    });
+
+    if (_config.numeric) {
+        ret.push('-n');
+    }
+
+    if (_config.timeout) {
+        // XXX: There is no timeout option on mac's ping6
+        if (config.v6) {
+            throw new Error('There is no timeout option on ping6');
+        }
+
+        ret = ret.concat([
+            '-W',
+            util.format('%d', _config.timeout * 1000),
+        ]);
+    }
+
+    if (_config.deadline) {
+        ret = ret.concat([
+            '-t',
+            util.format('%d', _config.deadline),
+        ]);
+    }
+
+    if (_config.min_reply) {
+        ret = ret.concat([
+            '-c',
+            util.format('%d', _config.min_reply),
+        ]);
+    }
+
+    if (_config.sourceAddr) {
+        ret = ret.concat([
+            '-S',
+            util.format('%s', _config.sourceAddr),
+        ]);
+    }
+
+    if (_config.packetSize) {
+        ret = ret.concat([
+            '-s',
+            util.format('%d', _config.packetSize),
+        ]);
+    }
+
+    if (_config.extra) {
+        ret = ret.concat(_config.extra);
+    }
+
+    ret.push(target);
+
+    return ret;
+};
+
+/**
+ * Compute an option object for child_process.spawn
+ * @return {object} - Refer to document of child_process.spawn
+ */
+builder.getSpawnOptions = function () {
+    return {};
+};
+
+
+module.exports = builder;

VApp/node_modules/ping/lib/builder/win.js

@@ -0,0 +1,119 @@
+'use strict';
+
+/**
+ * A builder builds command line arguments for ping in window environment
+ * @module lib/builder/win
+ */
+var util = require('util');
+
+var builder = {};
+
+/**
+ * Cross platform config representation
+ * @typedef {Object} PingConfig
+ * @property {boolean} numeric - Map IP address to hostname or not
+ * @property {number} timeout - Timeout in seconds for each ping request
+ * @property {number} min_reply - Exit after sending number of ECHO_REQUEST
+ * @property {boolean} v6 - Use IPv4 (default) or IPv6
+ * @property {string} sourceAddr - source address for sending the ping
+ * @property {number} packetSize - Specifies the number of data bytes to be sent
+ *                                 Default: Linux / MAC: 56 Bytes,
+ *                                          Window: 32 Bytes
+ * @property {string[]} extra - Optional options does not provided
+ */
+
+var defaultConfig = {
+    numeric: true,
+    timeout: 5,
+    min_reply: 1,
+    v6: false,
+    sourceAddr: '',
+    packetSize: 32,
+    extra: [],
+};
+
+/**
+ * Get the finalized array of command line arguments
+ * @param {string} target - hostname or ip address
+ * @param {PingConfig} [config] - Configuration object for cmd line argument
+ * @return {string[]} - Command line argument according to the configuration
+ */
+builder.getCommandArguments = function (target, config) {
+    var _config = config || {};
+
+    // Empty argument
+    var ret = [];
+
+    // Make every key in config has been setup properly
+    var keys = [
+        'numeric', 'timeout', 'min_reply', 'v6', 'sourceAddr', 'extra',
+        'packetSize',
+    ];
+    keys.forEach(function (k) {
+        // Falsy value will be overrided without below checking
+        if (typeof(_config[k]) !== 'boolean') {
+            _config[k] = _config[k] || defaultConfig[k];
+        }
+    });
+
+    ret.push(_config.v6 ? '-6' : '-4');
+
+    if (!_config.numeric) {
+        ret.push('-a');
+    }
+
+    if (_config.timeout) {
+        // refs #56: Unit problem
+        // Our timeout is in second while timeout in window is in milliseconds
+        // so we need to convert our units accordingly
+        ret = ret.concat([
+            '-w',
+            util.format('%d', _config.timeout * 1000),
+        ]);
+    }
+
+    if (_config.deadline) {
+        throw new Error('There is no deadline option on windows');
+    }
+
+    if (_config.min_reply) {
+        ret = ret.concat([
+            '-n',
+            util.format('%d', _config.min_reply),
+        ]);
+    }
+
+    if (_config.sourceAddr) {
+        ret = ret.concat([
+            '-S',
+            util.format('%s', _config.sourceAddr),
+        ]);
+    }
+
+    if (_config.packetSize) {
+        ret = ret.concat([
+            '-l',
+            util.format('%d', _config.packetSize),
+        ]);
+    }
+
+    if (_config.extra) {
+        ret = ret.concat(_config.extra);
+    }
+
+    ret.push(target);
+
+    return ret;
+};
+
+/**
+ * Compute an option object for child_process.spawn
+ * @return {object} - Refer to document of child_process.spawn
+ */
+builder.getSpawnOptions = function () {
+    return {
+        windowsHide: true,
+    };
+};
+
+module.exports = builder;

VApp/node_modules/ping/lib/parser/base.js

@@ -0,0 +1,192 @@
+'use strict';
+
+/* eslint no-unused-vars: 0 */
+
+/**
+ * Parsed response
+ * @typedef {object} PingResponse
+ * @param {string} inputHost - The input IP address or HOST
+ * @param {string} host - The input IP address or HOST
+ * @param {string} numeric_host - Target IP address
+ * @param {boolean} alive - True for existed host
+ * @param {string} output - Raw stdout from system ping
+ * @param {number} time - Time (float) in ms for first successful ping response
+ * @param {string} min - Minimum time for collection records
+ * @param {string} max - Maximum time for collection records
+ * @param {string} avg - Average time for collection records
+ * @param {number} packetLoss - Packet Losses in percent (number)
+ * @param {string} stddev - Standard deviation time for collected records
+ */
+
+/**
+ * @constructor
+ * @param {string} addr - Hostname or ip addres
+ * @param {PingConfig} config - Config object in probe()
+ */
+function parser(addr, config) {
+    // Initial state is 0
+    this._state = 0;
+
+    // Initial cache value
+    this._response = {
+        inputHost: addr,
+        host: 'unknown',
+        alive: false,
+        output: 'unknown',
+        time: 'unknown',
+        times: [],
+        min: 'unknown',
+        max: 'unknown',
+        avg: 'unknown',
+        stddev: 'unknown',
+        packetLoss: 'unknown',
+    };
+
+    // Initial times storage for ping time
+    this._times = [];
+
+    // Initial lines storage for ping output
+    this._lines = [];
+
+    // strip string regexp
+    this._stripRegex = /[ ]*\r?\n?$/g;
+
+    // Ping Config
+    this._pingConfig = config || {};
+}
+
+/**
+ * Enum for parser states
+ * @readonly
+ * @enum {number}
+ */
+parser.prototype.STATES = {
+    INIT: 0,
+    HEADER: 1,
+    BODY: 2,
+    FOOTER: 3,
+    END: 4,
+};
+
+/**
+ * Change state of this parser
+ * @param {number} state - parser.STATES
+ * @return {this} - This instance
+ */
+parser.prototype._changeState = function (state) {
+    // var states = Object.values(this.STATES); // If minimum engine version can be raised to >=7.0.0 in package.json
+    var states = Object.keys(this.STATES).map(function (key) { return this.STATES[key]; }, this);
+    if (states.indexOf(state) < 0) {
+        throw new Error('Unknown state');
+    }
+
+    this._state = state;
+
+    return this;
+};
+
+/**
+ * Process output's header
+ * @param {string} line - A line from system ping
+ */
+parser.prototype._processHeader = function (line) {
+    throw new Error('Subclass should implement this method');
+};
+
+/**
+ * Process output's body
+ * @param {string} line - A line from system ping
+ */
+parser.prototype._processBody = function (line) {
+    throw new Error('Subclass should implement this method');
+};
+
+/**
+ * Process output's footer
+ * @param {string} line - A line from system ping
+ */
+parser.prototype._processFooter = function (line) {
+    throw new Error('Subclass should implement this method');
+};
+
+/**
+ * Process a line from system ping
+ * @param {string} line - A line from system ping
+ * @return {this} - This instance
+ */
+parser.prototype.eat = function (line) {
+    var headerStates = [this.STATES.INIT, this.STATES.HEADER];
+
+    // Store lines
+    this._lines.push(line);
+
+    // Strip all space \r\n at the end
+    var _line = line.replace(this._stripRegex, '');
+
+    if (_line.length === 0) {
+        // Do nothing if this is an empty line
+    } else if (headerStates.indexOf(this._state) >= 0) {
+        this._processHeader(_line);
+    } else if (this._state === this.STATES.BODY) {
+        this._processBody(_line);
+    } else if (this._state === this.STATES.FOOTER) {
+        this._processFooter(_line);
+    } else if (this._state === this.STATES.END) {
+        // Do nothing
+    } else {
+        throw new Error('Unknown state');
+    }
+
+    return this;
+};
+
+/**
+ * Get results after parsing certain lines from system ping
+ * @return {PingResponse} - Response from parsing ping output
+ */
+parser.prototype.getResult = function () {
+    var ret = Object.assign({}, this._response);
+
+    // Concat output
+    ret.output = this._lines.join('\n');
+
+    // Determine alive
+    ret.alive = this._times.length > 0;
+
+    // Update time at first successful line
+    if (ret.alive) {
+        this._response.time = this._times[0];
+        ret.time = this._response.time;
+        this._response.times = this._times;
+        ret.times = this._response.times;
+    }
+
+    // Get stddev
+    if (ret.stddev === 'unknown' && ret.alive) {
+        var numberOfSamples = this._times.length;
+
+        var sumOfAllSquareDifferences = this._times.reduce(
+            function (memory, time) {
+                var differenceFromMean = time - ret.avg;
+                var squaredDifference = differenceFromMean * differenceFromMean;
+                return memory + squaredDifference;
+            },
+            0
+        );
+        var variances = sumOfAllSquareDifferences / numberOfSamples;
+
+        ret.stddev = Math.round(Math.sqrt(variances) * 1000) / 1000;
+    }
+
+    // Fix min, avg, max, stddev up to 3 decimal points
+    ['min', 'avg', 'max', 'stddev', 'packetLoss'].forEach(function (key) {
+        var v = ret[key];
+        if (typeof v === 'number') {
+            ret[key] = v.toFixed(3);
+        }
+    });
+
+    return ret;
+};
+
+module.exports = parser;

VApp/node_modules/ping/lib/parser/factory.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var util = require('util');
+
+var builderFactory = require('../builder/factory');
+var WinParser = require('./win');
+var MacParser = require('./mac');
+var LinuxParser = require('./linux');
+
+/**
+ * A factory creates a parser for parsing output from system ping
+ * @constructor
+ */
+function factory() {}
+
+/**
+ * Create a parser for a given platform
+ * @param {string} addr - Hostname or ip addres
+ * @param {string} platform - Name of the platform
+ * @param {PingConfig} [config] - Config object in probe()
+ * @return {object} - Parser
+ * @throw if given platform is not supported
+ */
+factory.createParser = function (addr, platform, config) {
+    // Avoid function reassignment
+    var _config = config || {};
+
+    if (!builderFactory.isPlatformSupport(platform)) {
+        throw new Error(util.format('Platform |%s| is not support', platform));
+    }
+
+    var ret = null;
+    if (builderFactory.isWindow(platform)) {
+        ret = new WinParser(addr, _config);
+    } else if (builderFactory.isMacOS(platform)) {
+        ret = new MacParser(addr, _config);
+    } else if (builderFactory.isLinux(platform)) {
+        ret = new LinuxParser(addr, _config);
+    }
+
+    return ret;
+};
+
+module.exports = factory;

VApp/node_modules/ping/lib/parser/linux.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var util = require('util');
+var base = require('./base');
+var MacParser = require('./mac');
+
+/**
+ * @constructor
+ * @param {string} addr - Hostname or ip addres
+ * @param {PingConfig} config - Config object in probe()
+ */
+function LinuxParser(addr, config) {
+    base.call(this, addr, config);
+}
+
+util.inherits(LinuxParser, base);
+
+/**
+ * Process output's body
+ * @param {string} line - A line from system ping
+ */
+LinuxParser.prototype._processHeader = function (line) {
+    // Get host and numeric_host
+    var tokens = line.split(' ');
+    var isProbablyIPv4 = tokens[1].indexOf('(') === -1;
+
+    if (isProbablyIPv4) {
+        this._response.host = tokens[1];
+        this._response.numeric_host = tokens[2].slice(1, -1);
+    } else {
+        // Normalise into either a 2 or 3 element array
+        var foundAddresses = tokens
+            .slice(1, -3)
+            .join('')
+            .match(/([^\s()]+)/g);
+        this._response.host = foundAddresses.shift();
+        this._response.numeric_host = foundAddresses.pop();
+    }
+
+    this._changeState(this.STATES.BODY);
+};
+
+/**
+ * Process output's body
+ * @param {string} line - A line from system ping
+ */
+LinuxParser.prototype._processBody = function (line) {
+    // Reuse mac parser implementation
+    MacParser.prototype._processBody.call(this, line);
+};
+
+/**
+ * Process output's footer
+ * @param {string} line - A line from system ping
+ */
+LinuxParser.prototype._processFooter = function (line) {
+    // Reuse mac parser implementation
+    MacParser.prototype._processFooter.call(this, line);
+};
+
+module.exports = LinuxParser;

VApp/node_modules/ping/lib/parser/mac.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var util = require('util');
+var base = require('./base');
+
+/**
+ * @constructor
+ * @param {string} addr - Hostname or ip addres
+ * @param {PingConfig} config - Config object in probe()
+ */
+function MacParser(addr, config) {
+    base.call(this, addr, config);
+}
+
+util.inherits(MacParser, base);
+
+/**
+ * Process output's header
+ * @param {string} line - A line from system ping
+ */
+MacParser.prototype._processHeader = function (line) {
+    // Get host and numeric_host
+    var tokens = line.split(' ');
+
+    this._response.host = tokens[1];
+    this._response.numeric_host = tokens[2].slice(1, -2);
+
+    this._changeState(this.STATES.BODY);
+};
+
+/**
+ * Process output's body
+ * @param {string} line - A line from system ping
+ */
+MacParser.prototype._processBody = function (line) {
+    // XXX: Assume there is at least 3 '=' can be found
+    var count = (line.match(/=/g) || []).length;
+    if (count >= 3) {
+        var regExp = /([0-9.]+)[ ]*ms/;
+        var match = regExp.exec(line);
+        this._times.push(parseFloat(match[1], 10));
+    }
+
+    // Change state if it see a '---'
+    if (line.indexOf('---') >= 0) {
+        this._changeState(this.STATES.FOOTER);
+    }
+};
+
+/**
+ * Process output's footer
+ * @param {string} line - A line from system ping
+ */
+MacParser.prototype._processFooter = function (line) {
+    var packetLoss = line.match(/ ([\d.]+)%/);
+    if (packetLoss) {
+        this._response.packetLoss = parseFloat(packetLoss[1], 10);
+    }
+
+    // XXX: Assume number of keywords '/' more than 3
+    var count = (line.match(/[/]/g) || []).length;
+    if (count >= 3) {
+        var regExp = /([0-9.]+)/g;
+        // XXX: Assume min avg max stddev
+        var m1 = regExp.exec(line);
+        var m2 = regExp.exec(line);
+        var m3 = regExp.exec(line);
+        var m4 = regExp.exec(line);
+
+        if (m1 && m2 && m3 && m4) {
+            this._response.min = parseFloat(m1[1], 10);
+            this._response.avg = parseFloat(m2[1], 10);
+            this._response.max = parseFloat(m3[1], 10);
+            this._response.stddev = parseFloat(m4[1], 10);
+            this._changeState(this.STATES.END);
+        }
+
+        this._changeState(this.STATES.END);
+    }
+};
+
+module.exports = MacParser;

VApp/node_modules/ping/lib/parser/win.js

@@ -0,0 +1,182 @@
+'use strict';
+
+var util = require('util');
+var base = require('./base');
+
+/**
+ * @constructor
+ * @param {string} addr - Hostname or ip addres
+ * @param {PingConfig} config - Config object in probe()
+ */
+function WinParser(addr, config) {
+    base.call(this, addr, config);
+    this._ipv4Regex = /^([0-9]{1,3}\.){3}[0-9]{1,3}$/;
+}
+
+util.inherits(WinParser, base);
+
+/**
+ * Process output's header
+ * @param {string} line - A line from system ping
+ */
+WinParser.prototype._processHeader = function (line) {
+    // XXX: Expect to find [****] when pinging domain like google.com
+    //      Read fixture/win/**/* for the detail
+    var isPingNumeric = line.indexOf('[') === -1;
+
+    // Get host and numeric_host
+    var tokens = line.split(' ');
+
+    if (isPingNumeric) {
+        // For those missing [***], get the first token which match IPV4 regex
+        this._response.host = tokens.find(
+            function (t) {
+                return this._ipv4Regex.test(t);
+            },
+            this
+        );
+        this._response.numeric_host = this._response.host;
+    } else {
+        // For those has [***], anchor with such token
+        var numericHost = tokens.find(
+            function (t) {
+                return t.indexOf('[') !== -1;
+            },
+            this
+        );
+        var numericHostIndex = tokens.indexOf(numericHost);
+        var match = /\[(.*)\]/.exec(numericHost);
+
+        if (match) {
+            // Capture IP inside [] only. refs #71
+            this._response.numeric_host = match[1];
+        } else {
+            // Otherwise, just mark as NA to indicate an error
+            this._response.numeric_host = 'NA';
+        }
+        this._response.host = tokens[numericHostIndex - 1];
+    }
+
+    this._changeState(this.STATES.BODY);
+};
+
+/**
+ * Process ipv6 output's body
+ * @param {string} line - A line from system ping
+ */
+WinParser.prototype._processIPV6Body = function (line) {
+    var tokens = line.split(' ');
+    var dataFields = tokens.filter(function (token) {
+        var isDataField = token.indexOf('=') >= 0 || token.indexOf('<') >= 0;
+        return isDataField;
+    });
+
+    // refs #65: Support system like french which has an extra space
+    dataFields = dataFields.map(function (dataField) {
+        var ret = dataField;
+        var dataFieldIndex = tokens.indexOf(dataField);
+        var nextIndex = dataFieldIndex + 1;
+
+        // Append the missing *ms*
+        if (nextIndex < tokens.length) {
+            if (tokens[nextIndex] === 'ms') {
+                ret += 'ms';
+            }
+        }
+
+        return ret;
+    });
+
+    var expectDataFieldInReplyLine = 1;
+    if (dataFields.length >= expectDataFieldInReplyLine) {
+        // XXX: Assume time will alaways get keyword ms for all language
+        var timeKVP = dataFields.find(function (dataField) {
+            return dataField.search(/(ms|мс)/i) >= 0;
+        });
+        var regExp = /([0-9.]+)/;
+        var match = regExp.exec(timeKVP);
+
+        this._times.push(parseFloat(match[1], 10));
+    }
+};
+
+/**
+ * Process ipv4 output's body
+ * @param {string} line - A line from system ping
+ */
+WinParser.prototype._processIPV4Body = function (line) {
+    var tokens = line.split(' ');
+    var byteTimeTTLFields = tokens.filter(function (token) {
+        var isDataField = token.indexOf('=') >= 0 || token.indexOf('<') >= 0;
+        return isDataField;
+    });
+
+    var expectDataFieldInReplyLine = 3;
+    var isReplyLine = byteTimeTTLFields.length >= expectDataFieldInReplyLine;
+    if (isReplyLine) {
+        var packetSize = this._pingConfig.packetSize;
+        var byteField = byteTimeTTLFields.find(function (dataField) {
+            var packetSizeToken = util.format('=%d', packetSize);
+            var isByteField = dataField.indexOf(packetSizeToken) >= 0;
+            return isByteField;
+        });
+
+        // XXX: Assume time field will always be next of byte field
+        var byteFieldIndex = byteTimeTTLFields.indexOf(byteField);
+        var timeFieldIndex = byteFieldIndex + 1;
+        var timeKVP = byteTimeTTLFields[timeFieldIndex];
+
+        var regExp = /([0-9.]+)/;
+        var match = regExp.exec(timeKVP);
+
+        this._times.push(parseFloat(match[1], 10));
+    }
+};
+
+/**
+ * Process output's body
+ * @param {string} line - A line from system ping
+ */
+WinParser.prototype._processBody = function (line) {
+    var isPingSummaryLineShown = line.slice(-1) === ':';
+    if (isPingSummaryLineShown) {
+        this._changeState(this.STATES.FOOTER);
+        return;
+    }
+
+    var isIPV6 = this._pingConfig.v6;
+    if (isIPV6) {
+        this._processIPV6Body(line);
+    } else {
+        this._processIPV4Body(line);
+    }
+};
+
+/**
+ * Process output's footer
+ * @param {string} line - A line from system ping
+ */
+WinParser.prototype._processFooter = function (line) {
+    var packetLoss = line.match(/([\d.]+)%/);
+    if (packetLoss) {
+        this._response.packetLoss = parseFloat(packetLoss[1], 10);
+    }
+
+    // XXX: Assume there is a keyword ms
+    if (line.search(/(ms|мсек)/i) >= 0) {
+        // XXX: Assume the ordering is Min Max Avg
+        var regExp = /([0-9.]+)/g;
+        var m1 = regExp.exec(line);
+        var m2 = regExp.exec(line);
+        var m3 = regExp.exec(line);
+
+        if (m1 && m2 && m3) {
+            this._response.min = parseFloat(m1[1], 10);
+            this._response.max = parseFloat(m2[1], 10);
+            this._response.avg = parseFloat(m3[1], 10);
+            this._changeState(this.STATES.END);
+        }
+    }
+};
+
+module.exports = WinParser;

VApp/node_modules/ping/lib/ping-pcap.js

@@ -0,0 +1,46 @@
+/* eslint-disable */
+
+/** 
+* LICENSE MIT
+* (C) Daniel Zelisko
+* http://github.com/danielzzz/node-ping
+*
+* A poor man's ping for node.js
+* It uses UDP_scanning (as node is not able to generate iCPM packets)
+* http://en.wikipedia.org/wiki/Port_scanner#UDP_scanning
+* it may not work correct for hosts that silently drop UDP traffic on their firewall
+* you need at pcap version 0.1.9 or higher
+* 
+*/
+
+var sys = require("util"),
+pcap = require('pcap');
+    
+var addr = process.argv[3] || 'localhost';
+setInterval(function() {probe(addr)}, 1000);
+
+
+function probe(addr) {
+    sys.puts('sending a probe to ' + addr);
+    var dgram = require('dgram');
+    var message = new Buffer("Some bytes");
+    var client = dgram.createSocket("udp4");
+    client.send(message, 0, message.length, 21111, addr);
+    client.close(); 
+}
+
+// create a pcap session
+pcap_session = pcap.createSession(process.argv[2] || 'eth0', "");
+
+
+// listen for packets, decode them, and feed the simple printer
+pcap_session.addListener('packet', function (raw_packet) {
+    var packet = pcap.decode.packet(raw_packet);
+    if (packet.link && packet.link.ip && packet.link.ip.saddr==addr) {
+        packet.link && packet.link.ip && sys.puts(packet.link.ip.saddr + " is alive");
+    }
+});
+
+//-------- example ------------------------
+
+

VApp/node_modules/ping/lib/ping-promise.js

@@ -0,0 +1,105 @@
+'use strict';
+
+/**
+ * LICENSE MIT
+ * (C) Daniel Zelisko
+ * http://github.com/danielzzz/node-ping
+ *
+ * a simple wrapper for ping
+ * Now with support of not only english Windows.
+ *
+ */
+
+// System library
+var util = require('util');
+var net = require('net');
+var cp = require('child_process');
+var os = require('os');
+
+// Our library
+var builderFactory = require('./builder/factory');
+var parserFactory = require('./parser/factory');
+
+/**
+ * Refer to probe()
+ */
+function _probe(addr, config) {
+    // Do not reassign function argument
+    var _config = config || {};
+    if (_config.v6 === undefined) {
+        _config.v6 = net.isIPv6(addr);
+    }
+
+    // Convert callback base system command to promise base
+    return new Promise(function (resolve, reject) {
+        // Spawn a ping process
+        var ping = null;
+        var platform = os.platform();
+        try {
+            var argumentBuilder = builderFactory.createBuilder(platform);
+            var pingExecutablePath = builderFactory.getExecutablePath(platform, _config.v6);
+            var pingArgs = argumentBuilder.getCommandArguments(addr, _config);
+            var spawnOptions = argumentBuilder.getSpawnOptions();
+            ping = cp.spawn(pingExecutablePath, pingArgs, spawnOptions);
+        } catch (err) {
+            reject(err);
+            return;
+        }
+
+        // Initial parser
+        var parser = parserFactory.createParser(addr, platform, _config);
+
+        // Register events from system ping
+        ping.once('error', function () {
+            var err = new Error(
+                util.format(
+                    'ping.probe: %s. %s',
+                    'there was an error while executing the ping program. ',
+                    'Check the path or permissions...'
+                )
+            );
+            reject(err);
+        });
+
+        // Cache all lines from the system ping
+        var outstring = [];
+        ping.stdout.on('data', function (data) {
+            outstring.push(String(data));
+        });
+        ping.stderr.on('data', function (data) {
+            outstring.push(String(data));
+        });
+
+        // Parse lines we have on closing system ping
+        ping.once('close', function () {
+            // Merge lines we have and split it by \n
+            var lines = outstring.join('').split('\n');
+
+            // Parse line one by one
+            lines.forEach(parser.eat, parser);
+
+            // Get result
+            var ret = parser.getResult();
+
+            resolve(ret);
+        });
+    });
+}
+
+/**
+ * Class::PromisePing
+ * @param {string} addr - Hostname or ip addres
+ * @param {PingConfig} config - Configuration for command ping
+ * @return {Promise}
+ */
+function probe(addr, config) {
+    try {
+        var probePromise = _probe(addr, config);
+        return probePromise;
+    } catch (error) {
+        var errorPromise = Promise.reject(error);
+        return errorPromise;
+    }
+}
+
+exports.probe = probe;

VApp/node_modules/ping/lib/ping-sys.js

@@ -0,0 +1,44 @@
+'use strict';
+
+/**
+* LICENSE MIT
+* (C) Daniel Zelisko
+* http://github.com/danielzzz/node-ping
+*
+* a simple wrapper for ping
+* Now with support of not only english Windows.
+*
+*/
+
+// Promise implementation
+var ping = require('./ping-promise');
+
+// TODO:
+// 1. Port round trip time to this callback
+// 2. However, it may breaks backward compatability
+// 3. Need discussion
+/**
+ * Callback after probing given host
+ * @callback probeCallback
+ * @param {boolean} isAlive - Whether target is alive or not
+ * @param {Object} error - Null if no error occurs
+ */
+
+/**
+ * Class::Ping construtor
+ * @param {string} addr - Hostname or ip addres
+ * @param {probeCallback} cb - Callback
+ * @param {PingConfig} config - Configuration for command ping
+ */
+function probe(addr, cb, config) {
+    // Do not reassign function parameter
+    var _config = config || {};
+
+    return ping.probe(addr, _config).then(function (res) {
+        cb(res.alive, null);
+    }).catch(function (err) {
+        cb(null, err);
+    });
+}
+
+exports.probe = probe;

VApp/node_modules/ping/package.json

@@ -0,0 +1,67 @@
+{
+  "author": "danielzzz <daniel@zelisko.net> (http://daniel.zelisko.net)",
+  "scripts": {
+    "test": "grunt test"
+  },
+  "contributors": [
+    "Mond Wan <mondwan.1015@gmail.com>",
+    "dougluce <doug@tenousiperochhelical.con.com>",
+    "weihua44",
+    "GermanBluefox",
+    "mabukar",
+    "microacup <xiangmain@gmail.com>",
+    "Andrew Fadeev",
+    "Joshua Pruitt <firefly777@gmail.com>",
+    "Stephan van Rooij <stephan@svrooij.nl> (http://svrooij.nl)",
+    "Krispin Schulz <krispinone@googlemail.com> (http://kr1sp1n.io)",
+    "Kathy Hill",
+    "mrMuppet",
+    "Adam Heath <adam@adamheath.me> (http://www.adamheath.me)",
+    "BlessJah <blessjah@jacekowski.org>",
+    "jritsema"
+  ],
+  "name": "ping",
+  "description": "a simple wrapper for ping",
+  "version": "0.4.4",
+  "homepage": "http://github.com/danielzzz/node-ping",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/danielzzz/node-ping.git"
+  },
+  "engines": {
+    "node": ">=4.0.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.17.10",
+    "@babel/core": "^7.18.2",
+    "@babel/eslint-parser": "^7.18.2",
+    "@babel/preset-env": "^7.18.2",
+    "@types/glob": "^8.1.0",
+    "chai": "4.2.0",
+    "coveralls": "^3.1.1",
+    "eslint": "^8.16.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-config-eslint": "^7.0.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-jsdoc": "^39.3.2",
+    "eslint-plugin-jsx-a11y": "^6.5.1",
+    "eslint-plugin-react": "^7.30.0",
+    "eslint-plugin-react-hooks": "^4.5.0",
+    "glob": "^7.2.3",
+    "grunt": "^1.5.3",
+    "grunt-coveralls": "^2.0.0",
+    "grunt-eslint": "^24.0.0",
+    "grunt-mocha-test": "^0.13.3",
+    "grunt-nyc-mocha": "^1.1.0",
+    "mocha": "^10.0.0",
+    "nyc": "^15.1.0",
+    "sinon": "9.2.2"
+  },
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "lib/**/*",
+    "lib/*"
+  ]
+}