ssh2-streams
Version:
SSH2 and SFTP(v3) client/server protocol streams for node.js
1,621 lines (1,461 loc) • 91.5 kB
JavaScript
// TODO: support EXTENDED request packets
var TransformStream = require('stream').Transform;
var ReadableStream = require('stream').Readable;
var WritableStream = require('stream').Writable;
var constants = require('fs').constants || process.binding('constants');
var util = require('util');
var inherits = util.inherits;
var isDate = util.isDate;
var listenerCount = require('events').EventEmitter.listenerCount;
var fs = require('fs');
var readString = require('./utils').readString;
var readInt = require('./utils').readInt;
var readUInt32BE = require('./buffer-helpers').readUInt32BE;
var writeUInt32BE = require('./buffer-helpers').writeUInt32BE;
var ATTR = {
SIZE: 0x00000001,
UIDGID: 0x00000002,
PERMISSIONS: 0x00000004,
ACMODTIME: 0x00000008,
EXTENDED: 0x80000000
};
var STATUS_CODE = {
OK: 0,
EOF: 1,
NO_SUCH_FILE: 2,
PERMISSION_DENIED: 3,
FAILURE: 4,
BAD_MESSAGE: 5,
NO_CONNECTION: 6,
CONNECTION_LOST: 7,
OP_UNSUPPORTED: 8
};
Object.keys(STATUS_CODE).forEach(function(key) {
STATUS_CODE[STATUS_CODE[key]] = key;
});
var STATUS_CODE_STR = {
0: 'No error',
1: 'End of file',
2: 'No such file or directory',
3: 'Permission denied',
4: 'Failure',
5: 'Bad message',
6: 'No connection',
7: 'Connection lost',
8: 'Operation unsupported'
};
SFTPStream.STATUS_CODE = STATUS_CODE;
var REQUEST = {
INIT: 1,
OPEN: 3,
CLOSE: 4,
READ: 5,
WRITE: 6,
LSTAT: 7,
FSTAT: 8,
SETSTAT: 9,
FSETSTAT: 10,
OPENDIR: 11,
READDIR: 12,
REMOVE: 13,
MKDIR: 14,
RMDIR: 15,
REALPATH: 16,
STAT: 17,
RENAME: 18,
READLINK: 19,
SYMLINK: 20,
EXTENDED: 200
};
Object.keys(REQUEST).forEach(function(key) {
REQUEST[REQUEST[key]] = key;
});
var RESPONSE = {
VERSION: 2,
STATUS: 101,
HANDLE: 102,
DATA: 103,
NAME: 104,
ATTRS: 105,
EXTENDED: 201
};
Object.keys(RESPONSE).forEach(function(key) {
RESPONSE[RESPONSE[key]] = key;
});
var OPEN_MODE = {
READ: 0x00000001,
WRITE: 0x00000002,
APPEND: 0x00000004,
CREAT: 0x00000008,
TRUNC: 0x00000010,
EXCL: 0x00000020
};
SFTPStream.OPEN_MODE = OPEN_MODE;
var MAX_PKT_LEN = 34000;
var MAX_REQID = Math.pow(2, 32) - 1;
var CLIENT_VERSION_BUFFER = Buffer.from([0, 0, 0, 5 /* length */,
REQUEST.INIT,
0, 0, 0, 3 /* version */]);
var SERVER_VERSION_BUFFER = Buffer.from([0, 0, 0, 5 /* length */,
RESPONSE.VERSION,
0, 0, 0, 3 /* version */]);
/*
http://tools.ietf.org/html/draft-ietf-secsh-filexfer-02:
The maximum size of a packet is in practice determined by the client
(the maximum size of read or write requests that it sends, plus a few
bytes of packet overhead). All servers SHOULD support packets of at
least 34000 bytes (where the packet size refers to the full length,
including the header above). This should allow for reads and writes
of at most 32768 bytes.
OpenSSH caps this to 256kb instead of the ~34kb as mentioned in the sftpv3
spec.
*/
var RE_OPENSSH = /^SSH-2.0-(?:OpenSSH|dropbear)/;
var OPENSSH_MAX_DATA_LEN = (256 * 1024) - (2 * 1024)/*account for header data*/;
function DEBUG_NOOP(msg) {}
function SFTPStream(cfg, remoteIdentRaw) {
if (typeof cfg === 'string' && !remoteIdentRaw) {
remoteIdentRaw = cfg;
cfg = undefined;
}
if (typeof cfg !== 'object' || !cfg)
cfg = {};
TransformStream.call(this, {
highWaterMark: (typeof cfg.highWaterMark === 'number'
? cfg.highWaterMark
: 32 * 1024)
});
this.debug = (typeof cfg.debug === 'function' ? cfg.debug : DEBUG_NOOP);
this.server = (cfg.server ? true : false);
this._isOpenSSH = (remoteIdentRaw && RE_OPENSSH.test(remoteIdentRaw));
this._needContinue = false;
this._state = {
// common
status: 'packet_header',
writeReqid: -1,
pktLeft: undefined,
pktHdrBuf: Buffer.allocUnsafe(9), // room for pktLen + pktType + req id
pktBuf: undefined,
pktType: undefined,
version: undefined,
extensions: {},
// client
maxDataLen: (this._isOpenSSH ? OPENSSH_MAX_DATA_LEN : 32768),
requests: {}
};
var self = this;
this.on('end', function() {
self.readable = false;
}).on('finish', onFinish)
.on('prefinish', onFinish);
function onFinish() {
self.writable = false;
self._cleanup(false);
}
if (!this.server)
this.push(CLIENT_VERSION_BUFFER);
}
inherits(SFTPStream, TransformStream);
SFTPStream.prototype.__read = TransformStream.prototype._read;
SFTPStream.prototype._read = function(n) {
if (this._needContinue) {
this._needContinue = false;
this.emit('continue');
}
return this.__read(n);
};
SFTPStream.prototype.__push = TransformStream.prototype.push;
SFTPStream.prototype.push = function(chunk, encoding) {
if (!this.readable)
return false;
if (chunk === null)
this.readable = false;
var ret = this.__push(chunk, encoding);
this._needContinue = (ret === false);
return ret;
};
SFTPStream.prototype._cleanup = function(callback) {
var state = this._state;
state.pktBuf = undefined; // give GC something to do
var requests = state.requests;
var keys = Object.keys(requests);
var len = keys.length;
if (len) {
if (this.readable) {
var err = new Error('SFTP session ended early');
for (var i = 0, cb; i < len; ++i)
(cb = requests[keys[i]].cb) && cb(err);
}
state.requests = {};
}
if (this.readable)
this.push(null);
if (!this._readableState.endEmitted && !this._readableState.flowing) {
// Ugh!
this.resume();
}
if (callback !== false) {
this.debug('DEBUG[SFTP]: Parser: Malformed packet');
callback && callback(new Error('Malformed packet'));
}
};
SFTPStream.prototype._transform = function(chunk, encoding, callback) {
var state = this._state;
var server = this.server;
var status = state.status;
var pktType = state.pktType;
var pktBuf = state.pktBuf;
var pktLeft = state.pktLeft;
var version = state.version;
var pktHdrBuf = state.pktHdrBuf;
var requests = state.requests;
var debug = this.debug;
var chunkLen = chunk.length;
var chunkPos = 0;
var buffer;
var chunkLeft;
var id;
while (true) {
if (status === 'discard') {
chunkLeft = (chunkLen - chunkPos);
if (pktLeft <= chunkLeft) {
chunkPos += pktLeft;
pktLeft = 0;
status = 'packet_header';
buffer = pktBuf = undefined;
} else {
pktLeft -= chunkLeft;
break;
}
} else if (pktBuf !== undefined) {
chunkLeft = (chunkLen - chunkPos);
if (pktLeft <= chunkLeft) {
chunk.copy(pktBuf,
pktBuf.length - pktLeft,
chunkPos,
chunkPos + pktLeft);
chunkPos += pktLeft;
pktLeft = 0;
buffer = pktBuf;
pktBuf = undefined;
continue;
} else {
chunk.copy(pktBuf, pktBuf.length - pktLeft, chunkPos);
pktLeft -= chunkLeft;
break;
}
} else if (status === 'packet_header') {
if (!buffer) {
pktLeft = 5;
pktBuf = pktHdrBuf;
} else {
// here we read the right-most 5 bytes from buffer (pktHdrBuf)
pktLeft = readUInt32BE(buffer, 4) - 1; // account for type byte
pktType = buffer[8];
if (server) {
if (version === undefined && pktType !== REQUEST.INIT) {
debug('DEBUG[SFTP]: Parser: Unexpected packet before init');
this._cleanup(false);
return callback(new Error('Unexpected packet before init'));
} else if (version !== undefined && pktType === REQUEST.INIT) {
debug('DEBUG[SFTP]: Parser: Unexpected duplicate init');
status = 'bad_pkt';
} else if (pktLeft > MAX_PKT_LEN) {
var msg = 'Packet length ('
+ pktLeft
+ ') exceeds max length ('
+ MAX_PKT_LEN
+ ')';
debug('DEBUG[SFTP]: Parser: ' + msg);
this._cleanup(false);
return callback(new Error(msg));
} else if (pktType === REQUEST.EXTENDED) {
status = 'bad_pkt';
} else if (REQUEST[pktType] === undefined) {
debug('DEBUG[SFTP]: Parser: Unsupported packet type: ' + pktType);
status = 'discard';
}
} else if (version === undefined && pktType !== RESPONSE.VERSION) {
debug('DEBUG[SFTP]: Parser: Unexpected packet before version');
this._cleanup(false);
return callback(new Error('Unexpected packet before version'));
} else if (version !== undefined && pktType === RESPONSE.VERSION) {
debug('DEBUG[SFTP]: Parser: Unexpected duplicate version');
status = 'bad_pkt';
} else if (RESPONSE[pktType] === undefined) {
status = 'discard';
}
if (status === 'bad_pkt') {
// Copy original packet info to left of pktHdrBuf
writeUInt32BE(pktHdrBuf, pktLeft + 1, 0);
pktHdrBuf[4] = pktType;
pktLeft = 4;
pktBuf = pktHdrBuf;
} else {
pktBuf = Buffer.allocUnsafe(pktLeft);
status = 'payload';
}
}
} else if (status === 'payload') {
if (pktType === RESPONSE.VERSION || pktType === REQUEST.INIT) {
/*
uint32 version
<extension data>
*/
version = state.version = readInt(buffer, 0, this, callback);
if (version === false)
return;
if (version < 3) {
this._cleanup(false);
return callback(new Error('Incompatible SFTP version: ' + version));
} else if (server)
this.push(SERVER_VERSION_BUFFER);
var buflen = buffer.length;
var extname;
var extdata;
buffer._pos = 4;
while (buffer._pos < buflen) {
extname = readString(buffer, buffer._pos, 'ascii', this, callback);
if (extname === false)
return;
extdata = readString(buffer, buffer._pos, 'ascii', this, callback);
if (extdata === false)
return;
if (state.extensions[extname])
state.extensions[extname].push(extdata);
else
state.extensions[extname] = [ extdata ];
}
this.emit('ready');
} else {
/*
All other packets (client and server) begin with a (client) request
id:
uint32 id
*/
id = readInt(buffer, 0, this, callback);
if (id === false)
return;
var filename;
var attrs;
var handle;
var data;
if (!server) {
var req = requests[id];
var cb = req && req.cb;
debug('DEBUG[SFTP]: Parser: Response: ' + RESPONSE[pktType]);
if (req && cb) {
if (pktType === RESPONSE.STATUS) {
/*
uint32 error/status code
string error message (ISO-10646 UTF-8)
string language tag
*/
var code = readInt(buffer, 4, this, callback);
if (code === false)
return;
if (code === STATUS_CODE.OK) {
cb();
} else {
// We borrow OpenSSH behavior here, specifically we make the
// message and language fields optional, despite the
// specification requiring them (even if they are empty). This
// helps to avoid problems with buggy implementations that do
// not fully conform to the SFTP(v3) specification.
var msg;
var lang = '';
if (buffer.length >= 12) {
msg = readString(buffer, 8, 'utf8', this, callback);
if (msg === false)
return;
if ((buffer._pos + 4) < buffer.length) {
lang = readString(buffer,
buffer._pos,
'ascii',
this,
callback);
if (lang === false)
return;
}
}
var err = new Error(msg
|| STATUS_CODE_STR[code]
|| 'Unknown status');
err.code = code;
err.lang = lang;
cb(err);
}
} else if (pktType === RESPONSE.HANDLE) {
/*
string handle
*/
handle = readString(buffer, 4, this, callback);
if (handle === false)
return;
cb(undefined, handle);
} else if (pktType === RESPONSE.DATA) {
/*
string data
*/
if (req.buffer) {
// we have already pre-allocated space to store the data
var dataLen = readInt(buffer, 4, this, callback);
if (dataLen === false)
return;
var reqBufLen = req.buffer.length;
if (dataLen > reqBufLen) {
// truncate response data to fit expected size
writeUInt32BE(buffer, reqBufLen, 4);
}
data = readString(buffer, 4, req.buffer, this, callback);
if (data === false)
return;
cb(undefined, data, dataLen);
} else {
data = readString(buffer, 4, this, callback);
if (data === false)
return;
cb(undefined, data);
}
} else if (pktType === RESPONSE.NAME) {
/*
uint32 count
repeats count times:
string filename
string longname
ATTRS attrs
*/
var namesLen = readInt(buffer, 4, this, callback);
if (namesLen === false)
return;
var names = [],
longname;
buffer._pos = 8;
for (var i = 0; i < namesLen; ++i) {
// we are going to assume UTF-8 for filenames despite the SFTPv3
// spec not specifying an encoding because the specs for newer
// versions of the protocol all explicitly specify UTF-8 for
// filenames
filename = readString(buffer,
buffer._pos,
'utf8',
this,
callback);
if (filename === false)
return;
// `longname` only exists in SFTPv3 and since it typically will
// contain the filename, we assume it is also UTF-8
longname = readString(buffer,
buffer._pos,
'utf8',
this,
callback);
if (longname === false)
return;
attrs = readAttrs(buffer, buffer._pos, this, callback);
if (attrs === false)
return;
names.push({
filename: filename,
longname: longname,
attrs: attrs
});
}
cb(undefined, names);
} else if (pktType === RESPONSE.ATTRS) {
/*
ATTRS attrs
*/
attrs = readAttrs(buffer, 4, this, callback);
if (attrs === false)
return;
cb(undefined, attrs);
} else if (pktType === RESPONSE.EXTENDED) {
if (req.extended) {
switch (req.extended) {
case 'statvfs@openssh.com':
case 'fstatvfs@openssh.com':
/*
uint64 f_bsize // file system block size
uint64 f_frsize // fundamental fs block size
uint64 f_blocks // number of blocks (unit f_frsize)
uint64 f_bfree // free blocks in file system
uint64 f_bavail // free blocks for non-root
uint64 f_files // total file inodes
uint64 f_ffree // free file inodes
uint64 f_favail // free file inodes for to non-root
uint64 f_fsid // file system id
uint64 f_flag // bit mask of f_flag values
uint64 f_namemax // maximum filename length
*/
var stats = {
f_bsize: undefined,
f_frsize: undefined,
f_blocks: undefined,
f_bfree: undefined,
f_bavail: undefined,
f_files: undefined,
f_ffree: undefined,
f_favail: undefined,
f_sid: undefined,
f_flag: undefined,
f_namemax: undefined
};
stats.f_bsize = readUInt64BE(buffer, 4, this, callback);
if (stats.f_bsize === false)
return;
stats.f_frsize = readUInt64BE(buffer, 12, this, callback);
if (stats.f_frsize === false)
return;
stats.f_blocks = readUInt64BE(buffer, 20, this, callback);
if (stats.f_blocks === false)
return;
stats.f_bfree = readUInt64BE(buffer, 28, this, callback);
if (stats.f_bfree === false)
return;
stats.f_bavail = readUInt64BE(buffer, 36, this, callback);
if (stats.f_bavail === false)
return;
stats.f_files = readUInt64BE(buffer, 44, this, callback);
if (stats.f_files === false)
return;
stats.f_ffree = readUInt64BE(buffer, 52, this, callback);
if (stats.f_ffree === false)
return;
stats.f_favail = readUInt64BE(buffer, 60, this, callback);
if (stats.f_favail === false)
return;
stats.f_sid = readUInt64BE(buffer, 68, this, callback);
if (stats.f_sid === false)
return;
stats.f_flag = readUInt64BE(buffer, 76, this, callback);
if (stats.f_flag === false)
return;
stats.f_namemax = readUInt64BE(buffer, 84, this, callback);
if (stats.f_namemax === false)
return;
cb(undefined, stats);
break;
}
}
// XXX: at least provide the raw buffer data to the callback in
// case of unexpected extended response?
cb();
}
}
if (req)
delete requests[id];
} else {
// server
var evName = REQUEST[pktType];
var offset;
var path;
debug('DEBUG[SFTP]: Parser: Request: ' + evName);
if (listenerCount(this, evName)) {
if (pktType === REQUEST.OPEN) {
/*
string filename
uint32 pflags
ATTRS attrs
*/
filename = readString(buffer, 4, 'utf8', this, callback);
if (filename === false)
return;
var pflags = readInt(buffer, buffer._pos, this, callback);
if (pflags === false)
return;
attrs = readAttrs(buffer, buffer._pos + 4, this, callback);
if (attrs === false)
return;
this.emit(evName, id, filename, pflags, attrs);
} else if (pktType === REQUEST.CLOSE
|| pktType === REQUEST.FSTAT
|| pktType === REQUEST.READDIR) {
/*
string handle
*/
handle = readString(buffer, 4, this, callback);
if (handle === false)
return;
this.emit(evName, id, handle);
} else if (pktType === REQUEST.READ) {
/*
string handle
uint64 offset
uint32 len
*/
handle = readString(buffer, 4, this, callback);
if (handle === false)
return;
offset = readUInt64BE(buffer, buffer._pos, this, callback);
if (offset === false)
return;
var len = readInt(buffer, buffer._pos, this, callback);
if (len === false)
return;
this.emit(evName, id, handle, offset, len);
} else if (pktType === REQUEST.WRITE) {
/*
string handle
uint64 offset
string data
*/
handle = readString(buffer, 4, this, callback);
if (handle === false)
return;
offset = readUInt64BE(buffer, buffer._pos, this, callback);
if (offset === false)
return;
data = readString(buffer, buffer._pos, this, callback);
if (data === false)
return;
this.emit(evName, id, handle, offset, data);
} else if (pktType === REQUEST.LSTAT
|| pktType === REQUEST.STAT
|| pktType === REQUEST.OPENDIR
|| pktType === REQUEST.REMOVE
|| pktType === REQUEST.RMDIR
|| pktType === REQUEST.REALPATH
|| pktType === REQUEST.READLINK) {
/*
string path
*/
path = readString(buffer, 4, 'utf8', this, callback);
if (path === false)
return;
this.emit(evName, id, path);
} else if (pktType === REQUEST.SETSTAT
|| pktType === REQUEST.MKDIR) {
/*
string path
ATTRS attrs
*/
path = readString(buffer, 4, 'utf8', this, callback);
if (path === false)
return;
attrs = readAttrs(buffer, buffer._pos, this, callback);
if (attrs === false)
return;
this.emit(evName, id, path, attrs);
} else if (pktType === REQUEST.FSETSTAT) {
/*
string handle
ATTRS attrs
*/
handle = readString(buffer, 4, this, callback);
if (handle === false)
return;
attrs = readAttrs(buffer, buffer._pos, this, callback);
if (attrs === false)
return;
this.emit(evName, id, handle, attrs);
} else if (pktType === REQUEST.RENAME
|| pktType === REQUEST.SYMLINK) {
/*
RENAME:
string oldpath
string newpath
SYMLINK:
string linkpath
string targetpath
*/
var str1;
var str2;
str1 = readString(buffer, 4, 'utf8', this, callback);
if (str1 === false)
return;
str2 = readString(buffer, buffer._pos, 'utf8', this, callback);
if (str2 === false)
return;
if (pktType === REQUEST.SYMLINK && this._isOpenSSH) {
// OpenSSH has linkpath and targetpath positions switched
this.emit(evName, id, str2, str1);
} else
this.emit(evName, id, str1, str2);
}
} else {
// automatically reject request if no handler for request type
this.status(id, STATUS_CODE.OP_UNSUPPORTED);
}
}
}
// prepare for next packet
status = 'packet_header';
buffer = pktBuf = undefined;
} else if (status === 'bad_pkt') {
if (server && buffer[4] !== REQUEST.INIT) {
var errCode = (buffer[4] === REQUEST.EXTENDED
? STATUS_CODE.OP_UNSUPPORTED
: STATUS_CODE.FAILURE);
// no request id for init/version packets, so we have no way to send a
// status response, so we just close up shop ...
if (buffer[4] === REQUEST.INIT || buffer[4] === RESPONSE.VERSION)
return this._cleanup(callback);
id = readInt(buffer, 5, this, callback);
if (id === false)
return;
this.status(id, errCode);
}
// by this point we have already read the type byte and the id bytes, so
// we subtract those from the number of bytes to skip
pktLeft = readUInt32BE(buffer, 0) - 5;
status = 'discard';
}
if (chunkPos >= chunkLen)
break;
}
state.status = status;
state.pktType = pktType;
state.pktBuf = pktBuf;
state.pktLeft = pktLeft;
state.version = version;
callback();
};
// client
SFTPStream.prototype.createReadStream = function(path, options) {
if (this.server)
throw new Error('Client-only method called in server mode');
return new ReadStream(this, path, options);
};
SFTPStream.prototype.createWriteStream = function(path, options) {
if (this.server)
throw new Error('Client-only method called in server mode');
return new WriteStream(this, path, options);
};
SFTPStream.prototype.open = function(path, flags_, attrs, cb) {
if (this.server)
throw new Error('Client-only method called in server mode');
var state = this._state;
if (typeof attrs === 'function') {
cb = attrs;
attrs = undefined;
}
var flags = (typeof flags_ === 'number' ? flags_ : stringToFlags(flags_));
if (flags === null)
throw new Error('Unknown flags string: ' + flags_);
var attrFlags = 0;
var attrBytes = 0;
if (typeof attrs === 'string' || typeof attrs === 'number') {
attrs = { mode: attrs };
}
if (typeof attrs === 'object' && attrs !== null) {
attrs = attrsToBytes(attrs);
attrFlags = attrs.flags;
attrBytes = attrs.nbytes;
attrs = attrs.bytes;
}
/*
uint32 id
string filename
uint32 pflags
ATTRS attrs
*/
var pathlen = Buffer.byteLength(path);
var p = 9;
var buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathlen + 4 + 4 + attrBytes);
writeUInt32BE(buf, buf.length - 4, 0);
buf[4] = REQUEST.OPEN;
var reqid = state.writeReqid = (state.writeReqid + 1) % MAX_REQID;
writeUInt32BE(buf, reqid, 5);
writeUInt32BE(buf, pathlen, p);
buf.write(path, p += 4, pathlen, 'utf8');
writeUInt32BE(buf, flags, p += pathlen);
writeUInt32BE(buf, attrFlags, p += 4);
if (attrs && attrFlags) {
p += 4;
for (var i = 0, len = attrs.length; i < len; ++i)
for (var j = 0, len2 = attrs[i].length; j < len2; ++j)
buf[p++] = attrs[i][j];
}
state.requests[reqid] = { cb: cb };
this.debug('DEBUG[SFTP]: Outgoing: Writing OPEN');
return this.push(buf);
};
SFTPStream.prototype.close = function(handle, cb) {
if (this.server)
throw new Error('Client-only method called in server mode');
else if (!Buffer.isBuffer(handle))
throw new Error('handle is not a Buffer');
var state = this._state;
/*
uint32 id
string handle
*/
var handlelen = handle.length;
var p = 9;
var buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handlelen);
writeUInt32BE(buf, buf.length - 4, 0);
buf[4] = REQUEST.CLOSE;
var reqid = state.writeReqid = (state.writeReqid + 1) % MAX_REQID;
writeUInt32BE(buf, reqid, 5);
writeUInt32BE(buf, handlelen, p);
handle.copy(buf, p += 4);
state.requests[reqid] = { cb: cb };
this.debug('DEBUG[SFTP]: Outgoing: Writing CLOSE');
return this.push(buf);
};
SFTPStream.prototype.readData = function(handle, buf, off, len, position, cb) {
if (this.server)
throw new Error('Client-only method called in server mode');
else if (!Buffer.isBuffer(handle))
throw new Error('handle is not a Buffer');
else if (!Buffer.isBuffer(buf))
throw new Error('buffer is not a Buffer');
else if (off >= buf.length)
throw new Error('offset is out of bounds');
else if (off + len > buf.length)
throw new Error('length extends beyond buffer');
else if (position === null)
throw new Error('null position currently unsupported');
var state = this._state;
/*
uint32 id
string handle
uint64 offset
uint32 len
*/
var handlelen = handle.length;
var p = 9;
var pos = position;
var out = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handlelen + 8 + 4);
writeUInt32BE(out, out.length - 4, 0);
out[4] = REQUEST.READ;
var reqid = state.writeReqid = (state.writeReqid + 1) % MAX_REQID;
writeUInt32BE(out, reqid, 5);
writeUInt32BE(out, handlelen, p);
handle.copy(out, p += 4);
p += handlelen;
for (var i = 7; i >= 0; --i) {
out[p + i] = pos & 0xFF;
pos /= 256;
}
writeUInt32BE(out, len, p += 8);
state.requests[reqid] = {
cb: function(err, data, nb) {
if (err) {
if (cb._wantEOFError || err.code !== STATUS_CODE.EOF)
return cb(err);
} else if (nb > len) {
return cb(new Error('Received more data than requested'));
}
cb(undefined, nb || 0, data, position);
},
buffer: buf.slice(off, off + len)
};
this.debug('DEBUG[SFTP]: Outgoing: Writing READ');
return this.push(out);
};
SFTPStream.prototype.writeData = function(handle, buf, off, len, position, cb) {
if (this.server)
throw new Error('Client-only method called in server mode');
else if (!Buffer.isBuffer(handle))
throw new Error('handle is not a Buffer');
else if (!Buffer.isBuffer(buf))
throw new Error('buffer is not a Buffer');
else if (off > buf.length)
throw new Error('offset is out of bounds');
else if (off + len > buf.length)
throw new Error('length extends beyond buffer');
else if (position === null)
throw new Error('null position currently unsupported');
var self = this;
var state = this._state;
if (!len) {
cb && process.nextTick(function() { cb(undefined, 0); });
return;
}
var overflow = (len > state.maxDataLen
? len - state.maxDataLen
: 0);
var origPosition = position;
if (overflow)
len = state.maxDataLen;
/*
uint32 id
string handle
uint64 offset
string data
*/
var handlelen = handle.length;
var p = 9;
var out = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handlelen + 8 + 4 + len);
writeUInt32BE(out, out.length - 4, 0);
out[4] = REQUEST.WRITE;
var reqid = state.writeReqid = (state.writeReqid + 1) % MAX_REQID;
writeUInt32BE(out, reqid, 5);
writeUInt32BE(out, handlelen, p);
handle.copy(out, p += 4);
p += handlelen;
for (var i = 7; i >= 0; --i) {
out[p + i] = position & 0xFF;
position /= 256;
}
writeUInt32BE(out, len, p += 8);
buf.copy(out, p += 4, off, off + len);
state.requests[reqid] = {
cb: function(err) {
if (err)
cb && cb(err);
else if (overflow) {
self.writeData(handle,
buf,
off + len,
overflow,
origPosition + len,
cb);
} else
cb && cb(undefined, off + len);
}
};
this.debug('DEBUG[SFTP]: Outgoing: Writing WRITE');
return this.push(out);
};
function tryCreateBuffer(size) {
try {
return Buffer.allocUnsafe(size);
} catch (ex) {
return ex;
}
}
function fastXfer(src, dst, srcPath, dstPath, opts, cb) {
var concurrency = 64;
var chunkSize = 32768;
//var preserve = false;
var onstep;
var mode;
var fileSize;
if (typeof opts === 'function') {
cb = opts;
} else if (typeof opts === 'object' && opts !== null) {
if (typeof opts.concurrency === 'number'
&& opts.concurrency > 0
&& !isNaN(opts.concurrency))
concurrency = opts.concurrency;
if (typeof opts.chunkSize === 'number'
&& opts.chunkSize > 0
&& !isNaN(opts.chunkSize))
chunkSize = opts.chunkSize;
if (typeof opts.fileSize === 'number'
&& opts.fileSize > 0
&& !isNaN(opts.fileSize))
fileSize = opts.fileSize;
if (typeof opts.step === 'function')
onstep = opts.step;
//preserve = (opts.preserve ? true : false);
if (typeof opts.mode === 'string' || typeof opts.mode === 'number')
mode = modeNum(opts.mode);
}
// internal state variables
var fsize;
var pdst = 0;
var total = 0;
var hadError = false;
var srcHandle;
var dstHandle;
var readbuf;
var bufsize = chunkSize * concurrency;
function onerror(err) {
if (hadError)
return;
hadError = true;
var left = 0;
var cbfinal;
if (srcHandle || dstHandle) {
cbfinal = function() {
if (--left === 0)
cb(err);
};
if (srcHandle && (src === fs || src.writable))
++left;
if (dstHandle && (dst === fs || dst.writable))
++left;
if (srcHandle && (src === fs || src.writable))
src.close(srcHandle, cbfinal);
if (dstHandle && (dst === fs || dst.writable))
dst.close(dstHandle, cbfinal);
} else
cb(err);
}
src.open(srcPath, 'r', function(err, sourceHandle) {
if (err)
return onerror(err);
srcHandle = sourceHandle;
if (fileSize === undefined)
src.fstat(srcHandle, tryStat);
else
tryStat(null, { size: fileSize });
function tryStat(err, attrs) {
if (err) {
if (src !== fs) {
// Try stat() for sftp servers that may not support fstat() for
// whatever reason
src.stat(srcPath, function(err_, attrs_) {
if (err_)
return onerror(err);
tryStat(null, attrs_);
});
return;
}
return onerror(err);
}
fsize = attrs.size;
dst.open(dstPath, 'w', function(err, destHandle) {
if (err)
return onerror(err);
dstHandle = destHandle;
if (fsize <= 0)
return onerror();
// Use less memory where possible
while (bufsize > fsize) {
if (concurrency === 1) {
bufsize = fsize;
break;
}
bufsize -= chunkSize;
--concurrency;
}
readbuf = tryCreateBuffer(bufsize);
if (readbuf instanceof Error)
return onerror(readbuf);
if (mode !== undefined) {
dst.fchmod(dstHandle, mode, function tryAgain(err) {
if (err) {
// Try chmod() for sftp servers that may not support fchmod() for
// whatever reason
dst.chmod(dstPath, mode, function(err_) {
tryAgain();
});
return;
}
startReads();
});
} else {
startReads();
}
function onread(err, nb, data, dstpos, datapos, origChunkLen) {
if (err)
return onerror(err);
datapos = datapos || 0;
if (src === fs)
dst.writeData(dstHandle, readbuf, datapos, nb, dstpos, writeCb);
else
dst.write(dstHandle, readbuf, datapos, nb, dstpos, writeCb);
function writeCb(err) {
if (err)
return onerror(err);
total += nb;
onstep && onstep(total, nb, fsize);
if (nb < origChunkLen)
return singleRead(datapos, dstpos + nb, origChunkLen - nb);
if (total === fsize) {
dst.close(dstHandle, function(err) {
dstHandle = undefined;
if (err)
return onerror(err);
src.close(srcHandle, function(err) {
srcHandle = undefined;
if (err)
return onerror(err);
cb();
});
});
return;
}
if (pdst >= fsize)
return;
var chunk = (pdst + chunkSize > fsize ? fsize - pdst : chunkSize);
singleRead(datapos, pdst, chunk);
pdst += chunk;
}
}
function makeCb(psrc, pdst, chunk) {
return function(err, nb, data) {
onread(err, nb, data, pdst, psrc, chunk);
};
}
function singleRead(psrc, pdst, chunk) {
if (src === fs) {
src.read(srcHandle,
readbuf,
psrc,
chunk,
pdst,
makeCb(psrc, pdst, chunk));
} else {
src.readData(srcHandle,
readbuf,
psrc,
chunk,
pdst,
makeCb(psrc, pdst, chunk));
}
}
function startReads() {
var reads = 0;
var psrc = 0;
while (pdst < fsize && reads < concurrency) {
var chunk = (pdst + chunkSize > fsize ? fsize - pdst : chunkSize);
singleRead(psrc, pdst, chunk);
psrc += chunk;
pdst += chunk;
++reads;
}
}
});
}
});
}
SFTPStream.prototype.fastGet = function(remotePath, localPath, opts, cb) {
if (this.server)
throw new Error('Client-only method called in server mode');
fastXfer(this, fs, remotePath, localPath, opts, cb);
};
SFTPStream.prototype.fastPut = function(localPath, remotePath, opts, cb) {
if (this.server)
throw new Error('Client-only method called in server mode');
fastXfer(fs, this, localPath, remotePath, opts, cb);
};
SFTPStream.prototype.readFile = function(path, options, callback_) {
if (this.server)
throw new Error('Client-only method called in server mode');
var callback;
if (typeof callback_ === 'function') {
callback = callback_;
} else if (typeof options === 'function') {
callback = options;
options = undefined;
}
var self = this;
if (typeof options === 'string')
options = { encoding: options, flag: 'r' };
else if (!options)
options = { encoding: null, flag: 'r' };
else if (typeof options !== 'object')
throw new TypeError('Bad arguments');
var encoding = options.encoding;
if (encoding && !Buffer.isEncoding(encoding))
throw new Error('Unknown encoding: ' + encoding);
// first, stat the file, so we know the size.
var size;
var buffer; // single buffer with file data
var buffers; // list for when size is unknown
var pos = 0;
var handle;
// SFTPv3 does not support using -1 for read position, so we have to track
// read position manually
var bytesRead = 0;
var flag = options.flag || 'r';
this.open(path, flag, 438 /*=0666*/, function(er, handle_) {
if (er)
return callback && callback(er);
handle = handle_;
self.fstat(handle, function tryStat(er, st) {
if (er) {
// Try stat() for sftp servers that may not support fstat() for
// whatever reason
self.stat(path, function(er_, st_) {
if (er_) {
return self.close(handle, function() {
callback && callback(er);
});
}
tryStat(null, st_);
});
return;
}
size = st.size || 0;
if (size === 0) {
// the kernel lies about many files.
// Go ahead and try to read some bytes.
buffers = [];
return read();
}
buffer = Buffer.allocUnsafe(size);
read();
});
});
function read() {
if (size === 0) {
buffer = Buffer.allocUnsafe(8192);
self.readData(handle, buffer, 0, 8192, bytesRead, afterRead);
} else {
self.readData(handle, buffer, pos, size - pos, bytesRead, afterRead);
}
}
function afterRead(er, nbytes) {
var eof;
if (er) {
eof = (er.code === STATUS_CODE.EOF);
if (!eof) {
return self.close(handle, function() {
return callback && callback(er);
});
}
} else {
eof = false;
}
if (eof || (size === 0 && nbytes === 0))
return close();
bytesRead += nbytes;
pos += nbytes;
if (size !== 0) {
if (pos === size)
close();
else
read();
} else {
// unknown size, just read until we don't get bytes.
buffers.push(buffer.slice(0, nbytes));
read();
}
}
afterRead._wantEOFError = true;
function close() {
self.close(handle, function(er) {
if (size === 0) {
// collected the data into the buffers list.
buffer = Buffer.concat(buffers, pos);
} else if (pos < size) {
buffer = buffer.slice(0, pos);
}
if (encoding)
buffer = buffer.toString(encoding);
return callback && callback(er, buffer);
});
}
};
function writeAll(self, handle, buffer, offset, length, position, callback_) {
var callback = (typeof callback_ === 'function' ? callback_ : undefined);
self.writeData(handle,
buffer,
offset,
length,
position,
function(writeErr, written) {
if (writeErr) {
return self.close(handle, function() {
callback && callback(writeErr);
});
}
if (written === length)
self.close(handle, callback);
else {
offset += written;
length -= written;
position += written;
writeAll(self, handle, buffer, offset, length, position, callback);
}
});
}
SFTPStream.prototype.writeFile = function(path, data, options, callback_) {
if (this.server)
throw new Error('Client-only method called in server mode');
var callback;
if (typeof callback_ === 'function') {
callback = callback_;
} else if (typeof options === 'function') {
callback = options;
options = undefined;
}
var self = this;
if (typeof options === 'string')
options = { encoding: options, mode: 438, flag: 'w' };
else if (!options)
options = { encoding: 'utf8', mode: 438 /*=0666*/, flag: 'w' };
else if (typeof options !== 'object')
throw new TypeError('Bad arguments');
if (options.encoding && !Buffer.isEncoding(options.encoding))
throw new Error('Unknown encoding: ' + options.encoding);
var flag = options.flag || 'w';
this.open(path, flag, options.mode, function(openErr, handle) {
if (openErr)
callback && callback(openErr);
else {
var buffer = (Buffer.isBuffer(data)
? data
: Buffer.from('' + data, options.encoding || 'utf8'));
var position = (/a/.test(flag) ? null : 0);
// SFTPv3 does not support the notion of 'current position'
// (null position), so we just attempt to append to the end of the file
// instead
if (position === null) {
self.fstat(handle, function tryStat(er, st) {
if (er) {
// Try stat() for sftp servers that may not support fstat() for
// whatever reason
self.stat(path, function(er_, st_) {
if (er_) {
return self.close(handle, function() {
callback && callback(er);
});
}
tryStat(null, st_);
});
return;
}
writeAll(self, handle, buffer, 0, buffer.length, st.size, callback);
});
return;
}
writeAll(self, handle, buffer, 0, buffer.length, position, callback);
}
});
};
SFTPStream.prototype.appendFile = function(path, data, options, callback_) {
if (this.server)
throw new Error('Client-only method called in server mode');
var callback;
if (typeof callback_ === 'function') {
callback = callback_;
} else if (typeof options === 'function') {
callback = options;
options = undefined;
}
if (typeof options === 'string')
options = { encoding: options, mode: 438, flag: 'a' };
else if (!options)
options = { encoding: 'utf8', mode: 438 /*=0666*/, flag: 'a' };
else if (typeof options !== 'object')
throw new TypeError('Bad arguments');
if (!options.flag)
options = util._extend({ flag: 'a' }, options);
this.writeFile(path, data, options, callback);
};
SFTPStream.prototype.exists = function(path, cb) {
if (this.server)
throw new Error('Client-only method called in server mode');
this.stat(path, function(err) {
cb && cb(err ? false : true);
});
};
SFTPStream.prototype.unlink = function(filename, cb) {
if (this.server)
throw new Error('Client-only method called in server mode');
var state = this._state;
/*
uint32 id
string filename
*/
var fnamelen = Buffer.byteLength(filename);
var p = 9;
var buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + fnamelen);
writeUInt32BE(buf, buf.length - 4, 0);
buf[4] = REQUEST.REMOVE;
var reqid = state.writeReqid = (state.writeReqid + 1) % MAX_REQID;
writeUInt32BE(buf, reqid, 5);
writeUInt32BE(buf, fnamelen, p);
buf.write(filename, p += 4, fnamelen, 'utf8');
state.requests[reqid] = { cb: cb };
this.debug('DEBUG[SFTP]: Outgoing: Writing REMOVE');
return this.push(buf);
};
SFTPStream.prototype.rename = function(oldPath, newPath, cb) {
if (this.server)
throw new Error('Client-only method called in server mode');
var state = this._state;
/*
uint32 id
string oldpath
string newpath
*/
var oldlen = Buffer.byteLength(oldPath);
var newlen = Buffer.byteLength(newPath);
var p = 9;
var buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + oldlen + 4 + newlen);
writeUInt32BE(buf, buf.length - 4, 0);
buf[4] = REQUEST.RENAME;
var reqid = state.writeReqid = (state.writeReqid + 1) % MAX_REQID;
writeUInt32BE(buf, reqid, 5);
writeUInt32BE(buf, oldlen, p);
buf.write(oldPath, p += 4, oldlen, 'utf8');
writeUInt32BE(buf, newlen, p += oldlen);
buf.write(newPath, p += 4, newlen, 'utf8');
state.requests[reqid] = { cb: cb };
this.debug('DEBUG[SFTP]: Outgoing: Writing RENAME');
return this.push(buf);
};
SFTPStream.prototype.mkdir = function(path, attrs, cb) {
if (this.server)
throw new Error('Client-only method called in server mode');
var flags = 0;
var attrBytes = 0;
var state = this._state;
if (typeof attrs === 'function') {
cb = attrs;
attrs = undefined;
}
if (typeof attrs === 'object' && attrs !== null) {
attrs = attrsToBytes(attrs);
flags = attrs.flags;
attrBytes = attrs.nbytes;
attrs = attrs.bytes;
}
/*
uint32 id
string path
ATTRS attrs
*/
var pathlen = Buffer.byteLength(path);
var p = 9;
var buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathlen + 4 + attrBytes);
writeUInt32BE(buf, buf.length - 4, 0);
buf[4] = REQUEST.MKDIR;
var reqid = state.writeReqid = (state.writeReqid + 1) % MAX_REQID;
writeUInt32BE(buf, reqid, 5);
writeUInt32BE(buf, pathlen, p);
buf.write(path, p += 4, pathlen, 'utf8');
writeUInt32BE(buf, flags, p += pathlen);
if (flags) {
p += 4;
for (var i = 0, len = attrs.length; i < len; ++i)
for (var j = 0, len2 = attrs[i].length; j < len2; ++j)
buf[p++] = attrs[i][j];
}
state.requests[reqid] = { cb: cb };
this.debug('DEBUG[SFTP]: Outgoing: Writing MKDIR');
return this.push(buf);
};
SFTPStream.prototype.rmdir = function(path, cb) {
if (this.server)
throw new Error('Client-only method called in server mode');
var state = this._state;
/*
uint32 id
string path
*/
var pathlen = Buffer.byteLength(path);
var p = 9;
var buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathlen);
writeUInt32BE(buf, buf.length - 4, 0);
buf[4] = REQUEST.RMDIR;
var reqid = state.writeReqid = (state.writeReqid + 1) % MAX_REQID;
writeUInt32BE(buf, reqid, 5);
writeUInt32BE(buf, pathlen, p);
buf.write(path, p += 4, pathlen, 'utf8');
state.requests[reqid] = { cb: cb };
this.debug('DEBUG[SFTP]: Outgoing: Writing RMDIR');
return this.push(buf);
};
SFTPStream.prototype.readdir = function(where, opts, cb) {
if (this.server)
throw new Error('Client-only method called in server mode');
var state = this._state;
var doFilter;
if (typeof opts === 'function') {
cb = opts;
opts = {};
}
if (typeof opts !== 'object' || opts === null)
opts = {};
doFilter = (opts && opts.full ? false : true);
if (!Buffer.isBuffer(where) && typeof where !== 'string')
throw new Error('missing directory handle or path');
if (typeof where === 'string') {
var self = this;
var entries = [];
var e = 0;
return this.opendir(where, function reread(err, handle) {
if (err)
return cb(err);
self.readdir(handle, opts, function(err, list) {
var eof = (err && err