@electerm/ssh2 0.8.11 → 1.5.0

package/lib/utils.js

@@ -0,0 +1,336 @@
+'use strict';
+
+const { SFTP } = require('./protocol/SFTP.js');
+
+const MAX_CHANNEL = 2 ** 32 - 1;
+
+function onChannelOpenFailure(self, recipient, info, cb) {
+  self._chanMgr.remove(recipient);
+  if (typeof cb !== 'function')
+    return;
+
+  let err;
+  if (info instanceof Error) {
+    err = info;
+  } else if (typeof info === 'object' && info !== null) {
+    err = new Error(`(SSH) Channel open failure: ${info.description}`);
+    err.reason = info.reason;
+  } else {
+    err = new Error(
+      '(SSH) Channel open failure: server closed channel unexpectedly'
+    );
+    err.reason = '';
+  }
+
+  cb(err);
+}
+
+function onCHANNEL_CLOSE(self, recipient, channel, err, dead) {
+  if (typeof channel === 'function') {
+    // We got CHANNEL_CLOSE instead of CHANNEL_OPEN_FAILURE when
+    // requesting to open a channel
+    onChannelOpenFailure(self, recipient, err, channel);
+    return;
+  }
+
+  if (typeof channel !== 'object' || channel === null)
+    return;
+
+  if (channel.incoming && channel.incoming.state === 'closed')
+    return;
+
+  self._chanMgr.remove(recipient);
+
+  if (channel.server && channel.constructor.name === 'Session')
+    return;
+
+  channel.incoming.state = 'closed';
+
+  if (channel.readable)
+    channel.push(null);
+  if (channel.server) {
+    if (channel.stderr.writable)
+      channel.stderr.end();
+  } else if (channel.stderr.readable) {
+    channel.stderr.push(null);
+  }
+
+  if (channel.constructor !== SFTP
+      && (channel.outgoing.state === 'open'
+          || channel.outgoing.state === 'eof')
+      && !dead) {
+    channel.close();
+  }
+  if (channel.outgoing.state === 'closing')
+    channel.outgoing.state = 'closed';
+
+  const readState = channel._readableState;
+  const writeState = channel._writableState;
+  if (writeState && !writeState.ending && !writeState.finished && !dead)
+    channel.end();
+
+  // Take care of any outstanding channel requests
+  const chanCallbacks = channel._callbacks;
+  channel._callbacks = [];
+  for (let i = 0; i < chanCallbacks.length; ++i)
+    chanCallbacks[i](true);
+
+  if (channel.server) {
+    if (!channel.readable
+        || channel.destroyed
+        || (readState && readState.endEmitted)) {
+      channel.emit('close');
+    } else {
+      channel.once('end', () => channel.emit('close'));
+    }
+  } else {
+    let doClose;
+    switch (channel.type) {
+      case 'direct-streamlocal@openssh.com':
+      case 'direct-tcpip':
+        doClose = () => channel.emit('close');
+        break;
+      default: {
+        // Align more with node child processes, where the close event gets
+        // the same arguments as the exit event
+        const exit = channel._exit;
+        doClose = () => {
+          if (exit.code === null)
+            channel.emit('close', exit.code, exit.signal, exit.dump, exit.desc);
+          else
+            channel.emit('close', exit.code);
+        };
+      }
+    }
+    if (!channel.readable
+        || channel.destroyed
+        || (readState && readState.endEmitted)) {
+      doClose();
+    } else {
+      channel.once('end', doClose);
+    }
+
+    const errReadState = channel.stderr._readableState;
+    if (!channel.stderr.readable
+        || channel.stderr.destroyed
+        || (errReadState && errReadState.endEmitted)) {
+      channel.stderr.emit('close');
+    } else {
+      channel.stderr.once('end', () => channel.stderr.emit('close'));
+    }
+  }
+}
+
+class ChannelManager {
+  constructor(client) {
+    this._client = client;
+    this._channels = {};
+    this._cur = -1;
+    this._count = 0;
+  }
+  add(val) {
+    // Attempt to reserve an id
+
+    let id;
+    // Optimized paths
+    if (this._cur < MAX_CHANNEL) {
+      id = ++this._cur;
+    } else if (this._count === 0) {
+      // Revert and reset back to fast path once we no longer have any channels
+      // open
+      this._cur = 0;
+      id = 0;
+    } else {
+      // Slower lookup path
+
+      // This path is triggered we have opened at least MAX_CHANNEL channels
+      // while having at least one channel open at any given time, so we have
+      // to search for a free id.
+      const channels = this._channels;
+      for (let i = 0; i < MAX_CHANNEL; ++i) {
+        if (channels[i] === undefined) {
+          id = i;
+          break;
+        }
+      }
+    }
+
+    if (id === undefined)
+      return -1;
+
+    this._channels[id] = (val || true);
+    ++this._count;
+
+    return id;
+  }
+  update(id, val) {
+    if (typeof id !== 'number' || id < 0 || id >= MAX_CHANNEL || !isFinite(id))
+      throw new Error(`Invalid channel id: ${id}`);
+
+    if (val && this._channels[id])
+      this._channels[id] = val;
+  }
+  get(id) {
+    if (typeof id !== 'number' || id < 0 || id >= MAX_CHANNEL || !isFinite(id))
+      throw new Error(`Invalid channel id: ${id}`);
+
+    return this._channels[id];
+  }
+  remove(id) {
+    if (typeof id !== 'number' || id < 0 || id >= MAX_CHANNEL || !isFinite(id))
+      throw new Error(`Invalid channel id: ${id}`);
+
+    if (this._channels[id]) {
+      delete this._channels[id];
+      if (this._count)
+        --this._count;
+    }
+  }
+  cleanup(err) {
+    const channels = this._channels;
+    this._channels = {};
+    this._cur = -1;
+    this._count = 0;
+
+    const chanIDs = Object.keys(channels);
+    const client = this._client;
+    for (let i = 0; i < chanIDs.length; ++i) {
+      const id = +chanIDs[i];
+      const channel = channels[id];
+      onCHANNEL_CLOSE(client, id, channel._channel || channel, err, true);
+    }
+  }
+}
+
+const isRegExp = (() => {
+  const toString = Object.prototype.toString;
+  return (val) => toString.call(val) === '[object RegExp]';
+})();
+
+function generateAlgorithmList(algoList, defaultList, supportedList) {
+  if (Array.isArray(algoList) && algoList.length > 0) {
+    // Exact list
+    for (let i = 0; i < algoList.length; ++i) {
+      if (supportedList.indexOf(algoList[i]) === -1)
+        throw new Error(`Unsupported algorithm: ${algoList[i]}`);
+    }
+    return algoList;
+  }
+
+  if (typeof algoList === 'object' && algoList !== null) {
+    // Operations based on the default list
+    const keys = Object.keys(algoList);
+    let list = defaultList;
+    for (let i = 0; i < keys.length; ++i) {
+      const key = keys[i];
+      let val = algoList[key];
+      switch (key) {
+        case 'append':
+          if (!Array.isArray(val))
+            val = [val];
+          if (Array.isArray(val)) {
+            for (let j = 0; j < val.length; ++j) {
+              const append = val[j];
+              if (typeof append === 'string') {
+                if (!append || list.indexOf(append) !== -1)
+                  continue;
+                if (supportedList.indexOf(append) === -1)
+                  throw new Error(`Unsupported algorithm: ${append}`);
+                if (list === defaultList)
+                  list = list.slice();
+                list.push(append);
+              } else if (isRegExp(append)) {
+                for (let k = 0; k < supportedList.length; ++k) {
+                  const algo = supportedList[k];
+                  if (append.test(algo)) {
+                    if (list.indexOf(algo) !== -1)
+                      continue;
+                    if (list === defaultList)
+                      list = list.slice();
+                    list.push(algo);
+                  }
+                }
+              }
+            }
+          }
+          break;
+        case 'prepend':
+          if (!Array.isArray(val))
+            val = [val];
+          if (Array.isArray(val)) {
+            for (let j = val.length; j >= 0; --j) {
+              const prepend = val[j];
+              if (typeof prepend === 'string') {
+                if (!prepend || list.indexOf(prepend) !== -1)
+                  continue;
+                if (supportedList.indexOf(prepend) === -1)
+                  throw new Error(`Unsupported algorithm: ${prepend}`);
+                if (list === defaultList)
+                  list = list.slice();
+                list.unshift(prepend);
+              } else if (isRegExp(prepend)) {
+                for (let k = supportedList.length; k >= 0; --k) {
+                  const algo = supportedList[k];
+                  if (prepend.test(algo)) {
+                    if (list.indexOf(algo) !== -1)
+                      continue;
+                    if (list === defaultList)
+                      list = list.slice();
+                    list.unshift(algo);
+                  }
+                }
+              }
+            }
+          }
+          break;
+        case 'remove':
+          if (!Array.isArray(val))
+            val = [val];
+          if (Array.isArray(val)) {
+            for (let j = 0; j < val.length; ++j) {
+              const search = val[j];
+              if (typeof search === 'string') {
+                if (!search)
+                  continue;
+                const idx = list.indexOf(search);
+                if (idx === -1)
+                  continue;
+                if (list === defaultList)
+                  list = list.slice();
+                list.splice(idx, 1);
+              } else if (isRegExp(search)) {
+                for (let k = 0; k < list.length; ++k) {
+                  if (search.test(list[k])) {
+                    if (list === defaultList)
+                      list = list.slice();
+                    list.splice(k, 1);
+                    --k;
+                  }
+                }
+              }
+            }
+          }
+          break;
+      }
+    }
+
+    return list;
+  }
+
+  return defaultList;
+}
+
+module.exports = {
+  ChannelManager,
+  generateAlgorithmList,
+  onChannelOpenFailure,
+  onCHANNEL_CLOSE,
+  isWritable: (stream) => {
+    // XXX: hack to workaround regression in node
+    // See: https://github.com/nodejs/node/issues/36029
+    return (stream
+            && stream.writable
+            && stream._readableState
+            && stream._readableState.ended === false);
+  },
+};

