@electerm/ssh2 0.8.11 → 1.5.0

package/lib/Channel.js

@@ -1,508 +1,294 @@
-var inherits = require('util').inherits;
-var DuplexStream = require('stream').Duplex;
-var ReadableStream = require('stream').Readable;
-var WritableStream = require('stream').Writable;
-
-var STDERR = require('ssh2-streams').constants.CHANNEL_EXTENDED_DATATYPE.STDERR;
-
-var PACKET_SIZE = 32 * 1024;
-var MAX_WINDOW = 2 * 1024 * 1024;
-var WINDOW_THRESHOLD = MAX_WINDOW / 2;
-var CUSTOM_EVENTS = [
-  'CHANNEL_EOF',
-  'CHANNEL_CLOSE',
-  'CHANNEL_DATA',
-  'CHANNEL_EXTENDED_DATA',
-  'CHANNEL_WINDOW_ADJUST',
-  'CHANNEL_SUCCESS',
-  'CHANNEL_FAILURE',
-  'CHANNEL_REQUEST'
-];
-var CUSTOM_EVENTS_LEN = CUSTOM_EVENTS.length;
-
-function Channel(info, client, opts) {
-  var streamOpts = {
-    highWaterMark: MAX_WINDOW,
-    allowHalfOpen: (!opts || (opts && opts.allowHalfOpen !== false))
-  };
-
-  this.allowHalfOpen = streamOpts.allowHalfOpen;
-
-  DuplexStream.call(this, streamOpts);
-
-  var self = this;
-  var server = opts && opts.server;
-
-  this.server = server;
-  this.type = info.type;
-  this.subtype = undefined;
-  /*
-    incoming and outgoing contain these properties:
-    {
-      id: undefined,
-      window: undefined,
-      packetSize: undefined,
-      state: 'closed'
-    }
-  */
-  var incoming = this.incoming = info.incoming;
-  var incomingId = incoming.id;
-  var outgoing = this.outgoing = info.outgoing;
-  var callbacks = this._callbacks = [];
-  var exitCode;
-  var exitSignal;
-  var exitDump;
-  var exitDesc;
-  var exitLang;
-
-  this._client = client;
-  this._hasX11 = false;
-
-  var channels = client._channels;
-  var sshstream = client._sshstream;
-
-  function ondrain() {
-    if (self._waitClientDrain) {
-      self._waitClientDrain = false;
-      if (!self._waitWindow) {
-        if (self._chunk)
-          self._write(self._chunk, null, self._chunkcb);
-        else if (self._chunkcb)
-          self._chunkcb();
-        else if (self._chunkErr)
-          self.stderr._write(self._chunkErr, null, self._chunkcbErr);
-        else if (self._chunkcbErr)
-          self._chunkcbErr();
-      }
+'use strict';
+
+const {
+  Duplex: DuplexStream,
+  Readable: ReadableStream,
+  Writable: WritableStream,
+} = require('stream');
+
+const {
+  CHANNEL_EXTENDED_DATATYPE: { STDERR },
+} = require('./protocol/constants.js');
+const { bufferSlice } = require('./protocol/utils.js');
+
+const PACKET_SIZE = 32 * 1024;
+const MAX_WINDOW = 2 * 1024 * 1024;
+const WINDOW_THRESHOLD = MAX_WINDOW / 2;
+
+class ClientStderr extends ReadableStream {
+  constructor(channel, streamOpts) {
+    super(streamOpts);
+
+    this._channel = channel;
+  }
+  _read(n) {
+    if (this._channel._waitChanDrain) {
+      this._channel._waitChanDrain = false;
+      if (this._channel.incoming.window <= WINDOW_THRESHOLD)
+        windowAdjust(this._channel);
     }
   }
-  client._sock.on('drain', ondrain);
+}
 
-  sshstream.once('CHANNEL_EOF:' + incomingId, function() {
-    if (incoming.state !== 'open')
-      return;
-    incoming.state = 'eof';
-
-    if (self.readable)
-      self.push(null);
-    if (!server && self.stderr.readable)
-      self.stderr.push(null);
-  }).once('CHANNEL_CLOSE:' + incomingId, function() {
-    if (incoming.state === 'closed')
-      return;
-    incoming.state = 'closed';
-
-    if (self.readable)
-      self.push(null);
-    if (server && self.stderr.writable)
-      self.stderr.end();
-    else if (!server && self.stderr.readable)
-      self.stderr.push(null);
-
-    if (outgoing.state === 'open' || outgoing.state === 'eof')
-      self.close();
-    if (outgoing.state === 'closing')
-      outgoing.state = 'closed';
-
-    delete channels[incomingId];
-
-    var state = self._writableState;
-    client._sock.removeListener('drain', ondrain);
-    if (!state.ending && !state.finished)
-      self.end();
-
-    // Take care of any outstanding channel requests
-    self._callbacks = [];
-    for (var i = 0; i < callbacks.length; ++i)
-      callbacks[i](true);
-    callbacks = self._callbacks;
-
-    if (!server) {
-      // align more with node child processes, where the close event gets the
-      // same arguments as the exit event
-      if (!self.readable) {
-        if (exitCode === null) {
-          self.emit('close', exitCode, exitSignal, exitDump, exitDesc,
-                    exitLang);
-        } else
-          self.emit('close', exitCode);
-      } else {
-        self.once('end', function() {
-          if (exitCode === null) {
-            self.emit('close', exitCode, exitSignal, exitDump, exitDesc,
-                      exitLang);
-          } else
-            self.emit('close', exitCode);
-        });
-      }
+class ServerStderr extends WritableStream {
+  constructor(channel) {
+    super({ highWaterMark: MAX_WINDOW });
 
-      if (!self.stderr.readable)
-        self.stderr.emit('close');
-      else {
-        self.stderr.once('end', function() {
-          self.stderr.emit('close');
-        });
-      }
-    } else { // Server mode
-      if (!self.readable)
-        self.emit('close');
-      else {
-        self.once('end', function() {
-          self.emit('close');
-        });
-      }
-    }
+    this._channel = channel;
+  }
 
-    for (var i = 0; i < CUSTOM_EVENTS_LEN; ++i)
-      sshstream.removeAllListeners(CUSTOM_EVENTS[i] + ':' + incomingId);
-  }).on('CHANNEL_DATA:' + incomingId, function(data) {
-    // the remote party should not be sending us data if there is no window
-    // space available ...
-    // TODO: raise error on data with not enough window
-    if (incoming.window === 0)
+  _write(data, encoding, cb) {
+    const channel = this._channel;
+    const protocol = channel._client._protocol;
+    const outgoing = channel.outgoing;
+    const packetSize = outgoing.packetSize;
+    const id = outgoing.id;
+    let window = outgoing.window;
+    const len = data.length;
+    let p = 0;
+
+    if (outgoing.state !== 'open')
       return;
 
-    incoming.window -= data.length;
+    while (len - p > 0 && window > 0) {
+      let sliceLen = len - p;
+      if (sliceLen > window)
+        sliceLen = window;
+      if (sliceLen > packetSize)
+        sliceLen = packetSize;
 
-    if (!self.push(data)) {
-      self._waitChanDrain = true;
-      return;
-    }
+      if (p === 0 && sliceLen === len)
+        protocol.channelExtData(id, data, STDERR);
+      else
+        protocol.channelExtData(id, bufferSlice(data, p, p + sliceLen), STDERR);
 
-    if (incoming.window <= WINDOW_THRESHOLD)
-      windowAdjust(self);
-  }).on('CHANNEL_WINDOW_ADJUST:' + incomingId, function(amt) {
-    // the server is allowing us to send `amt` more bytes of data
-    outgoing.window += amt;
-
-    if (self._waitWindow) {
-      self._waitWindow = false;
-      if (!self._waitClientDrain) {
-        if (self._chunk)
-          self._write(self._chunk, null, self._chunkcb);
-        else if (self._chunkcb)
-          self._chunkcb();
-        else if (self._chunkErr)
-          self.stderr._write(self._chunkErr, null, self._chunkcbErr);
-        else if (self._chunkcbErr)
-          self._chunkcbErr();
-      }
-    }
-  }).on('CHANNEL_SUCCESS:' + incomingId, function() {
-    if (server) {
-      sshstream._kalast = Date.now();
-      sshstream._kacnt = 0;
-    } else
-      client._resetKA();
-    if (callbacks.length)
-      callbacks.shift()(false);
-  }).on('CHANNEL_FAILURE:' + incomingId, function() {
-    if (server) {
-      sshstream._kalast = Date.now();
-      sshstream._kacnt = 0;
-    } else
-      client._resetKA();
-    if (callbacks.length)
-      callbacks.shift()(true);
-  }).on('CHANNEL_REQUEST:' + incomingId, function(info) {
-    if (!server) {
-      if (info.request === 'exit-status') {
-        self.emit('exit', exitCode = info.code);
-        return;
-      } else if (info.request === 'exit-signal') {
-        self.emit('exit',
-                  exitCode = null,
-                  exitSignal = 'SIG' + info.signal,
-                  exitDump = info.coredump,
-                  exitDesc = info.description,
-                  exitLang = info.lang);
-        return;
-      }
+      p += sliceLen;
+      window -= sliceLen;
     }
 
-    // keepalive request? OpenSSH will send one as a channel request if there
-    // is a channel open
+    outgoing.window = window;
 
-    if (info.wantReply)
-      sshstream.channelFailure(outgoing.id);
-  });
+    if (len - p > 0) {
+      if (window === 0)
+        channel._waitWindow = true;
+      if (p > 0)
+        channel._chunkErr = bufferSlice(data, p, len);
+      else
+        channel._chunkErr = data;
+      channel._chunkcbErr = cb;
+      return;
+    }
 
-  this.stdin = this.stdout = this;
+    cb();
+  }
+}
 
-  if (server)
-    this.stderr = new ServerStderr(this);
-  else {
-    this.stderr = new ReadableStream(streamOpts);
-    this.stderr._read = function(n) {
-      if (self._waitChanDrain) {
-        self._waitChanDrain = false;
-        if (incoming.window <= WINDOW_THRESHOLD)
-          windowAdjust(self);
+class Channel extends DuplexStream {
+  constructor(client, info, opts) {
+    const streamOpts = {
+      highWaterMark: MAX_WINDOW,
+      allowHalfOpen: (!opts || (opts && opts.allowHalfOpen !== false)),
+      emitClose: false,
+    };
+    super(streamOpts);
+    this.allowHalfOpen = streamOpts.allowHalfOpen;
+
+    const server = !!(opts && opts.server);
+
+    this.server = server;
+    this.type = info.type;
+    this.subtype = undefined;
+
+    /*
+      incoming and outgoing contain these properties:
+      {
+        id: undefined,
+        window: undefined,
+        packetSize: undefined,
+        state: 'closed'
       }
+    */
+    this.incoming = info.incoming;
+    this.outgoing = info.outgoing;
+    this._callbacks = [];
+
+    this._client = client;
+    this._hasX11 = false;
+    this._exit = {
+      code: undefined,
+      signal: undefined,
+      dump: undefined,
+      desc: undefined,
     };
 
-    sshstream.on('CHANNEL_EXTENDED_DATA:' + incomingId,
-      function(type, data) {
-        // the remote party should not be sending us data if there is no window
-        // space available ...
-        // TODO: raise error on data with not enough window
-        if (incoming.window === 0)
-          return;
+    this.stdin = this.stdout = this;
 
-        incoming.window -= data.length;
+    if (server)
+      this.stderr = new ServerStderr(this);
+    else
+      this.stderr = new ClientStderr(this, streamOpts);
 
-        if (!self.stderr.push(data)) {
-          self._waitChanDrain = true;
-          return;
-        }
+    // Outgoing data
+    this._waitWindow = false; // SSH-level backpressure
 
-        if (incoming.window <= WINDOW_THRESHOLD)
-          windowAdjust(self);
-      }
-    );
-  }
+    // Incoming data
+    this._waitChanDrain = false; // Channel Readable side backpressure
 
-  // outgoing data
-  this._waitClientDrain = false; // Client stream-level backpressure
-  this._waitWindow = false; // SSH-level backpressure
+    this._chunk = undefined;
+    this._chunkcb = undefined;
+    this._chunkErr = undefined;
+    this._chunkcbErr = undefined;
 
-  // incoming data
-  this._waitChanDrain = false; // Channel Readable side backpressure
+    this.on('finish', onFinish)
+        .on('prefinish', onFinish); // For node v0.11+
 
-  this._chunk = undefined;
-  this._chunkcb = undefined;
-  this._chunkErr = undefined;
-  this._chunkcbErr = undefined;
-
-  function onFinish() {
-    self.eof();
-    if (server || (!server && !self.allowHalfOpen))
-      self.close();
-    self.writable = false;
-  }
-  this.on('finish', onFinish)
-      .on('prefinish', onFinish); // for node v0.11+
-  function onEnd() {
-    self.readable = false;
+    this.on('end', onEnd).on('close', onEnd);
   }
-  this.on('end', onEnd)
-      .on('close', onEnd);
-}
-inherits(Channel, DuplexStream);
-
-Channel.prototype.eof = function() {
-  var ret = true;
-  var outgoing = this.outgoing;
 
-  if (outgoing.state === 'open') {
-    outgoing.state = 'eof';
-    ret = this._client._sshstream.channelEOF(outgoing.id);
+  _read(n) {
+    if (this._waitChanDrain) {
+      this._waitChanDrain = false;
+      if (this.incoming.window <= WINDOW_THRESHOLD)
+        windowAdjust(this);
+    }
   }
 
-  return ret;
-};
+  _write(data, encoding, cb) {
+    const protocol = this._client._protocol;
+    const outgoing = this.outgoing;
+    const packetSize = outgoing.packetSize;
+    const id = outgoing.id;
+    let window = outgoing.window;
+    const len = data.length;
+    let p = 0;
 
-Channel.prototype.close = function() {
-  var ret = true;
-  var outgoing = this.outgoing;
+    if (outgoing.state !== 'open')
+      return;
 
-  if (outgoing.state === 'open' || outgoing.state === 'eof') {
-    outgoing.state = 'closing';
-    ret = this._client._sshstream.channelClose(outgoing.id);
-  }
+    while (len - p > 0 && window > 0) {
+      let sliceLen = len - p;
+      if (sliceLen > window)
+        sliceLen = window;
+      if (sliceLen > packetSize)
+        sliceLen = packetSize;
 
-  return ret;
-};
+      if (p === 0 && sliceLen === len)
+        protocol.channelData(id, data);
+      else
+        protocol.channelData(id, bufferSlice(data, p, p + sliceLen));
 
-Channel.prototype._read = function(n) {
-  if (this._waitChanDrain) {
-    this._waitChanDrain = false;
-    if (this.incoming.window <= WINDOW_THRESHOLD)
-      windowAdjust(this);
-  }
-};
+      p += sliceLen;
+      window -= sliceLen;
+    }
 
-Channel.prototype._write = function(data, encoding, cb) {
-  var sshstream = this._client._sshstream;
-  var outgoing = this.outgoing;
-  var packetSize = outgoing.packetSize;
-  var id = outgoing.id;
-  var window = outgoing.window;
-  var len = data.length;
-  var p = 0;
-  var ret;
-  var buf;
-  var sliceLen;
-
-  if (outgoing.state !== 'open')
-    return;
+    outgoing.window = window;
 
-  while (len - p > 0 && window > 0) {
-    sliceLen = len - p;
-    if (sliceLen > window)
-      sliceLen = window;
-    if (sliceLen > packetSize)
-      sliceLen = packetSize;
+    if (len - p > 0) {
+      if (window === 0)
+        this._waitWindow = true;
+      if (p > 0)
+        this._chunk = bufferSlice(data, p, len);
+      else
+        this._chunk = data;
+      this._chunkcb = cb;
+      return;
+    }
 
-    ret = sshstream.channelData(id, data.slice(p, p + sliceLen));
+    cb();
+  }
 
-    p += sliceLen;
-    window -= sliceLen;
+  eof() {
+    if (this.outgoing.state === 'open') {
+      this.outgoing.state = 'eof';
+      this._client._protocol.channelEOF(this.outgoing.id);
+    }
+  }
 
-    if (!ret) {
-      this._waitClientDrain = true;
-      this._chunk = undefined;
-      this._chunkcb = cb;
-      break;
+  close() {
+    if (this.outgoing.state === 'open' || this.outgoing.state === 'eof') {
+      this.outgoing.state = 'closing';
+      this._client._protocol.channelClose(this.outgoing.id);
     }
   }
 
-  outgoing.window = window;
-
-  if (len - p > 0) {
-    if (window === 0)
-      this._waitWindow = true;
-    if (p > 0) {
-      // partial
-      buf = Buffer.allocUnsafe(len - p);
-      data.copy(buf, 0, p);
-      this._chunk = buf;
-    } else
-      this._chunk = data;
-    this._chunkcb = cb;
-    return;
+  destroy() {
+    this.end();
+    this.close();
   }
 
-  if (!this._waitClientDrain)
-    cb();
-};
+  // Session type-specific methods =============================================
+  setWindow(rows, cols, height, width) {
+    if (this.server)
+      throw new Error('Client-only method called in server mode');
+
+    if (this.type === 'session'
+        && (this.subtype === 'shell' || this.subtype === 'exec')
+        && this.writable
+        && this.outgoing.state === 'open') {
+      this._client._protocol.windowChange(this.outgoing.id,
+                                          rows,
+                                          cols,
+                                          height,
+                                          width);
+    }
+  }
 
-Channel.prototype.destroy = function() {
-  this.end();
-};
+  signal(signalName) {
+    if (this.server)
+      throw new Error('Client-only method called in server mode');
 
-// session type-specific methods
-Channel.prototype.setWindow = function(rows, cols, height, width) {
-  if (this.server)
-    throw new Error('Client-only method called in server mode');
-
-  if (this.type === 'session'
-      && (this.subtype === 'shell' || this.subtype === 'exec')
-      && this.writable
-      && this.outgoing.state === 'open') {
-    return this._client._sshstream.windowChange(this.outgoing.id,
-                                                rows,
-                                                cols,
-                                                height,
-                                                width);
+    if (this.type === 'session'
+        && this.writable
+        && this.outgoing.state === 'open') {
+      this._client._protocol.signal(this.outgoing.id, signalName);
+    }
   }
 
-  return true;
-};
-Channel.prototype.signal = function(signalName) {
-  if (this.server)
-    throw new Error('Client-only method called in server mode');
+  exit(statusOrSignal, coreDumped, msg) {
+    if (!this.server)
+      throw new Error('Server-only method called in client mode');
 
-  if (this.type === 'session'
-      && this.writable
-      && this.outgoing.state === 'open')
-    return this._client._sshstream.signal(this.outgoing.id, signalName);
-
-  return true;
-};
-Channel.prototype.exit = function(name, coreDumped, msg) {
-  if (!this.server)
-    throw new Error('Server-only method called in client mode');
-
-  if (this.type === 'session'
-      && this.writable
-      && this.outgoing.state === 'open') {
-    if (typeof name === 'number')
-      return this._client._sshstream.exitStatus(this.outgoing.id, name);
-    else {
-      return this._client._sshstream.exitSignal(this.outgoing.id,
-                                                name,
-                                                coreDumped,
-                                                msg);
+    if (this.type === 'session'
+        && this.writable
+        && this.outgoing.state === 'open') {
+      if (typeof statusOrSignal === 'number') {
+        this._client._protocol.exitStatus(this.outgoing.id, statusOrSignal);
+      } else {
+        this._client._protocol.exitSignal(this.outgoing.id,
+                                          statusOrSignal,
+                                          coreDumped,
+                                          msg);
+      }
     }
   }
 
-  return true;
-};
+}
+
+function onFinish() {
+  this.eof();
+  if (this.server || !this.allowHalfOpen)
+    this.close();
+  this.writable = false;
+}
 
-Channel.MAX_WINDOW = MAX_WINDOW;
-Channel.PACKET_SIZE = PACKET_SIZE;
+function onEnd() {
+  this.readable = false;
+}
 
 function windowAdjust(self) {
   if (self.outgoing.state === 'closed')
-    return true;
-  var amt = MAX_WINDOW - self.incoming.window;
+    return;
+  const amt = MAX_WINDOW - self.incoming.window;
   if (amt <= 0)
-    return true;
+    return;
   self.incoming.window += amt;
-  return self._client._sshstream.channelWindowAdjust(self.outgoing.id, amt);
+  self._client._protocol.channelWindowAdjust(self.outgoing.id, amt);
 }
 
-function ServerStderr(channel) {
-  WritableStream.call(this, { highWaterMark: MAX_WINDOW });
-  this._channel = channel;
-}
-inherits(ServerStderr, WritableStream);
-
-ServerStderr.prototype._write = function(data, encoding, cb) {
-  var channel = this._channel;
-  var sshstream = channel._client._sshstream;
-  var outgoing = channel.outgoing;
-  var packetSize = outgoing.packetSize;
-  var id = outgoing.id;
-  var window = outgoing.window;
-  var len = data.length;
-  var p = 0;
-  var ret;
-  var buf;
-  var sliceLen;
-
-  if (channel.outgoing.state !== 'open')
-    return;
-
-  while (len - p > 0 && window > 0) {
-    sliceLen = len - p;
-    if (sliceLen > window)
-      sliceLen = window;
-    if (sliceLen > packetSize)
-      sliceLen = packetSize;
-
-    ret = sshstream.channelExtData(id, data.slice(p, p + sliceLen), STDERR);
-
-    p += sliceLen;
-    window -= sliceLen;
-
-    if (!ret) {
-      channel._waitClientDrain = true;
-      channel._chunkErr = undefined;
-      channel._chunkcbErr = cb;
-      break;
-    }
-  }
-
-  outgoing.window = window;
-
-  if (len - p > 0) {
-    if (window === 0)
-      channel._waitWindow = true;
-    if (p > 0) {
-      // partial
-      buf = Buffer.allocUnsafe(len - p);
-      data.copy(buf, 0, p);
-      channel._chunkErr = buf;
-    } else
-      channel._chunkErr = data;
-    channel._chunkcbErr = cb;
-    return;
-  }
-
-  if (!channel._waitClientDrain)
-    cb();
+module.exports = {
+  Channel,
+  MAX_WINDOW,
+  PACKET_SIZE,
+  windowAdjust,
+  WINDOW_THRESHOLD,
 };
-
-module.exports = Channel;