package/package.json

@@ -1,16 +1,49 @@
-{ "name": "@electerm/ssh2",
-  "version": "0.8.11",
+{
+  "name": "@electerm/ssh2",
+  "version": "1.5.0",
   "author": "Brian White <mscdex@mscdex.net>",
   "description": "SSH2 client and server modules written in pure JavaScript for node.js",
-  "main": "./lib/client",
-  "engines": { "node": ">=5.2.0" },
+  "main": "./lib/index.js",
+  "engines": {
+    "node": ">=10.16.0"
+  },
   "dependencies": {
-    "ssh2-streams": "~0.4.10"
+    "asn1": "^0.2.4",
+    "bcrypt-pbkdf": "^1.0.2"
+  },
+  "devDependencies": {
+    "@mscdex/eslint-config": "^1.0.0",
+    "eslint": "^7.0.0"
+  },
+  "peerDependencies": {
+    "cpu-features": "0.0.2",
+    "nan": "^2.15.0"
   },
   "scripts": {
-    "test": "node test/test.js"
+    "install": "node install.js",
+    "rebuild": "node install.js",
+    "test": "node test/test.js",
+    "lint": "eslint --cache --report-unused-disable-directives --ext=.js .eslintrc.js examples lib test",
+    "lint:fix": "npm run lint -- --fix"
   },
-  "keywords": [ "ssh", "ssh2", "sftp", "secure", "shell", "exec", "remote", "client" ],
-  "licenses": [ { "type": "MIT", "url": "http://github.com/mscdex/ssh2/raw/master/LICENSE" } ],
-  "repository" : { "type": "git", "url": "http://github.com/mscdex/ssh2.git" }
+  "keywords": [
+    "ssh",
+    "ssh2",
+    "sftp",
+    "secure",
+    "shell",
+    "exec",
+    "remote",
+    "client"
+  ],
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/mscdex/ssh2/raw/master/LICENSE"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/mscdex/ssh2.git"
+  }
 }

package/lib/SFTPWrapper.js

@@ -1,145 +0,0 @@
-// This wrapper class is used to retain backwards compatibility with
-// pre-v0.4 ssh2. If it weren't for `read()` and `write()` being used by the
-// streams2/3 API, we could just pass the SFTPStream directly to the end user...
-
-var inherits = require('util').inherits;
-var EventEmitter = require('events').EventEmitter;
-
-function SFTPWrapper(stream) {
-  var self = this;
-
-  EventEmitter.call(this);
-
-  this._stream = stream;
-
-  stream.on('error', function(err) {
-    self.emit('error', err);
-  }).on('end', function() {
-    self.emit('end');
-  }).on('close', function() {
-    self.emit('close');
-  }).on('continue', function() {
-    self.emit('continue');
-  });
-}
-inherits(SFTPWrapper, EventEmitter);
-
-// stream-related methods to pass on
-SFTPWrapper.prototype.end = function() {
-  return this._stream.end();
-};
-// SFTPStream client methods
-SFTPWrapper.prototype.createReadStream = function(path, options) {
-  return this._stream.createReadStream(path, options);
-};
-SFTPWrapper.prototype.createWriteStream = function(path, options) {
-  return this._stream.createWriteStream(path, options);
-};
-SFTPWrapper.prototype.open = function(path, flags, attrs, cb) {
-  return this._stream.open(path, flags, attrs, cb);
-};
-SFTPWrapper.prototype.close = function(handle, cb) {
-  return this._stream.close(handle, cb);
-};
-SFTPWrapper.prototype.read = function(handle, buf, off, len, position, cb) {
-  return this._stream.readData(handle, buf, off, len, position, cb);
-};
-SFTPWrapper.prototype.write = function(handle, buf, off, len, position, cb) {
-  return this._stream.writeData(handle, buf, off, len, position, cb);
-};
-SFTPWrapper.prototype.fastGet = function(remotePath, localPath, opts, cb) {
-  return this._stream.fastGet(remotePath, localPath, opts, cb);
-};
-SFTPWrapper.prototype.fastPut = function(localPath, remotePath, opts, cb) {
-  return this._stream.fastPut(localPath, remotePath, opts, cb);
-};
-SFTPWrapper.prototype.readFile = function(path, options, callback_) {
-  return this._stream.readFile(path, options, callback_);
-};
-SFTPWrapper.prototype.writeFile = function(path, data, options, callback_) {
-  return this._stream.writeFile(path, data, options, callback_);
-};
-SFTPWrapper.prototype.appendFile = function(path, data, options, callback_) {
-  return this._stream.appendFile(path, data, options, callback_);
-};
-SFTPWrapper.prototype.exists = function(path, cb) {
-  return this._stream.exists(path, cb);
-};
-SFTPWrapper.prototype.unlink = function(filename, cb) {
-  return this._stream.unlink(filename, cb);
-};
-SFTPWrapper.prototype.rename = function(oldPath, newPath, cb) {
-  return this._stream.rename(oldPath, newPath, cb);
-};
-SFTPWrapper.prototype.mkdir = function(path, attrs, cb) {
-  return this._stream.mkdir(path, attrs, cb);
-};
-SFTPWrapper.prototype.rmdir = function(path, cb) {
-  return this._stream.rmdir(path, cb);
-};
-SFTPWrapper.prototype.readdir = function(where, opts, cb) {
-  return this._stream.readdir(where, opts, cb);
-};
-SFTPWrapper.prototype.fstat = function(handle, cb) {
-  return this._stream.fstat(handle, cb);
-};
-SFTPWrapper.prototype.stat = function(path, cb) {
-  return this._stream.stat(path, cb);
-};
-SFTPWrapper.prototype.lstat = function(path, cb) {
-  return this._stream.lstat(path, cb);
-};
-SFTPWrapper.prototype.opendir = function(path, cb) {
-  return this._stream.opendir(path, cb);
-};
-SFTPWrapper.prototype.setstat = function(path, attrs, cb) {
-  return this._stream.setstat(path, attrs, cb);
-};
-SFTPWrapper.prototype.fsetstat = function(handle, attrs, cb) {
-  return this._stream.fsetstat(handle, attrs, cb);
-};
-SFTPWrapper.prototype.futimes = function(handle, atime, mtime, cb) {
-  return this._stream.futimes(handle, atime, mtime, cb);
-};
-SFTPWrapper.prototype.utimes = function(path, atime, mtime, cb) {
-  return this._stream.utimes(path, atime, mtime, cb);
-};
-SFTPWrapper.prototype.fchown = function(handle, uid, gid, cb) {
-  return this._stream.fchown(handle, uid, gid, cb);
-};
-SFTPWrapper.prototype.chown = function(path, uid, gid, cb) {
-  return this._stream.chown(path, uid, gid, cb);
-};
-SFTPWrapper.prototype.fchmod = function(handle, mode, cb) {
-  return this._stream.fchmod(handle, mode, cb);
-};
-SFTPWrapper.prototype.chmod = function(path, mode, cb) {
-  return this._stream.chmod(path, mode, cb);
-};
-SFTPWrapper.prototype.readlink = function(path, cb) {
-  return this._stream.readlink(path, cb);
-};
-SFTPWrapper.prototype.symlink = function(targetPath, linkPath, cb) {
-  return this._stream.symlink(targetPath, linkPath, cb);
-};
-SFTPWrapper.prototype.realpath = function(path, cb) {
-  return this._stream.realpath(path, cb);
-};
-// extended requests
-SFTPWrapper.prototype.ext_openssh_rename = function(oldPath, newPath, cb) {
-  return this._stream.ext_openssh_rename(oldPath, newPath, cb);
-};
-SFTPWrapper.prototype.ext_openssh_statvfs = function(path, cb) {
-  return this._stream.ext_openssh_statvfs(path, cb);
-};
-SFTPWrapper.prototype.ext_openssh_fstatvfs = function(handle, cb) {
-  return this._stream.ext_openssh_fstatvfs(handle, cb);
-};
-SFTPWrapper.prototype.ext_openssh_hardlink = function(oldPath, newPath, cb) {
-  return this._stream.ext_openssh_hardlink(oldPath, newPath, cb);
-};
-SFTPWrapper.prototype.ext_openssh_fsync = function(handle, cb) {
-  return this._stream.ext_openssh_fsync(handle, cb);
-};
-
-module.exports = SFTPWrapper;

package/lib/buffer-helpers.js

@@ -1,22 +0,0 @@
-module.exports = {
-  readUInt32BE: function readUInt32BE(buf, offset) {
-    return buf[offset++] * 16777216
-           + buf[offset++] * 65536
-           + buf[offset++] * 256
-           + buf[offset];
-  },
-  writeUInt32BE: function writeUInt32BE(buf, value, offset) {
-    buf[offset++] = (value >>> 24);
-    buf[offset++] = (value >>> 16);
-    buf[offset++] = (value >>> 8);
-    buf[offset++] = value;
-    return offset;
-  },
-  writeUInt32LE: function writeUInt32LE(buf, value, offset) {
-    buf[offset++] = value;
-    buf[offset++] = (value >>> 8);
-    buf[offset++] = (value >>> 16);
-    buf[offset++] = (value >>> 24);
-    return offset;
-  }
-};

package/lib/keepalivemgr.js

@@ -1,80 +0,0 @@
-function spliceOne(list, index) {
-  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
-    list[i] = list[k];
-  list.pop();
-}
-
-function Manager(interval, streamInterval, kaCountMax) {
-  var streams = this._streams = [];
-  this._timer = undefined;
-  this._timerInterval = interval;
-  this._timerfn = function() {
-    var now = Date.now();
-    for (var i = 0, len = streams.length, s, last; i < len; ++i) {
-      s = streams[i];
-      last = s._kalast;
-      if (last && (now - last) >= streamInterval) {
-        if (++s._kacnt > kaCountMax) {
-          var err = new Error('Keepalive timeout');
-          err.level = 'client-timeout';
-          s.emit('error', err);
-          s.disconnect();
-          spliceOne(streams, i);
-          --i;
-          len = streams.length;
-        } else {
-          s._kalast = now;
-          // XXX: if the server ever starts sending real global requests to the
-          //      client, we will need to add a dummy callback here to keep the
-          //      correct reply order
-          s.ping();
-        }
-      }
-    }
-  };
-}
-
-Manager.prototype.start = function() {
-  if (this._timer)
-    this.stop();
-  this._timer = setInterval(this._timerfn, this._timerInterval);
-};
-
-Manager.prototype.stop = function() {
-  if (this._timer) {
-    clearInterval(this._timer);
-    this._timer = undefined;
-  }
-};
-
-Manager.prototype.add = function(stream) {
-  var streams = this._streams,
-      self = this;
-
-  stream.once('end', function() {
-    self.remove(stream);
-  }).on('packet', resetKA);
-
-  streams[streams.length] = stream;
-
-  resetKA();
-
-  if (!this._timer)
-    this.start();
-
-  function resetKA() {
-    stream._kalast = Date.now();
-    stream._kacnt = 0;
-  }
-};
-
-Manager.prototype.remove = function(stream) {
-  var streams = this._streams,
-      index = streams.indexOf(stream);
-  if (index > -1)
-    spliceOne(streams, index);
-  if (!streams.length)
-    this.stop();
-};
-
-module.exports = Manager;