agent-skill-manager 1.22.0 → 2.1.0

package/node_modules/ssh2/lib/protocol/SFTP.js

@@ -1,4052 +0,0 @@
-'use strict';
-
-const EventEmitter = require('events');
-const fs = require('fs');
-const { constants } = fs;
-const {
-  Readable: ReadableStream,
-  Writable: WritableStream
-} = require('stream');
-const { inherits, types: { isDate } } = require('util');
-
-const FastBuffer = Buffer[Symbol.species];
-
-const {
-  bufferCopy,
-  bufferSlice,
-  makeBufferParser,
-  writeUInt32BE,
-} = require('./utils.js');
-
-const ATTR = {
-  SIZE: 0x00000001,
-  UIDGID: 0x00000002,
-  PERMISSIONS: 0x00000004,
-  ACMODTIME: 0x00000008,
-  EXTENDED: 0x80000000,
-};
-
-// Large enough to store all possible attributes
-const ATTRS_BUF = Buffer.alloc(28);
-
-const 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
-};
-
-const VALID_STATUS_CODES = new Map(
-  Object.values(STATUS_CODE).map((n) => [n, 1])
-);
-
-const STATUS_CODE_STR = {
-  [STATUS_CODE.OK]: 'No error',
-  [STATUS_CODE.EOF]: 'End of file',
-  [STATUS_CODE.NO_SUCH_FILE]: 'No such file or directory',
-  [STATUS_CODE.PERMISSION_DENIED]: 'Permission denied',
-  [STATUS_CODE.FAILURE]: 'Failure',
-  [STATUS_CODE.BAD_MESSAGE]: 'Bad message',
-  [STATUS_CODE.NO_CONNECTION]: 'No connection',
-  [STATUS_CODE.CONNECTION_LOST]: 'Connection lost',
-  [STATUS_CODE.OP_UNSUPPORTED]: 'Operation unsupported',
-};
-
-const 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
-};
-
-const RESPONSE = {
-  VERSION: 2,
-  STATUS: 101,
-  HANDLE: 102,
-  DATA: 103,
-  NAME: 104,
-  ATTRS: 105,
-  EXTENDED: 201
-};
-
-const OPEN_MODE = {
-  READ: 0x00000001,
-  WRITE: 0x00000002,
-  APPEND: 0x00000004,
-  CREAT: 0x00000008,
-  TRUNC: 0x00000010,
-  EXCL: 0x00000020
-};
-
-const PKT_RW_OVERHEAD = 2 * 1024;
-const MAX_REQID = 2 ** 32 - 1;
-const CLIENT_VERSION_BUFFER = Buffer.from([
-  0, 0, 0, 5 /* length */,
-    REQUEST.INIT,
-    0, 0, 0, 3 /* version */
-]);
-const SERVER_VERSION_BUFFER = Buffer.from([
-  0, 0, 0, 5 /* length */,
-    RESPONSE.VERSION,
-    0, 0, 0, 3 /* version */
-]);
-
-const RE_OPENSSH = /^SSH-2.0-(?:OpenSSH|dropbear)/;
-const OPENSSH_MAX_PKT_LEN = 256 * 1024;
-
-const bufferParser = makeBufferParser();
-
-const fakeStderr = {
-  readable: false,
-  writable: false,
-  push: (data) => {},
-  once: () => {},
-  on: () => {},
-  emit: () => {},
-  end: () => {},
-};
-
-function noop() {}
-
-// Emulates enough of `Channel` to be able to be used as a drop-in replacement
-// in order to process incoming data with as little overhead as possible
-class SFTP extends EventEmitter {
-  constructor(client, chanInfo, cfg) {
-    super();
-
-    if (typeof cfg !== 'object' || !cfg)
-      cfg = {};
-
-    const remoteIdentRaw = client._protocol._remoteIdentRaw;
-
-    this.server = !!cfg.server;
-    this._debug = (typeof cfg.debug === 'function' ? cfg.debug : undefined);
-    this._isOpenSSH = (remoteIdentRaw && RE_OPENSSH.test(remoteIdentRaw));
-
-    this._version = -1;
-    this._extensions = {};
-    this._biOpt = cfg.biOpt;
-    this._pktLenBytes = 0;
-    this._pktLen = 0;
-    this._pktPos = 0;
-    this._pktType = 0;
-    this._pktData = undefined;
-    this._writeReqid = -1;
-    this._requests = {};
-    this._maxInPktLen = OPENSSH_MAX_PKT_LEN;
-    this._maxOutPktLen = 34000;
-    this._maxReadLen =
-      (this._isOpenSSH ? OPENSSH_MAX_PKT_LEN : 34000) - PKT_RW_OVERHEAD;
-    this._maxWriteLen =
-      (this._isOpenSSH ? OPENSSH_MAX_PKT_LEN : 34000) - PKT_RW_OVERHEAD;
-
-    this.maxOpenHandles = undefined;
-
-    // Channel compatibility
-    this._client = client;
-    this._protocol = client._protocol;
-    this._callbacks = [];
-    this._hasX11 = false;
-    this._exit = {
-      code: undefined,
-      signal: undefined,
-      dump: undefined,
-      desc: undefined,
-    };
-    this._waitWindow = false; // SSH-level backpressure
-    this._chunkcb = undefined;
-    this._buffer = [];
-    this.type = chanInfo.type;
-    this.subtype = undefined;
-    this.incoming = chanInfo.incoming;
-    this.outgoing = chanInfo.outgoing;
-    this.stderr = fakeStderr;
-    this.readable = true;
-  }
-
-  // This handles incoming data to parse
-  push(data) {
-    if (data === null) {
-      cleanupRequests(this);
-      if (!this.readable)
-        return;
-      // No more incoming data from the remote side
-      this.readable = false;
-      this.emit('end');
-      return;
-    }
-    /*
-        uint32             length
-        byte               type
-        byte[length - 1]   data payload
-    */
-    let p = 0;
-
-    while (p < data.length) {
-      if (this._pktLenBytes < 4) {
-        let nb = Math.min(4 - this._pktLenBytes, data.length - p);
-        this._pktLenBytes += nb;
-
-        while (nb--)
-          this._pktLen = (this._pktLen << 8) + data[p++];
-
-        if (this._pktLenBytes < 4)
-          return;
-        if (this._pktLen === 0)
-          return doFatalSFTPError(this, 'Invalid packet length');
-        if (this._pktLen > this._maxInPktLen) {
-          const max = this._maxInPktLen;
-          return doFatalSFTPError(
-            this,
-            `Packet length ${this._pktLen} exceeds max length of ${max}`
-          );
-        }
-        if (p >= data.length)
-          return;
-      }
-      if (this._pktPos < this._pktLen) {
-        const nb = Math.min(this._pktLen - this._pktPos, data.length - p);
-        if (p !== 0 || nb !== data.length) {
-          if (nb === this._pktLen) {
-            this._pkt = new FastBuffer(data.buffer, data.byteOffset + p, nb);
-          } else {
-            if (!this._pkt)
-              this._pkt = Buffer.allocUnsafe(this._pktLen);
-            this._pkt.set(
-              new Uint8Array(data.buffer, data.byteOffset + p, nb),
-              this._pktPos
-            );
-          }
-        } else if (nb === this._pktLen) {
-          this._pkt = data;
-        } else {
-          if (!this._pkt)
-            this._pkt = Buffer.allocUnsafe(this._pktLen);
-          this._pkt.set(data, this._pktPos);
-        }
-        p += nb;
-        this._pktPos += nb;
-        if (this._pktPos < this._pktLen)
-          return;
-      }
-
-      const type = this._pkt[0];
-      const payload = this._pkt;
-
-      // Prepare for next packet
-      this._pktLen = 0;
-      this._pktLenBytes = 0;
-      this._pkt = undefined;
-      this._pktPos = 0;
-
-      const handler = (this.server
-                       ? SERVER_HANDLERS[type]
-                       : CLIENT_HANDLERS[type]);
-      if (!handler)
-        return doFatalSFTPError(this, `Unknown packet type ${type}`);
-
-      if (this._version === -1) {
-        if (this.server) {
-          if (type !== REQUEST.INIT)
-            return doFatalSFTPError(this, `Expected INIT packet, got ${type}`);
-        } else if (type !== RESPONSE.VERSION) {
-          return doFatalSFTPError(this, `Expected VERSION packet, got ${type}`);
-        }
-      }
-
-      if (handler(this, payload) === false)
-        return;
-    }
-  }
-
-  end() {
-    this.destroy();
-  }
-  destroy() {
-    if (this.outgoing.state === 'open' || this.outgoing.state === 'eof') {
-      this.outgoing.state = 'closing';
-      this._protocol.channelClose(this.outgoing.id);
-    }
-  }
-  _init() {
-    this._init = noop;
-    if (!this.server)
-      sendOrBuffer(this, CLIENT_VERSION_BUFFER);
-  }
-
-  // ===========================================================================
-  // Client-specific ===========================================================
-  // ===========================================================================
-  createReadStream(path, options) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    return new ReadStream(this, path, options);
-  }
-  createWriteStream(path, options) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    return new WriteStream(this, path, options);
-  }
-  open(path, flags_, attrs, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    if (typeof attrs === 'function') {
-      cb = attrs;
-      attrs = undefined;
-    }
-
-    const flags = (typeof flags_ === 'number' ? flags_ : stringToFlags(flags_));
-    if (flags === null)
-      throw new Error(`Unknown flags string: ${flags_}`);
-
-    let attrsFlags = 0;
-    let attrsLen = 0;
-    if (typeof attrs === 'string' || typeof attrs === 'number')
-      attrs = { mode: attrs };
-    if (typeof attrs === 'object' && attrs !== null) {
-      attrs = attrsToBytes(attrs);
-      attrsFlags = attrs.flags;
-      attrsLen = attrs.nb;
-    }
-
-    /*
-      uint32        id
-      string        filename
-      uint32        pflags
-      ATTRS         attrs
-    */
-    const pathLen = Buffer.byteLength(path);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen + 4 + 4 + attrsLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.OPEN;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, pathLen, p);
-    buf.utf8Write(path, p += 4, pathLen);
-    writeUInt32BE(buf, flags, p += pathLen);
-    writeUInt32BE(buf, attrsFlags, p += 4);
-    if (attrsLen) {
-      p += 4;
-
-      if (attrsLen === ATTRS_BUF.length)
-        buf.set(ATTRS_BUF, p);
-      else
-        bufferCopy(ATTRS_BUF, buf, 0, attrsLen, p);
-
-      p += attrsLen;
-    }
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} OPEN`
-    );
-  }
-  close(handle, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    if (!Buffer.isBuffer(handle))
-      throw new Error('handle is not a Buffer');
-
-    /*
-      uint32     id
-      string     handle
-    */
-    const handleLen = handle.length;
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.CLOSE;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, handleLen, p);
-    buf.set(handle, p += 4);
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} CLOSE`
-    );
-  }
-  read(handle, buf, off, len, position, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-    if (!Buffer.isBuffer(handle))
-      throw new Error('handle is not a Buffer');
-    if (!Buffer.isBuffer(buf))
-      throw new Error('buffer is not a Buffer');
-    if (off >= buf.length)
-      throw new Error('offset is out of bounds');
-    if (off + len > buf.length)
-      throw new Error('length extends beyond buffer');
-    if (position === null)
-      throw new Error('null position currently unsupported');
-
-    read_(this, handle, buf, off, len, position, cb);
-  }
-  readData(handle, buf, off, len, position, cb) {
-    // Backwards compatibility
-    this.read(handle, buf, off, len, position, cb);
-  }
-  write(handle, buf, off, len, position, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    if (!Buffer.isBuffer(handle))
-      throw new Error('handle is not a Buffer');
-    if (!Buffer.isBuffer(buf))
-      throw new Error('buffer is not a Buffer');
-    if (off > buf.length)
-      throw new Error('offset is out of bounds');
-    if (off + len > buf.length)
-      throw new Error('length extends beyond buffer');
-    if (position === null)
-      throw new Error('null position currently unsupported');
-
-    if (!len) {
-      cb && process.nextTick(cb, undefined, 0);
-      return;
-    }
-
-    const maxDataLen = this._maxWriteLen;
-    const overflow = Math.max(len - maxDataLen, 0);
-    const origPosition = position;
-
-    if (overflow)
-      len = maxDataLen;
-
-    /*
-      uint32     id
-      string     handle
-      uint64     offset
-      string     data
-    */
-    const handleLen = handle.length;
-    let p = 9;
-    const out = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen + 8 + 4 + len);
-
-    writeUInt32BE(out, out.length - 4, 0);
-    out[4] = REQUEST.WRITE;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(out, reqid, 5);
-
-    writeUInt32BE(out, handleLen, p);
-    out.set(handle, p += 4);
-    p += handleLen;
-    for (let i = 7; i >= 0; --i) {
-      out[p + i] = position & 0xFF;
-      position /= 256;
-    }
-    writeUInt32BE(out, len, p += 8);
-    bufferCopy(buf, out, off, off + len, p += 4);
-
-    this._requests[reqid] = {
-      cb: (err) => {
-        if (err) {
-          if (typeof cb === 'function')
-            cb(err);
-        } else if (overflow) {
-          this.write(handle,
-                     buf,
-                     off + len,
-                     overflow,
-                     origPosition + len,
-                     cb);
-        } else if (typeof cb === 'function') {
-          cb(undefined, off + len);
-        }
-      }
-    };
-
-    const isSent = sendOrBuffer(this, out);
-    if (this._debug) {
-      const how = (isSent ? 'Sent' : 'Buffered');
-      this._debug(`SFTP: Outbound: ${how} WRITE (id:${reqid})`);
-    }
-  }
-  writeData(handle, buf, off, len, position, cb) {
-    // Backwards compatibility
-    this.write(handle, buf, off, len, position, cb);
-  }
-  fastGet(remotePath, localPath, opts, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    fastXfer(this, fs, remotePath, localPath, opts, cb);
-  }
-  fastPut(localPath, remotePath, opts, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    fastXfer(fs, this, localPath, remotePath, opts, cb);
-  }
-  readFile(path, options, callback_) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    let callback;
-    if (typeof callback_ === 'function') {
-      callback = callback_;
-    } else if (typeof options === 'function') {
-      callback = options;
-      options = undefined;
-    }
-
-    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');
-
-    const encoding = options.encoding;
-    if (encoding && !Buffer.isEncoding(encoding))
-      throw new Error(`Unknown encoding: ${encoding}`);
-
-    // First stat the file, so we know the size.
-    let size;
-    let buffer; // Single buffer with file data
-    let buffers; // List for when size is unknown
-    let pos = 0;
-    let handle;
-
-    // SFTPv3 does not support using -1 for read position, so we have to track
-    // read position manually
-    let bytesRead = 0;
-
-    const flag = options.flag || 'r';
-
-    const read = () => {
-      if (size === 0) {
-        buffer = Buffer.allocUnsafe(8192);
-        this.read(handle, buffer, 0, 8192, bytesRead, afterRead);
-      } else {
-        this.read(handle, buffer, pos, size - pos, bytesRead, afterRead);
-      }
-    };
-
-    const afterRead = (er, nbytes) => {
-      let eof;
-      if (er) {
-        eof = (er.code === STATUS_CODE.EOF);
-        if (!eof) {
-          return this.close(handle, () => {
-            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(bufferSlice(buffer, 0, nbytes));
-        read();
-      }
-    };
-    afterRead._wantEOFError = true;
-
-    const close = () => {
-      this.close(handle, (er) => {
-        if (size === 0) {
-          // Collect the data into the buffers list.
-          buffer = Buffer.concat(buffers, pos);
-        } else if (pos < size) {
-          buffer = bufferSlice(buffer, 0, pos);
-        }
-
-        if (encoding)
-          buffer = buffer.toString(encoding);
-        return callback && callback(er, buffer);
-      });
-    };
-
-    this.open(path, flag, 0o666, (er, handle_) => {
-      if (er)
-        return callback && callback(er);
-      handle = handle_;
-
-      const tryStat = (er, st) => {
-        if (er) {
-          // Try stat() for sftp servers that may not support fstat() for
-          // whatever reason
-          this.stat(path, (er_, st_) => {
-            if (er_) {
-              return this.close(handle, () => {
-                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();
-      };
-      this.fstat(handle, tryStat);
-    });
-  }
-  writeFile(path, data, options, callback_) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    let callback;
-    if (typeof callback_ === 'function') {
-      callback = callback_;
-    } else if (typeof options === 'function') {
-      callback = options;
-      options = undefined;
-    }
-
-    if (typeof options === 'string')
-      options = { encoding: options, mode: 0o666, flag: 'w' };
-    else if (!options)
-      options = { encoding: 'utf8', mode: 0o666, 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}`);
-
-    const flag = options.flag || 'w';
-    this.open(path, flag, options.mode, (openErr, handle) => {
-      if (openErr) {
-        callback && callback(openErr);
-      } else {
-        const buffer = (Buffer.isBuffer(data)
-                        ? data
-                        : Buffer.from('' + data, options.encoding || 'utf8'));
-        const 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) {
-          const tryStat = (er, st) => {
-            if (er) {
-              // Try stat() for sftp servers that may not support fstat() for
-              // whatever reason
-              this.stat(path, (er_, st_) => {
-                if (er_) {
-                  return this.close(handle, () => {
-                    callback && callback(er);
-                  });
-                }
-                tryStat(null, st_);
-              });
-              return;
-            }
-            writeAll(this, handle, buffer, 0, buffer.length, st.size, callback);
-          };
-          this.fstat(handle, tryStat);
-          return;
-        }
-        writeAll(this, handle, buffer, 0, buffer.length, position, callback);
-      }
-    });
-  }
-  appendFile(path, data, options, callback_) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    let callback;
-    if (typeof callback_ === 'function') {
-      callback = callback_;
-    } else if (typeof options === 'function') {
-      callback = options;
-      options = undefined;
-    }
-
-    if (typeof options === 'string')
-      options = { encoding: options, mode: 0o666, flag: 'a' };
-    else if (!options)
-      options = { encoding: 'utf8', mode: 0o666, flag: 'a' };
-    else if (typeof options !== 'object')
-      throw new TypeError('Bad arguments');
-
-    if (!options.flag)
-      options = Object.assign({ flag: 'a' }, options);
-    this.writeFile(path, data, options, callback);
-  }
-  exists(path, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    this.stat(path, (err) => {
-      cb && cb(err ? false : true);
-    });
-  }
-  unlink(filename, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    /*
-      uint32     id
-      string     filename
-    */
-    const fnameLen = Buffer.byteLength(filename);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + fnameLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.REMOVE;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, fnameLen, p);
-    buf.utf8Write(filename, p += 4, fnameLen);
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} REMOVE`
-    );
-  }
-  rename(oldPath, newPath, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    /*
-      uint32     id
-      string     oldpath
-      string     newpath
-    */
-    const oldLen = Buffer.byteLength(oldPath);
-    const newLen = Buffer.byteLength(newPath);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + oldLen + 4 + newLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.RENAME;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, oldLen, p);
-    buf.utf8Write(oldPath, p += 4, oldLen);
-    writeUInt32BE(buf, newLen, p += oldLen);
-    buf.utf8Write(newPath, p += 4, newLen);
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} RENAME`
-    );
-  }
-  mkdir(path, attrs, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    let flags = 0;
-    let attrsLen = 0;
-
-    if (typeof attrs === 'function') {
-      cb = attrs;
-      attrs = undefined;
-    }
-    if (typeof attrs === 'object' && attrs !== null) {
-      attrs = attrsToBytes(attrs);
-      flags = attrs.flags;
-      attrsLen = attrs.nb;
-    }
-
-    /*
-      uint32     id
-      string     path
-      ATTRS      attrs
-    */
-    const pathLen = Buffer.byteLength(path);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen + 4 + attrsLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.MKDIR;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, pathLen, p);
-    buf.utf8Write(path, p += 4, pathLen);
-    writeUInt32BE(buf, flags, p += pathLen);
-    if (attrsLen) {
-      p += 4;
-
-      if (attrsLen === ATTRS_BUF.length)
-        buf.set(ATTRS_BUF, p);
-      else
-        bufferCopy(ATTRS_BUF, buf, 0, attrsLen, p);
-
-      p += attrsLen;
-    }
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} MKDIR`
-    );
-  }
-  rmdir(path, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    /*
-      uint32     id
-      string     path
-    */
-    const pathLen = Buffer.byteLength(path);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.RMDIR;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, pathLen, p);
-    buf.utf8Write(path, p += 4, pathLen);
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} RMDIR`
-    );
-  }
-  readdir(where, opts, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    if (typeof opts === 'function') {
-      cb = opts;
-      opts = {};
-    }
-    if (typeof opts !== 'object' || opts === null)
-      opts = {};
-
-    const 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') {
-      const entries = [];
-      let e = 0;
-
-      const reread = (err, handle) => {
-        if (err)
-          return cb(err);
-
-        this.readdir(handle, opts, (err, list) => {
-          const eof = (err && err.code === STATUS_CODE.EOF);
-
-          if (err && !eof)
-            return this.close(handle, () => cb(err));
-
-          if (eof) {
-            return this.close(handle, (err) => {
-              if (err)
-                return cb(err);
-              cb(undefined, entries);
-            });
-          }
-
-          for (let i = 0; i < list.length; ++i, ++e)
-            entries[e] = list[i];
-
-          reread(undefined, handle);
-        });
-      };
-      return this.opendir(where, reread);
-    }
-
-    /*
-      uint32     id
-      string     handle
-    */
-    const handleLen = where.length;
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.READDIR;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, handleLen, p);
-    buf.set(where, p += 4);
-
-    this._requests[reqid] = {
-      cb: (doFilter
-           ? (err, list) => {
-               if (typeof cb !== 'function')
-                 return;
-               if (err)
-                 return cb(err);
-
-               for (let i = list.length - 1; i >= 0; --i) {
-                 if (list[i].filename === '.' || list[i].filename === '..')
-                   list.splice(i, 1);
-               }
-
-               cb(undefined, list);
-             }
-           : cb)
-    };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} READDIR`
-    );
-  }
-  fstat(handle, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    if (!Buffer.isBuffer(handle))
-      throw new Error('handle is not a Buffer');
-
-    /*
-      uint32     id
-      string     handle
-    */
-    const handleLen = handle.length;
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.FSTAT;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, handleLen, p);
-    buf.set(handle, p += 4);
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} FSTAT`
-    );
-  }
-  stat(path, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    /*
-      uint32     id
-      string     path
-    */
-    const pathLen = Buffer.byteLength(path);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.STAT;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, pathLen, p);
-    buf.utf8Write(path, p += 4, pathLen);
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} STAT`
-    );
-  }
-  lstat(path, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    /*
-      uint32     id
-      string     path
-    */
-    const pathLen = Buffer.byteLength(path);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.LSTAT;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, pathLen, p);
-    buf.utf8Write(path, p += 4, pathLen);
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} LSTAT`
-    );
-  }
-  opendir(path, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    /*
-      uint32     id
-      string     path
-    */
-    const pathLen = Buffer.byteLength(path);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.OPENDIR;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, pathLen, p);
-    buf.utf8Write(path, p += 4, pathLen);
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} OPENDIR`
-    );
-  }
-  setstat(path, attrs, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    let flags = 0;
-    let attrsLen = 0;
-
-    if (typeof attrs === 'object' && attrs !== null) {
-      attrs = attrsToBytes(attrs);
-      flags = attrs.flags;
-      attrsLen = attrs.nb;
-    } else if (typeof attrs === 'function') {
-      cb = attrs;
-    }
-
-    /*
-      uint32     id
-      string     path
-      ATTRS      attrs
-    */
-    const pathLen = Buffer.byteLength(path);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen + 4 + attrsLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.SETSTAT;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, pathLen, p);
-    buf.utf8Write(path, p += 4, pathLen);
-    writeUInt32BE(buf, flags, p += pathLen);
-    if (attrsLen) {
-      p += 4;
-
-      if (attrsLen === ATTRS_BUF.length)
-        buf.set(ATTRS_BUF, p);
-      else
-        bufferCopy(ATTRS_BUF, buf, 0, attrsLen, p);
-
-      p += attrsLen;
-    }
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} SETSTAT`
-    );
-  }
-  fsetstat(handle, attrs, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    if (!Buffer.isBuffer(handle))
-      throw new Error('handle is not a Buffer');
-
-    let flags = 0;
-    let attrsLen = 0;
-
-    if (typeof attrs === 'object' && attrs !== null) {
-      attrs = attrsToBytes(attrs);
-      flags = attrs.flags;
-      attrsLen = attrs.nb;
-    } else if (typeof attrs === 'function') {
-      cb = attrs;
-    }
-
-    /*
-      uint32     id
-      string     handle
-      ATTRS      attrs
-    */
-    const handleLen = handle.length;
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen + 4 + attrsLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.FSETSTAT;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, handleLen, p);
-    buf.set(handle, p += 4);
-    writeUInt32BE(buf, flags, p += handleLen);
-    if (attrsLen) {
-      p += 4;
-
-      if (attrsLen === ATTRS_BUF.length)
-        buf.set(ATTRS_BUF, p);
-      else
-        bufferCopy(ATTRS_BUF, buf, 0, attrsLen, p);
-
-      p += attrsLen;
-    }
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} FSETSTAT`
-    );
-  }
-  futimes(handle, atime, mtime, cb) {
-    return this.fsetstat(handle, {
-      atime: toUnixTimestamp(atime),
-      mtime: toUnixTimestamp(mtime)
-    }, cb);
-  }
-  utimes(path, atime, mtime, cb) {
-    return this.setstat(path, {
-      atime: toUnixTimestamp(atime),
-      mtime: toUnixTimestamp(mtime)
-    }, cb);
-  }
-  fchown(handle, uid, gid, cb) {
-    return this.fsetstat(handle, {
-      uid: uid,
-      gid: gid
-    }, cb);
-  }
-  chown(path, uid, gid, cb) {
-    return this.setstat(path, {
-      uid: uid,
-      gid: gid
-    }, cb);
-  }
-  fchmod(handle, mode, cb) {
-    return this.fsetstat(handle, {
-      mode: mode
-    }, cb);
-  }
-  chmod(path, mode, cb) {
-    return this.setstat(path, {
-      mode: mode
-    }, cb);
-  }
-  readlink(path, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    /*
-      uint32     id
-      string     path
-    */
-    const pathLen = Buffer.byteLength(path);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.READLINK;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, pathLen, p);
-    buf.utf8Write(path, p += 4, pathLen);
-
-    this._requests[reqid] = {
-      cb: (err, names) => {
-        if (typeof cb !== 'function')
-          return;
-        if (err)
-          return cb(err);
-        if (!names || !names.length)
-          return cb(new Error('Response missing link info'));
-        cb(undefined, names[0].filename);
-      }
-    };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} READLINK`
-    );
-  }
-  symlink(targetPath, linkPath, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    /*
-      uint32     id
-      string     linkpath
-      string     targetpath
-    */
-    const linkLen = Buffer.byteLength(linkPath);
-    const targetLen = Buffer.byteLength(targetPath);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + linkLen + 4 + targetLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.SYMLINK;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    if (this._isOpenSSH) {
-      // OpenSSH has linkpath and targetpath positions switched
-      writeUInt32BE(buf, targetLen, p);
-      buf.utf8Write(targetPath, p += 4, targetLen);
-      writeUInt32BE(buf, linkLen, p += targetLen);
-      buf.utf8Write(linkPath, p += 4, linkLen);
-    } else {
-      writeUInt32BE(buf, linkLen, p);
-      buf.utf8Write(linkPath, p += 4, linkLen);
-      writeUInt32BE(buf, targetLen, p += linkLen);
-      buf.utf8Write(targetPath, p += 4, targetLen);
-    }
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} SYMLINK`
-    );
-  }
-  realpath(path, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    /*
-      uint32     id
-      string     path
-    */
-    const pathLen = Buffer.byteLength(path);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.REALPATH;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, pathLen, p);
-    buf.utf8Write(path, p += 4, pathLen);
-
-    this._requests[reqid] = {
-      cb: (err, names) => {
-        if (typeof cb !== 'function')
-          return;
-        if (err)
-          return cb(err);
-        if (!names || !names.length)
-          return cb(new Error('Response missing path info'));
-        cb(undefined, names[0].filename);
-      }
-    };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} REALPATH`
-    );
-  }
-  // extended requests
-  ext_openssh_rename(oldPath, newPath, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    const ext = this._extensions['posix-rename@openssh.com'];
-    if (!ext || ext !== '1')
-      throw new Error('Server does not support this extended request');
-
-    /*
-      uint32    id
-      string    "posix-rename@openssh.com"
-      string    oldpath
-      string    newpath
-    */
-    const oldLen = Buffer.byteLength(oldPath);
-    const newLen = Buffer.byteLength(newPath);
-    let p = 9;
-    const buf =
-      Buffer.allocUnsafe(4 + 1 + 4 + 4 + 24 + 4 + oldLen + 4 + newLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.EXTENDED;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, 24, p);
-    buf.utf8Write('posix-rename@openssh.com', p += 4, 24);
-    writeUInt32BE(buf, oldLen, p += 24);
-    buf.utf8Write(oldPath, p += 4, oldLen);
-    writeUInt32BE(buf, newLen, p += oldLen);
-    buf.utf8Write(newPath, p += 4, newLen);
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    if (this._debug) {
-      const which = (isBuffered ? 'Buffered' : 'Sending');
-      this._debug(`SFTP: Outbound: ${which} posix-rename@openssh.com`);
-    }
-  }
-  ext_openssh_statvfs(path, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    const ext = this._extensions['statvfs@openssh.com'];
-    if (!ext || ext !== '2')
-      throw new Error('Server does not support this extended request');
-
-    /*
-      uint32    id
-      string    "statvfs@openssh.com"
-      string    path
-    */
-    const pathLen = Buffer.byteLength(path);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 19 + 4 + pathLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.EXTENDED;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, 19, p);
-    buf.utf8Write('statvfs@openssh.com', p += 4, 19);
-    writeUInt32BE(buf, pathLen, p += 19);
-    buf.utf8Write(path, p += 4, pathLen);
-
-    this._requests[reqid] = { extended: 'statvfs@openssh.com', cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    if (this._debug) {
-      const which = (isBuffered ? 'Buffered' : 'Sending');
-      this._debug(`SFTP: Outbound: ${which} statvfs@openssh.com`);
-    }
-  }
-  ext_openssh_fstatvfs(handle, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    const ext = this._extensions['fstatvfs@openssh.com'];
-    if (!ext || ext !== '2')
-      throw new Error('Server does not support this extended request');
-    if (!Buffer.isBuffer(handle))
-      throw new Error('handle is not a Buffer');
-
-    /*
-      uint32    id
-      string    "fstatvfs@openssh.com"
-      string    handle
-    */
-    const handleLen = handle.length;
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 20 + 4 + handleLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.EXTENDED;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, 20, p);
-    buf.utf8Write('fstatvfs@openssh.com', p += 4, 20);
-    writeUInt32BE(buf, handleLen, p += 20);
-    buf.set(handle, p += 4);
-
-    this._requests[reqid] = { extended: 'fstatvfs@openssh.com', cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    if (this._debug) {
-      const which = (isBuffered ? 'Buffered' : 'Sending');
-      this._debug(`SFTP: Outbound: ${which} fstatvfs@openssh.com`);
-    }
-  }
-  ext_openssh_hardlink(oldPath, newPath, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    const ext = this._extensions['hardlink@openssh.com'];
-    if (ext !== '1')
-      throw new Error('Server does not support this extended request');
-
-    /*
-      uint32    id
-      string    "hardlink@openssh.com"
-      string    oldpath
-      string    newpath
-    */
-    const oldLen = Buffer.byteLength(oldPath);
-    const newLen = Buffer.byteLength(newPath);
-    let p = 9;
-    const buf =
-      Buffer.allocUnsafe(4 + 1 + 4 + 4 + 20 + 4 + oldLen + 4 + newLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.EXTENDED;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, 20, p);
-    buf.utf8Write('hardlink@openssh.com', p += 4, 20);
-    writeUInt32BE(buf, oldLen, p += 20);
-    buf.utf8Write(oldPath, p += 4, oldLen);
-    writeUInt32BE(buf, newLen, p += oldLen);
-    buf.utf8Write(newPath, p += 4, newLen);
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    if (this._debug) {
-      const which = (isBuffered ? 'Buffered' : 'Sending');
-      this._debug(`SFTP: Outbound: ${which} hardlink@openssh.com`);
-    }
-  }
-  ext_openssh_fsync(handle, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    const ext = this._extensions['fsync@openssh.com'];
-    if (ext !== '1')
-      throw new Error('Server does not support this extended request');
-    if (!Buffer.isBuffer(handle))
-      throw new Error('handle is not a Buffer');
-
-    /*
-      uint32    id
-      string    "fsync@openssh.com"
-      string    handle
-    */
-    const handleLen = handle.length;
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 17 + 4 + handleLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.EXTENDED;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, 17, p);
-    buf.utf8Write('fsync@openssh.com', p += 4, 17);
-    writeUInt32BE(buf, handleLen, p += 17);
-    buf.set(handle, p += 4);
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} fsync@openssh.com`
-    );
-  }
-  ext_openssh_lsetstat(path, attrs, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    const ext = this._extensions['lsetstat@openssh.com'];
-    if (ext !== '1')
-      throw new Error('Server does not support this extended request');
-
-    let flags = 0;
-    let attrsLen = 0;
-
-    if (typeof attrs === 'object' && attrs !== null) {
-      attrs = attrsToBytes(attrs);
-      flags = attrs.flags;
-      attrsLen = attrs.nb;
-    } else if (typeof attrs === 'function') {
-      cb = attrs;
-    }
-
-    /*
-      uint32    id
-      string    "lsetstat@openssh.com"
-      string    path
-      ATTRS     attrs
-    */
-    const pathLen = Buffer.byteLength(path);
-    let p = 9;
-    const buf =
-      Buffer.allocUnsafe(4 + 1 + 4 + 4 + 20 + 4 + pathLen + 4 + attrsLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.EXTENDED;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, 20, p);
-    buf.utf8Write('lsetstat@openssh.com', p += 4, 20);
-
-    writeUInt32BE(buf, pathLen, p += 20);
-    buf.utf8Write(path, p += 4, pathLen);
-
-    writeUInt32BE(buf, flags, p += pathLen);
-    if (attrsLen) {
-      p += 4;
-
-      if (attrsLen === ATTRS_BUF.length)
-        buf.set(ATTRS_BUF, p);
-      else
-        bufferCopy(ATTRS_BUF, buf, 0, attrsLen, p);
-
-      p += attrsLen;
-    }
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    if (this._debug) {
-      const status = (isBuffered ? 'Buffered' : 'Sending');
-      this._debug(`SFTP: Outbound: ${status} lsetstat@openssh.com`);
-    }
-  }
-  ext_openssh_expandPath(path, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    const ext = this._extensions['expand-path@openssh.com'];
-    if (ext !== '1')
-      throw new Error('Server does not support this extended request');
-
-    /*
-      uint32    id
-      string    "expand-path@openssh.com"
-      string    path
-    */
-    const pathLen = Buffer.byteLength(path);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 23 + 4 + pathLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = REQUEST.EXTENDED;
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, 23, p);
-    buf.utf8Write('expand-path@openssh.com', p += 4, 23);
-
-    writeUInt32BE(buf, pathLen, p += 20);
-    buf.utf8Write(path, p += 4, pathLen);
-
-    this._requests[reqid] = {
-      cb: (err, names) => {
-        if (typeof cb !== 'function')
-          return;
-        if (err)
-          return cb(err);
-        if (!names || !names.length)
-          return cb(new Error('Response missing expanded path'));
-        cb(undefined, names[0].filename);
-      }
-    };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    if (this._debug) {
-      const status = (isBuffered ? 'Buffered' : 'Sending');
-      this._debug(`SFTP: Outbound: ${status} expand-path@openssh.com`);
-    }
-  }
-  ext_copy_data(srcHandle, srcOffset, len, dstHandle, dstOffset, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    const ext = this._extensions['copy-data'];
-    if (ext !== '1')
-      throw new Error('Server does not support this extended request');
-
-    if (!Buffer.isBuffer(srcHandle))
-      throw new Error('Source handle is not a Buffer');
-
-    if (!Buffer.isBuffer(dstHandle))
-      throw new Error('Destination handle is not a Buffer');
-
-    /*
-      uint32    id
-      string    "copy-data"
-      string    read-from-handle
-      uint64    read-from-offset
-      uint64    read-data-length
-      string    write-to-handle
-      uint64    write-to-offset
-    */
-    let p = 0;
-    const buf = Buffer.allocUnsafe(
-      4 + 1
-      + 4
-      + 4 + 9
-      + 4 + srcHandle.length
-      + 8
-      + 8
-      + 4 + dstHandle.length
-      + 8
-    );
-
-    writeUInt32BE(buf, buf.length - 4, p);
-    p += 4;
-
-    buf[p] = REQUEST.EXTENDED;
-    ++p;
-
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, p);
-    p += 4;
-
-    writeUInt32BE(buf, 9, p);
-    p += 4;
-    buf.utf8Write('copy-data', p, 9);
-    p += 9;
-
-    writeUInt32BE(buf, srcHandle.length, p);
-    p += 4;
-    buf.set(srcHandle, p);
-    p += srcHandle.length;
-
-    for (let i = 7; i >= 0; --i) {
-      buf[p + i] = srcOffset & 0xFF;
-      srcOffset /= 256;
-    }
-    p += 8;
-
-    for (let i = 7; i >= 0; --i) {
-      buf[p + i] = len & 0xFF;
-      len /= 256;
-    }
-    p += 8;
-
-    writeUInt32BE(buf, dstHandle.length, p);
-    p += 4;
-    buf.set(dstHandle, p);
-    p += dstHandle.length;
-
-    for (let i = 7; i >= 0; --i) {
-      buf[p + i] = dstOffset & 0xFF;
-      dstOffset /= 256;
-    }
-
-    this._requests[reqid] = { cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    if (this._debug) {
-      const status = (isBuffered ? 'Buffered' : 'Sending');
-      this._debug(`SFTP: Outbound: ${status} copy-data`);
-    }
-  }
-  ext_home_dir(username, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    const ext = this._extensions['home-directory'];
-    if (ext !== '1')
-      throw new Error('Server does not support this extended request');
-
-    if (typeof username !== 'string')
-      throw new TypeError('username is not a string');
-
-    /*
-      uint32    id
-      string    "home-directory"
-      string    username
-    */
-    let p = 0;
-    const usernameLen = Buffer.byteLength(username);
-    const buf = Buffer.allocUnsafe(
-      4 + 1
-      + 4
-      + 4 + 14
-      + 4 + usernameLen
-    );
-
-    writeUInt32BE(buf, buf.length - 4, p);
-    p += 4;
-
-    buf[p] = REQUEST.EXTENDED;
-    ++p;
-
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, p);
-    p += 4;
-
-    writeUInt32BE(buf, 14, p);
-    p += 4;
-    buf.utf8Write('home-directory', p, 14);
-    p += 14;
-
-    writeUInt32BE(buf, usernameLen, p);
-    p += 4;
-    buf.utf8Write(username, p, usernameLen);
-    p += usernameLen;
-
-    this._requests[reqid] = {
-      cb: (err, names) => {
-        if (typeof cb !== 'function')
-          return;
-        if (err)
-          return cb(err);
-        if (!names || !names.length)
-          return cb(new Error('Response missing home directory'));
-        cb(undefined, names[0].filename);
-      }
-    };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    if (this._debug) {
-      const status = (isBuffered ? 'Buffered' : 'Sending');
-      this._debug(`SFTP: Outbound: ${status} home-directory`);
-    }
-  }
-  ext_users_groups(uids, gids, cb) {
-    if (this.server)
-      throw new Error('Client-only method called in server mode');
-
-    const ext = this._extensions['users-groups-by-id@openssh.com'];
-    if (ext !== '1')
-      throw new Error('Server does not support this extended request');
-
-    if (!Array.isArray(uids))
-      throw new TypeError('uids is not an array');
-    for (const val of uids) {
-      if (!Number.isInteger(val) || val < 0 || val > (2 ** 32 - 1))
-        throw new Error('uid values must all be 32-bit unsigned integers');
-    }
-    if (!Array.isArray(gids))
-      throw new TypeError('gids is not an array');
-    for (const val of gids) {
-      if (!Number.isInteger(val) || val < 0 || val > (2 ** 32 - 1))
-        throw new Error('gid values must all be 32-bit unsigned integers');
-    }
-
-    /*
-      uint32    id
-      string    "users-groups-by-id@openssh.com"
-      string    uids
-        uint32    uid1
-        ...
-      string    gids
-        uint32    gid1
-        ...
-    */
-    let p = 0;
-    const buf = Buffer.allocUnsafe(
-      4 + 1
-      + 4
-      + 4 + 30
-      + 4 + (4 * uids.length)
-      + 4 + (4 * gids.length)
-    );
-
-    writeUInt32BE(buf, buf.length - 4, p);
-    p += 4;
-
-    buf[p] = REQUEST.EXTENDED;
-    ++p;
-
-    const reqid = this._writeReqid = (this._writeReqid + 1) & MAX_REQID;
-    writeUInt32BE(buf, reqid, p);
-    p += 4;
-
-    writeUInt32BE(buf, 30, p);
-    p += 4;
-    buf.utf8Write('users-groups-by-id@openssh.com', p, 30);
-    p += 30;
-
-    writeUInt32BE(buf, 4 * uids.length, p);
-    p += 4;
-    for (const val of uids) {
-      writeUInt32BE(buf, val, p);
-      p += 4;
-    }
-
-    writeUInt32BE(buf, 4 * gids.length, p);
-    p += 4;
-    for (const val of gids) {
-      writeUInt32BE(buf, val, p);
-      p += 4;
-    }
-
-    this._requests[reqid] = { extended: 'users-groups-by-id@openssh.com', cb };
-
-    const isBuffered = sendOrBuffer(this, buf);
-    if (this._debug) {
-      const status = (isBuffered ? 'Buffered' : 'Sending');
-      this._debug(`SFTP: Outbound: ${status} users-groups-by-id@openssh.com`);
-    }
-  }
-  // ===========================================================================
-  // Server-specific ===========================================================
-  // ===========================================================================
-  handle(reqid, handle) {
-    if (!this.server)
-      throw new Error('Server-only method called in client mode');
-
-    if (!Buffer.isBuffer(handle))
-      throw new Error('handle is not a Buffer');
-
-    const handleLen = handle.length;
-
-    if (handleLen > 256)
-      throw new Error('handle too large (> 256 bytes)');
-
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = RESPONSE.HANDLE;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, handleLen, p);
-    if (handleLen)
-      buf.set(handle, p += 4);
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} HANDLE`
-    );
-  }
-  status(reqid, code, message) {
-    if (!this.server)
-      throw new Error('Server-only method called in client mode');
-
-    if (!VALID_STATUS_CODES.has(code))
-      throw new Error(`Bad status code: ${code}`);
-
-    message || (message = '');
-
-    const msgLen = Buffer.byteLength(message);
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 4 + msgLen + 4);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = RESPONSE.STATUS;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, code, p);
-
-    writeUInt32BE(buf, msgLen, p += 4);
-    p += 4;
-    if (msgLen) {
-      buf.utf8Write(message, p, msgLen);
-      p += msgLen;
-    }
-
-    writeUInt32BE(buf, 0, p); // Empty language tag
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} STATUS`
-    );
-  }
-  data(reqid, data, encoding) {
-    if (!this.server)
-      throw new Error('Server-only method called in client mode');
-
-    const isBuffer = Buffer.isBuffer(data);
-
-    if (!isBuffer && typeof data !== 'string')
-      throw new Error('data is not a Buffer or string');
-
-    let isUTF8;
-    if (!isBuffer && !encoding) {
-      encoding = undefined;
-      isUTF8 = true;
-    }
-
-    const dataLen = (
-      isBuffer
-      ? data.length
-      : Buffer.byteLength(data, encoding)
-    );
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + dataLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = RESPONSE.DATA;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, dataLen, p);
-    if (dataLen) {
-      if (isBuffer)
-        buf.set(data, p += 4);
-      else if (isUTF8)
-        buf.utf8Write(data, p += 4, dataLen);
-      else
-        buf.write(data, p += 4, dataLen, encoding);
-    }
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} DATA`
-    );
-  }
-  name(reqid, names) {
-    if (!this.server)
-      throw new Error('Server-only method called in client mode');
-
-    if (!Array.isArray(names)) {
-      if (typeof names !== 'object' || names === null)
-        throw new Error('names is not an object or array');
-      names = [ names ];
-    }
-
-    const count = names.length;
-    let namesLen = 0;
-    let nameAttrs;
-    const attrs = [];
-
-    for (let i = 0; i < count; ++i) {
-      const name = names[i];
-      const filename = (
-        !name || !name.filename || typeof name.filename !== 'string'
-        ? ''
-        : name.filename
-      );
-      namesLen += 4 + Buffer.byteLength(filename);
-      const longname = (
-        !name || !name.longname || typeof name.longname !== 'string'
-        ? ''
-        : name.longname
-      );
-      namesLen += 4 + Buffer.byteLength(longname);
-
-      if (typeof name.attrs === 'object' && name.attrs !== null) {
-        nameAttrs = attrsToBytes(name.attrs);
-        namesLen += 4 + nameAttrs.nb;
-
-        if (nameAttrs.nb) {
-          let bytes;
-
-          if (nameAttrs.nb === ATTRS_BUF.length) {
-            bytes = new Uint8Array(ATTRS_BUF);
-          } else {
-            bytes = new Uint8Array(nameAttrs.nb);
-            bufferCopy(ATTRS_BUF, bytes, 0, nameAttrs.nb, 0);
-          }
-
-          nameAttrs.bytes = bytes;
-        }
-
-        attrs.push(nameAttrs);
-      } else {
-        namesLen += 4;
-        attrs.push(null);
-      }
-    }
-
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + namesLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = RESPONSE.NAME;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, count, p);
-
-    p += 4;
-
-    for (let i = 0; i < count; ++i) {
-      const name = names[i];
-
-      {
-        const filename = (
-          !name || !name.filename || typeof name.filename !== 'string'
-          ? ''
-          : name.filename
-        );
-        const len = Buffer.byteLength(filename);
-        writeUInt32BE(buf, len, p);
-        p += 4;
-        if (len) {
-          buf.utf8Write(filename, p, len);
-          p += len;
-        }
-      }
-
-      {
-        const longname = (
-          !name || !name.longname || typeof name.longname !== 'string'
-          ? ''
-          : name.longname
-        );
-        const len = Buffer.byteLength(longname);
-        writeUInt32BE(buf, len, p);
-        p += 4;
-        if (len) {
-          buf.utf8Write(longname, p, len);
-          p += len;
-        }
-      }
-
-      const attr = attrs[i];
-      if (attr) {
-        writeUInt32BE(buf, attr.flags, p);
-        p += 4;
-        if (attr.flags && attr.bytes) {
-          buf.set(attr.bytes, p);
-          p += attr.nb;
-        }
-      } else {
-        writeUInt32BE(buf, 0, p);
-        p += 4;
-      }
-    }
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} NAME`
-    );
-  }
-  attrs(reqid, attrs) {
-    if (!this.server)
-      throw new Error('Server-only method called in client mode');
-
-    if (typeof attrs !== 'object' || attrs === null)
-      throw new Error('attrs is not an object');
-
-    attrs = attrsToBytes(attrs);
-    const flags = attrs.flags;
-    const attrsLen = attrs.nb;
-    let p = 9;
-    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + attrsLen);
-
-    writeUInt32BE(buf, buf.length - 4, 0);
-    buf[4] = RESPONSE.ATTRS;
-    writeUInt32BE(buf, reqid, 5);
-
-    writeUInt32BE(buf, flags, p);
-    if (attrsLen) {
-      p += 4;
-
-      if (attrsLen === ATTRS_BUF.length)
-        buf.set(ATTRS_BUF, p);
-      else
-        bufferCopy(ATTRS_BUF, buf, 0, attrsLen, p);
-
-      p += attrsLen;
-    }
-
-    const isBuffered = sendOrBuffer(this, buf);
-    this._debug && this._debug(
-      `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} ATTRS`
-    );
-  }
-}
-
-function tryCreateBuffer(size) {
-  try {
-    return Buffer.allocUnsafe(size);
-  } catch (ex) {
-    return ex;
-  }
-}
-
-function read_(self, handle, buf, off, len, position, cb, req_) {
-  const maxDataLen = self._maxReadLen;
-  const overflow = Math.max(len - maxDataLen, 0);
-
-  if (overflow)
-    len = maxDataLen;
-
-  /*
-    uint32     id
-    string     handle
-    uint64     offset
-    uint32     len
-  */
-  const handleLen = handle.length;
-  let p = 9;
-  let pos = position;
-  const out = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen + 8 + 4);
-
-  writeUInt32BE(out, out.length - 4, 0);
-  out[4] = REQUEST.READ;
-  const reqid = self._writeReqid = (self._writeReqid + 1) & MAX_REQID;
-  writeUInt32BE(out, reqid, 5);
-
-  writeUInt32BE(out, handleLen, p);
-  out.set(handle, p += 4);
-  p += handleLen;
-  for (let i = 7; i >= 0; --i) {
-    out[p + i] = pos & 0xFF;
-    pos /= 256;
-  }
-  writeUInt32BE(out, len, p += 8);
-
-  if (typeof cb !== 'function')
-    cb = noop;
-
-  const req = (req_ || {
-    nb: 0,
-    position,
-    off,
-    origOff: off,
-    len: undefined,
-    overflow: undefined,
-    cb: (err, data, nb) => {
-      const len = req.len;
-      const overflow = req.overflow;
-
-      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'));
-      } else if (nb === len && overflow) {
-        req.nb += nb;
-        req.position += nb;
-        req.off += nb;
-        read_(self, handle, buf, req.off, overflow, req.position, cb, req);
-        return;
-      }
-
-      nb = (nb || 0);
-      if (req.origOff === 0 && buf.length === req.nb)
-        data = buf;
-      else
-        data = bufferSlice(buf, req.origOff, req.origOff + req.nb + nb);
-      cb(undefined, req.nb + nb, data, req.position);
-    },
-    buffer: undefined,
-  });
-
-  req.len = len;
-  req.overflow = overflow;
-
-  // TODO: avoid creating multiple buffer slices when we need to re-call read_()
-  // because of overflow
-  req.buffer = bufferSlice(buf, off, off + len);
-
-  self._requests[reqid] = req;
-
-  const isBuffered = sendOrBuffer(self, out);
-  self._debug && self._debug(
-    `SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} READ`
-  );
-}
-
-function fastXfer(src, dst, srcPath, dstPath, opts, cb) {
-  let concurrency = 64;
-  let chunkSize = 32768;
-  let onstep;
-  let mode;
-  let 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;
-
-    if (typeof opts.mode === 'string' || typeof opts.mode === 'number')
-      mode = modeNum(opts.mode);
-  }
-
-  // Internal state variables
-  let fsize;
-  let pdst = 0;
-  let total = 0;
-  let hadError = false;
-  let srcHandle;
-  let dstHandle;
-  let readbuf;
-  let bufsize = chunkSize * concurrency;
-
-  function onerror(err) {
-    if (hadError)
-      return;
-
-    hadError = true;
-
-    let left = 0;
-    let cbfinal;
-
-    if (srcHandle || dstHandle) {
-      cbfinal = () => {
-        if (--left === 0)
-          cb(err);
-      };
-      if (srcHandle && (src === fs || src.outgoing.state === 'open'))
-        ++left;
-      if (dstHandle && (dst === fs || dst.outgoing.state === 'open'))
-        ++left;
-      if (srcHandle && (src === fs || src.outgoing.state === 'open'))
-        src.close(srcHandle, cbfinal);
-      if (dstHandle && (dst === fs || dst.outgoing.state === 'open'))
-        dst.close(dstHandle, cbfinal);
-    } else {
-      cb(err);
-    }
-  }
-
-  src.open(srcPath, 'r', (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, (err_, attrs_) => {
-            if (err_)
-              return onerror(err);
-            tryStat(null, attrs_);
-          });
-          return;
-        }
-        return onerror(err);
-      }
-      fsize = attrs.size;
-
-      dst.open(dstPath, 'w', (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, (err_) => tryAgain());
-              return;
-            }
-            startReads();
-          });
-        } else {
-          startReads();
-        }
-
-        function onread(err, nb, data, dstpos, datapos, origChunkLen) {
-          if (err)
-            return onerror(err);
-
-          datapos = datapos || 0;
-
-          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, (err) => {
-                dstHandle = undefined;
-                if (err)
-                  return onerror(err);
-                src.close(srcHandle, (err) => {
-                  srcHandle = undefined;
-                  if (err)
-                    return onerror(err);
-                  cb();
-                });
-              });
-              return;
-            }
-
-            if (pdst >= fsize)
-              return;
-
-            const chunk =
-              (pdst + chunkSize > fsize ? fsize - pdst : chunkSize);
-            singleRead(datapos, pdst, chunk);
-            pdst += chunk;
-          }
-        }
-
-        function makeCb(psrc, pdst, chunk) {
-          return (err, nb, data) => {
-            onread(err, nb, data, pdst, psrc, chunk);
-          };
-        }
-
-        function singleRead(psrc, pdst, chunk) {
-          src.read(srcHandle,
-                   readbuf,
-                   psrc,
-                   chunk,
-                   pdst,
-                   makeCb(psrc, pdst, chunk));
-        }
-
-        function startReads() {
-          let reads = 0;
-          let psrc = 0;
-          while (pdst < fsize && reads < concurrency) {
-            const chunk =
-              (pdst + chunkSize > fsize ? fsize - pdst : chunkSize);
-            singleRead(psrc, pdst, chunk);
-            psrc += chunk;
-            pdst += chunk;
-            ++reads;
-          }
-        }
-      });
-    }
-  });
-}
-
-function writeAll(sftp, handle, buffer, offset, length, position, callback_) {
-  const callback = (typeof callback_ === 'function' ? callback_ : undefined);
-
-  sftp.write(handle,
-             buffer,
-             offset,
-             length,
-             position,
-             (writeErr, written) => {
-    if (writeErr) {
-      return sftp.close(handle, () => {
-        callback && callback(writeErr);
-      });
-    }
-    if (written === length) {
-      sftp.close(handle, callback);
-    } else {
-      offset += written;
-      length -= written;
-      position += written;
-      writeAll(sftp, handle, buffer, offset, length, position, callback);
-    }
-  });
-}
-
-class Stats {
-  constructor(initial) {
-    this.mode = (initial && initial.mode);
-    this.uid = (initial && initial.uid);
-    this.gid = (initial && initial.gid);
-    this.size = (initial && initial.size);
-    this.atime = (initial && initial.atime);
-    this.mtime = (initial && initial.mtime);
-    this.extended = (initial && initial.extended);
-  }
-  isDirectory() {
-    return ((this.mode & constants.S_IFMT) === constants.S_IFDIR);
-  }
-  isFile() {
-    return ((this.mode & constants.S_IFMT) === constants.S_IFREG);
-  }
-  isBlockDevice() {
-    return ((this.mode & constants.S_IFMT) === constants.S_IFBLK);
-  }
-  isCharacterDevice() {
-    return ((this.mode & constants.S_IFMT) === constants.S_IFCHR);
-  }
-  isSymbolicLink() {
-    return ((this.mode & constants.S_IFMT) === constants.S_IFLNK);
-  }
-  isFIFO() {
-    return ((this.mode & constants.S_IFMT) === constants.S_IFIFO);
-  }
-  isSocket() {
-    return ((this.mode & constants.S_IFMT) === constants.S_IFSOCK);
-  }
-}
-
-function attrsToBytes(attrs) {
-  let flags = 0;
-  let nb = 0;
-
-  if (typeof attrs === 'object' && attrs !== null) {
-    if (typeof attrs.size === 'number') {
-      flags |= ATTR.SIZE;
-      const val = attrs.size;
-      // Big Endian
-      ATTRS_BUF[nb++] = val / 72057594037927940; // 2**56
-      ATTRS_BUF[nb++] = val / 281474976710656; // 2**48
-      ATTRS_BUF[nb++] = val / 1099511627776; // 2**40
-      ATTRS_BUF[nb++] = val / 4294967296; // 2**32
-      ATTRS_BUF[nb++] = val / 16777216; // 2**24
-      ATTRS_BUF[nb++] = val / 65536; // 2**16
-      ATTRS_BUF[nb++] = val / 256; // 2**8
-      ATTRS_BUF[nb++] = val;
-    }
-    if (typeof attrs.uid === 'number' && typeof attrs.gid === 'number') {
-      flags |= ATTR.UIDGID;
-      const uid = attrs.uid;
-      const gid = attrs.gid;
-      // Big Endian
-      ATTRS_BUF[nb++] = uid >>> 24;
-      ATTRS_BUF[nb++] = uid >>> 16;
-      ATTRS_BUF[nb++] = uid >>> 8;
-      ATTRS_BUF[nb++] = uid;
-      ATTRS_BUF[nb++] = gid >>> 24;
-      ATTRS_BUF[nb++] = gid >>> 16;
-      ATTRS_BUF[nb++] = gid >>> 8;
-      ATTRS_BUF[nb++] = gid;
-    }
-    if (typeof attrs.mode === 'number' || typeof attrs.mode === 'string') {
-      const mode = modeNum(attrs.mode);
-      flags |= ATTR.PERMISSIONS;
-      // Big Endian
-      ATTRS_BUF[nb++] = mode >>> 24;
-      ATTRS_BUF[nb++] = mode >>> 16;
-      ATTRS_BUF[nb++] = mode >>> 8;
-      ATTRS_BUF[nb++] = mode;
-    }
-    if ((typeof attrs.atime === 'number' || isDate(attrs.atime))
-        && (typeof attrs.mtime === 'number' || isDate(attrs.mtime))) {
-      const atime = toUnixTimestamp(attrs.atime);
-      const mtime = toUnixTimestamp(attrs.mtime);
-
-      flags |= ATTR.ACMODTIME;
-      // Big Endian
-      ATTRS_BUF[nb++] = atime >>> 24;
-      ATTRS_BUF[nb++] = atime >>> 16;
-      ATTRS_BUF[nb++] = atime >>> 8;
-      ATTRS_BUF[nb++] = atime;
-      ATTRS_BUF[nb++] = mtime >>> 24;
-      ATTRS_BUF[nb++] = mtime >>> 16;
-      ATTRS_BUF[nb++] = mtime >>> 8;
-      ATTRS_BUF[nb++] = mtime;
-    }
-    // TODO: extended attributes
-  }
-
-  return { flags, nb };
-}
-
-function toUnixTimestamp(time) {
-  // eslint-disable-next-line no-self-compare
-  if (typeof time === 'number' && time === time) // Valid, non-NaN number
-    return time;
-  if (isDate(time))
-    return parseInt(time.getTime() / 1000, 10);
-  throw new Error(`Cannot parse time: ${time}`);
-}
-
-function modeNum(mode) {
-  // eslint-disable-next-line no-self-compare
-  if (typeof mode === 'number' && mode === mode) // Valid, non-NaN number
-    return mode;
-  if (typeof mode === 'string')
-    return modeNum(parseInt(mode, 8));
-  throw new Error(`Cannot parse mode: ${mode}`);
-}
-
-const stringFlagMap = {
-  'r': OPEN_MODE.READ,
-  'r+': OPEN_MODE.READ | OPEN_MODE.WRITE,
-  'w': OPEN_MODE.TRUNC | OPEN_MODE.CREAT | OPEN_MODE.WRITE,
-  'wx': OPEN_MODE.TRUNC | OPEN_MODE.CREAT | OPEN_MODE.WRITE | OPEN_MODE.EXCL,
-  'xw': OPEN_MODE.TRUNC | OPEN_MODE.CREAT | OPEN_MODE.WRITE | OPEN_MODE.EXCL,
-  'w+': OPEN_MODE.TRUNC | OPEN_MODE.CREAT | OPEN_MODE.READ | OPEN_MODE.WRITE,
-  'wx+': OPEN_MODE.TRUNC | OPEN_MODE.CREAT | OPEN_MODE.READ | OPEN_MODE.WRITE
-         | OPEN_MODE.EXCL,
-  'xw+': OPEN_MODE.TRUNC | OPEN_MODE.CREAT | OPEN_MODE.READ | OPEN_MODE.WRITE
-         | OPEN_MODE.EXCL,
-  'a': OPEN_MODE.APPEND | OPEN_MODE.CREAT | OPEN_MODE.WRITE,
-  'ax': OPEN_MODE.APPEND | OPEN_MODE.CREAT | OPEN_MODE.WRITE | OPEN_MODE.EXCL,
-  'xa': OPEN_MODE.APPEND | OPEN_MODE.CREAT | OPEN_MODE.WRITE | OPEN_MODE.EXCL,
-  'a+': OPEN_MODE.APPEND | OPEN_MODE.CREAT | OPEN_MODE.READ | OPEN_MODE.WRITE,
-  'ax+': OPEN_MODE.APPEND | OPEN_MODE.CREAT | OPEN_MODE.READ | OPEN_MODE.WRITE
-         | OPEN_MODE.EXCL,
-  'xa+': OPEN_MODE.APPEND | OPEN_MODE.CREAT | OPEN_MODE.READ | OPEN_MODE.WRITE
-         | OPEN_MODE.EXCL
-};
-
-function stringToFlags(str) {
-  const flags = stringFlagMap[str];
-  return (flags !== undefined ? flags : null);
-}
-
-const flagsToString = (() => {
-  const stringFlagMapKeys = Object.keys(stringFlagMap);
-  return (flags) => {
-    for (let i = 0; i < stringFlagMapKeys.length; ++i) {
-      const key = stringFlagMapKeys[i];
-      if (stringFlagMap[key] === flags)
-        return key;
-    }
-    return null;
-  };
-})();
-
-function readAttrs(biOpt) {
-  /*
-    uint32   flags
-    uint64   size           present only if flag SSH_FILEXFER_ATTR_SIZE
-    uint32   uid            present only if flag SSH_FILEXFER_ATTR_UIDGID
-    uint32   gid            present only if flag SSH_FILEXFER_ATTR_UIDGID
-    uint32   permissions    present only if flag SSH_FILEXFER_ATTR_PERMISSIONS
-    uint32   atime          present only if flag SSH_FILEXFER_ACMODTIME
-    uint32   mtime          present only if flag SSH_FILEXFER_ACMODTIME
-    uint32   extended_count present only if flag SSH_FILEXFER_ATTR_EXTENDED
-    string   extended_type
-    string   extended_data
-    ...      more extended data (extended_type - extended_data pairs),
-               so that number of pairs equals extended_count
-  */
-  const flags = bufferParser.readUInt32BE();
-  if (flags === undefined)
-    return;
-
-  const attrs = new Stats();
-  if (flags & ATTR.SIZE) {
-    const size = bufferParser.readUInt64BE(biOpt);
-    if (size === undefined)
-      return;
-    attrs.size = size;
-  }
-
-  if (flags & ATTR.UIDGID) {
-    const uid = bufferParser.readUInt32BE();
-    const gid = bufferParser.readUInt32BE();
-    if (gid === undefined)
-      return;
-    attrs.uid = uid;
-    attrs.gid = gid;
-  }
-
-  if (flags & ATTR.PERMISSIONS) {
-    const mode = bufferParser.readUInt32BE();
-    if (mode === undefined)
-      return;
-    attrs.mode = mode;
-  }
-
-  if (flags & ATTR.ACMODTIME) {
-    const atime = bufferParser.readUInt32BE();
-    const mtime = bufferParser.readUInt32BE();
-    if (mtime === undefined)
-      return;
-    attrs.atime = atime;
-    attrs.mtime = mtime;
-  }
-
-  if (flags & ATTR.EXTENDED) {
-    const count = bufferParser.readUInt32BE();
-    if (count === undefined)
-      return;
-    const extended = {};
-    for (let i = 0; i < count; ++i) {
-      const type = bufferParser.readString(true);
-      const data = bufferParser.readString();
-      if (data === undefined)
-        return;
-      extended[type] = data;
-    }
-    attrs.extended = extended;
-  }
-
-  return attrs;
-}
-
-function sendOrBuffer(sftp, payload) {
-  const ret = tryWritePayload(sftp, payload);
-  if (ret !== undefined) {
-    sftp._buffer.push(ret);
-    return false;
-  }
-  return true;
-}
-
-function tryWritePayload(sftp, payload) {
-  const outgoing = sftp.outgoing;
-  if (outgoing.state !== 'open')
-    return;
-
-  if (outgoing.window === 0) {
-    sftp._waitWindow = true;
-    sftp._chunkcb = drainBuffer;
-    return payload;
-  }
-
-  let ret;
-  const len = payload.length;
-  let p = 0;
-
-  while (len - p > 0 && outgoing.window > 0) {
-    const actualLen = Math.min(len - p, outgoing.window, outgoing.packetSize);
-    outgoing.window -= actualLen;
-    if (outgoing.window === 0) {
-      sftp._waitWindow = true;
-      sftp._chunkcb = drainBuffer;
-    }
-
-    if (p === 0 && actualLen === len) {
-      sftp._protocol.channelData(sftp.outgoing.id, payload);
-    } else {
-      sftp._protocol.channelData(sftp.outgoing.id,
-                                 bufferSlice(payload, p, p + actualLen));
-    }
-
-    p += actualLen;
-  }
-
-  if (len - p > 0) {
-    if (p > 0)
-      ret = bufferSlice(payload, p, len);
-    else
-      ret = payload; // XXX: should never get here?
-  }
-
-  return ret;
-}
-
-function drainBuffer() {
-  this._chunkcb = undefined;
-  const buffer = this._buffer;
-  let i = 0;
-  while (i < buffer.length) {
-    const payload = buffer[i];
-    const ret = tryWritePayload(this, payload);
-    if (ret !== undefined) {
-      if (ret !== payload)
-        buffer[i] = ret;
-      if (i > 0)
-        this._buffer = buffer.slice(i);
-      return;
-    }
-    ++i;
-  }
-  if (i > 0)
-    this._buffer = [];
-}
-
-function doFatalSFTPError(sftp, msg, noDebug) {
-  const err = new Error(msg);
-  err.level = 'sftp-protocol';
-  if (!noDebug && sftp._debug)
-    sftp._debug(`SFTP: Inbound: ${msg}`);
-  sftp.emit('error', err);
-  sftp.destroy();
-  cleanupRequests(sftp);
-  return false;
-}
-
-function cleanupRequests(sftp) {
-  const keys = Object.keys(sftp._requests);
-  if (keys.length === 0)
-    return;
-
-  const reqs = sftp._requests;
-  sftp._requests = {};
-  const err = new Error('No response from server');
-  for (let i = 0; i < keys.length; ++i) {
-    const req = reqs[keys[i]];
-    if (typeof req.cb === 'function')
-      req.cb(err);
-  }
-}
-
-function requestLimits(sftp, cb) {
-  /*
-    uint32    id
-    string    "limits@openssh.com"
-  */
-  let p = 9;
-  const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 18);
-
-  writeUInt32BE(buf, buf.length - 4, 0);
-  buf[4] = REQUEST.EXTENDED;
-  const reqid = sftp._writeReqid = (sftp._writeReqid + 1) & MAX_REQID;
-  writeUInt32BE(buf, reqid, 5);
-
-  writeUInt32BE(buf, 18, p);
-  buf.utf8Write('limits@openssh.com', p += 4, 18);
-
-  sftp._requests[reqid] = { extended: 'limits@openssh.com', cb };
-
-  const isBuffered = sendOrBuffer(sftp, buf);
-  if (sftp._debug) {
-    const which = (isBuffered ? 'Buffered' : 'Sending');
-    sftp._debug(`SFTP: Outbound: ${which} limits@openssh.com`);
-  }
-}
-
-const CLIENT_HANDLERS = {
-  [RESPONSE.VERSION]: (sftp, payload) => {
-    if (sftp._version !== -1)
-      return doFatalSFTPError(sftp, 'Duplicate VERSION packet');
-
-    const extensions = {};
-
-    /*
-      uint32 version
-      <extension data>
-    */
-    bufferParser.init(payload, 1);
-    let version = bufferParser.readUInt32BE();
-    while (bufferParser.avail()) {
-      const extName = bufferParser.readString(true);
-      const extData = bufferParser.readString(true);
-      if (extData === undefined) {
-        version = undefined;
-        break;
-      }
-      extensions[extName] = extData;
-    }
-    bufferParser.clear();
-
-    if (version === undefined)
-      return doFatalSFTPError(sftp, 'Malformed VERSION packet');
-
-    if (sftp._debug) {
-      const names = Object.keys(extensions);
-      if (names.length) {
-        sftp._debug(
-          `SFTP: Inbound: Received VERSION (v${version}, exts:${names})`
-        );
-      } else {
-        sftp._debug(`SFTP: Inbound: Received VERSION (v${version})`);
-      }
-    }
-
-    sftp._version = version;
-    sftp._extensions = extensions;
-
-    if (extensions['limits@openssh.com'] === '1') {
-      return requestLimits(sftp, (err, limits) => {
-        if (!err) {
-          if (limits.maxPktLen > 0)
-            sftp._maxOutPktLen = limits.maxPktLen;
-          if (limits.maxReadLen > 0)
-            sftp._maxReadLen = limits.maxReadLen;
-          if (limits.maxWriteLen > 0)
-            sftp._maxWriteLen = limits.maxWriteLen;
-          sftp.maxOpenHandles = (
-            limits.maxOpenHandles > 0 ? limits.maxOpenHandles : Infinity
-          );
-        }
-        sftp.emit('ready');
-      });
-    }
-
-    sftp.emit('ready');
-  },
-  [RESPONSE.STATUS]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      uint32     error/status code
-      string     error message (ISO-10646 UTF-8)
-      string     language tag
-    */
-    const errorCode = bufferParser.readUInt32BE();
-    const errorMsg = bufferParser.readString(true);
-    bufferParser.clear();
-
-    // Note: we avoid checking that the error message and language tag are in
-    // the packet because there are some broken implementations that incorrectly
-    // omit them. The language tag in general was never really used amongst ssh
-    // implementations, so in the case of a missing error message we just
-    // default to something sensible.
-
-    if (sftp._debug) {
-      const jsonMsg = JSON.stringify(errorMsg);
-      sftp._debug(
-        `SFTP: Inbound: Received STATUS (id:${reqID}, ${errorCode}, ${jsonMsg})`
-      );
-    }
-    const req = sftp._requests[reqID];
-    delete sftp._requests[reqID];
-    if (req && typeof req.cb === 'function') {
-      if (errorCode === STATUS_CODE.OK) {
-        req.cb();
-        return;
-      }
-      const err = new Error(errorMsg
-                            || STATUS_CODE_STR[errorCode]
-                            || 'Unknown status');
-      err.code = errorCode;
-      req.cb(err);
-    }
-  },
-  [RESPONSE.HANDLE]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     handle
-    */
-    const handle = bufferParser.readString();
-    bufferParser.clear();
-
-    if (handle === undefined) {
-      if (reqID !== undefined)
-        delete sftp._requests[reqID];
-      return doFatalSFTPError(sftp, 'Malformed HANDLE packet');
-    }
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received HANDLE (id:${reqID})`);
-
-    const req = sftp._requests[reqID];
-    delete sftp._requests[reqID];
-    if (req && typeof req.cb === 'function')
-      req.cb(undefined, handle);
-  },
-  [RESPONSE.DATA]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    let req;
-    if (reqID !== undefined) {
-      req = sftp._requests[reqID];
-      delete sftp._requests[reqID];
-    }
-    /*
-      string     data
-    */
-    if (req && typeof req.cb === 'function') {
-      if (req.buffer) {
-        // We have already pre-allocated space to store the data
-
-        const nb = bufferParser.readString(req.buffer);
-        bufferParser.clear();
-
-        if (nb !== undefined) {
-          sftp._debug && sftp._debug(
-            `SFTP: Inbound: Received DATA (id:${reqID}, ${nb})`
-          );
-          req.cb(undefined, req.buffer, nb);
-          return;
-        }
-      } else {
-        const data = bufferParser.readString();
-        bufferParser.clear();
-
-        if (data !== undefined) {
-          sftp._debug && sftp._debug(
-            `SFTP: Inbound: Received DATA (id:${reqID}, ${data.length})`
-          );
-          req.cb(undefined, data);
-          return;
-        }
-      }
-    } else {
-      const nb = bufferParser.skipString();
-      bufferParser.clear();
-      if (nb !== undefined) {
-        sftp._debug && sftp._debug(
-          `SFTP: Inbound: Received DATA (id:${reqID}, ${nb})`
-        );
-        return;
-      }
-    }
-
-    return doFatalSFTPError(sftp, 'Malformed DATA packet');
-  },
-  [RESPONSE.NAME]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    let req;
-    if (reqID !== undefined) {
-      req = sftp._requests[reqID];
-      delete sftp._requests[reqID];
-    }
-    /*
-      uint32     count
-      repeats count times:
-              string     filename
-              string     longname
-              ATTRS      attrs
-    */
-    const count = bufferParser.readUInt32BE();
-    if (count !== undefined) {
-      let names = [];
-      for (let i = 0; i < count; ++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
-        const filename = bufferParser.readString(true);
-
-        // `longname` only exists in SFTPv3 and since it typically will
-        // contain the filename, we assume it is also UTF-8
-        const longname = bufferParser.readString(true);
-
-        const attrs = readAttrs(sftp._biOpt);
-        if (attrs === undefined) {
-          names = undefined;
-          break;
-        }
-        names.push({ filename, longname, attrs });
-      }
-      if (names !== undefined) {
-        sftp._debug && sftp._debug(
-          `SFTP: Inbound: Received NAME (id:${reqID}, ${names.length})`
-        );
-        bufferParser.clear();
-        if (req && typeof req.cb === 'function')
-          req.cb(undefined, names);
-        return;
-      }
-    }
-
-    bufferParser.clear();
-    return doFatalSFTPError(sftp, 'Malformed NAME packet');
-  },
-  [RESPONSE.ATTRS]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    let req;
-    if (reqID !== undefined) {
-      req = sftp._requests[reqID];
-      delete sftp._requests[reqID];
-    }
-    /*
-      ATTRS      attrs
-    */
-    const attrs = readAttrs(sftp._biOpt);
-    bufferParser.clear();
-    if (attrs !== undefined) {
-      sftp._debug && sftp._debug(`SFTP: Inbound: Received ATTRS (id:${reqID})`);
-      if (req && typeof req.cb === 'function')
-        req.cb(undefined, attrs);
-      return;
-    }
-
-    return doFatalSFTPError(sftp, 'Malformed ATTRS packet');
-  },
-  [RESPONSE.EXTENDED]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    if (reqID !== undefined) {
-      const req = sftp._requests[reqID];
-      if (req) {
-        delete sftp._requests[reqID];
-        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
-            */
-            const biOpt = sftp._biOpt;
-            const stats = {
-              f_bsize: bufferParser.readUInt64BE(biOpt),
-              f_frsize: bufferParser.readUInt64BE(biOpt),
-              f_blocks: bufferParser.readUInt64BE(biOpt),
-              f_bfree: bufferParser.readUInt64BE(biOpt),
-              f_bavail: bufferParser.readUInt64BE(biOpt),
-              f_files: bufferParser.readUInt64BE(biOpt),
-              f_ffree: bufferParser.readUInt64BE(biOpt),
-              f_favail: bufferParser.readUInt64BE(biOpt),
-              f_sid: bufferParser.readUInt64BE(biOpt),
-              f_flag: bufferParser.readUInt64BE(biOpt),
-              f_namemax: bufferParser.readUInt64BE(biOpt),
-            };
-            if (stats.f_namemax === undefined)
-              break;
-            if (sftp._debug) {
-              sftp._debug(
-                'SFTP: Inbound: Received EXTENDED_REPLY '
-                  + `(id:${reqID}, ${req.extended})`
-              );
-            }
-            bufferParser.clear();
-            if (typeof req.cb === 'function')
-              req.cb(undefined, stats);
-            return;
-          }
-          case 'limits@openssh.com': {
-            /*
-              uint64          max-packet-length
-              uint64          max-read-length
-              uint64          max-write-length
-              uint64          max-open-handles
-            */
-            const limits = {
-              maxPktLen: bufferParser.readUInt64BE(),
-              maxReadLen: bufferParser.readUInt64BE(),
-              maxWriteLen: bufferParser.readUInt64BE(),
-              maxOpenHandles: bufferParser.readUInt64BE(),
-            };
-            if (limits.maxOpenHandles === undefined)
-              break;
-            if (sftp._debug) {
-              sftp._debug(
-                'SFTP: Inbound: Received EXTENDED_REPLY '
-                  + `(id:${reqID}, ${req.extended})`
-              );
-            }
-            bufferParser.clear();
-            if (typeof req.cb === 'function')
-              req.cb(undefined, limits);
-            return;
-          }
-          case 'users-groups-by-id@openssh.com': {
-            /*
-              string    usernames
-                string    username1
-                ...
-              string    groupnames
-                string    groupname1
-                ...
-            */
-            const usernameCount = bufferParser.readUInt32BE();
-            if (usernameCount === undefined)
-              break;
-            const usernames = new Array(usernameCount);
-            for (let i = 0; i < usernames.length; ++i)
-              usernames[i] = bufferParser.readString(true);
-
-            const groupnameCount = bufferParser.readUInt32BE();
-            if (groupnameCount === undefined)
-              break;
-            const groupnames = new Array(groupnameCount);
-            for (let i = 0; i < groupnames.length; ++i)
-              groupnames[i] = bufferParser.readString(true);
-            if (groupnames.length > 0
-                && groupnames[groupnames.length - 1] === undefined) {
-              break;
-            }
-
-            if (sftp._debug) {
-              sftp._debug(
-                'SFTP: Inbound: Received EXTENDED_REPLY '
-                  + `(id:${reqID}, ${req.extended})`
-              );
-            }
-            bufferParser.clear();
-            if (typeof req.cb === 'function')
-              req.cb(undefined, usernames, groupnames);
-            return;
-          }
-          default:
-            // Unknown extended request
-            sftp._debug && sftp._debug(
-              `SFTP: Inbound: Received EXTENDED_REPLY (id:${reqID}, ???)`
-            );
-            bufferParser.clear();
-            if (typeof req.cb === 'function')
-              req.cb();
-            return;
-        }
-      } else {
-        sftp._debug && sftp._debug(
-          `SFTP: Inbound: Received EXTENDED_REPLY (id:${reqID}, ???)`
-        );
-        bufferParser.clear();
-        return;
-      }
-    }
-
-    bufferParser.clear();
-    return doFatalSFTPError(sftp, 'Malformed EXTENDED_REPLY packet');
-  },
-};
-const SERVER_HANDLERS = {
-  [REQUEST.INIT]: (sftp, payload) => {
-    if (sftp._version !== -1)
-      return doFatalSFTPError(sftp, 'Duplicate INIT packet');
-
-    const extensions = {};
-
-    /*
-      uint32 version
-      <extension data>
-    */
-    bufferParser.init(payload, 1);
-    let version = bufferParser.readUInt32BE();
-    while (bufferParser.avail()) {
-      const extName = bufferParser.readString(true);
-      const extData = bufferParser.readString(true);
-      if (extData === undefined) {
-        version = undefined;
-        break;
-      }
-      extensions[extName] = extData;
-    }
-    bufferParser.clear();
-
-    if (version === undefined)
-      return doFatalSFTPError(sftp, 'Malformed INIT packet');
-
-    if (sftp._debug) {
-      const names = Object.keys(extensions);
-      if (names.length) {
-        sftp._debug(
-          `SFTP: Inbound: Received INIT (v${version}, exts:${names})`
-        );
-      } else {
-        sftp._debug(`SFTP: Inbound: Received INIT (v${version})`);
-      }
-    }
-
-    sendOrBuffer(sftp, SERVER_VERSION_BUFFER);
-
-    sftp._version = version;
-    sftp._extensions = extensions;
-    sftp.emit('ready');
-  },
-  [REQUEST.OPEN]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string        filename
-      uint32        pflags
-      ATTRS         attrs
-    */
-    const filename = bufferParser.readString(true);
-    const pflags = bufferParser.readUInt32BE();
-    const attrs = readAttrs(sftp._biOpt);
-    bufferParser.clear();
-
-    if (attrs === undefined)
-      return doFatalSFTPError(sftp, 'Malformed OPEN packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received OPEN (id:${reqID})`);
-
-    if (!sftp.emit('OPEN', reqID, filename, pflags, attrs)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.CLOSE]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string        handle
-    */
-    const handle = bufferParser.readString();
-    bufferParser.clear();
-
-    if (handle === undefined || handle.length > 256)
-      return doFatalSFTPError(sftp, 'Malformed CLOSE packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received CLOSE (id:${reqID})`);
-
-    if (!sftp.emit('CLOSE', reqID, handle)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.READ]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     handle
-      uint64     offset
-      uint32     len
-    */
-    const handle = bufferParser.readString();
-    const offset = bufferParser.readUInt64BE(sftp._biOpt);
-    const len = bufferParser.readUInt32BE();
-    bufferParser.clear();
-
-    if (len === undefined || handle.length > 256)
-      return doFatalSFTPError(sftp, 'Malformed READ packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received READ (id:${reqID})`);
-
-    if (!sftp.emit('READ', reqID, handle, offset, len)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.WRITE]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     handle
-      uint64     offset
-      string     data
-    */
-    const handle = bufferParser.readString();
-    const offset = bufferParser.readUInt64BE(sftp._biOpt);
-    const data = bufferParser.readString();
-    bufferParser.clear();
-
-    if (data === undefined || handle.length > 256)
-      return doFatalSFTPError(sftp, 'Malformed WRITE packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received WRITE (id:${reqID})`);
-
-    if (!sftp.emit('WRITE', reqID, handle, offset, data)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.LSTAT]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     path
-    */
-    const path = bufferParser.readString(true);
-    bufferParser.clear();
-
-    if (path === undefined)
-      return doFatalSFTPError(sftp, 'Malformed LSTAT packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received LSTAT (id:${reqID})`);
-
-    if (!sftp.emit('LSTAT', reqID, path)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.FSTAT]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string        handle
-    */
-    const handle = bufferParser.readString();
-    bufferParser.clear();
-
-    if (handle === undefined || handle.length > 256)
-      return doFatalSFTPError(sftp, 'Malformed FSTAT packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received FSTAT (id:${reqID})`);
-
-    if (!sftp.emit('FSTAT', reqID, handle)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.SETSTAT]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     path
-      ATTRS      attrs
-    */
-    const path = bufferParser.readString(true);
-    const attrs = readAttrs(sftp._biOpt);
-    bufferParser.clear();
-
-    if (attrs === undefined)
-      return doFatalSFTPError(sftp, 'Malformed SETSTAT packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received SETSTAT (id:${reqID})`);
-
-    if (!sftp.emit('SETSTAT', reqID, path, attrs)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.FSETSTAT]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     handle
-      ATTRS      attrs
-    */
-    const handle = bufferParser.readString();
-    const attrs = readAttrs(sftp._biOpt);
-    bufferParser.clear();
-
-    if (attrs === undefined || handle.length > 256)
-      return doFatalSFTPError(sftp, 'Malformed FSETSTAT packet');
-
-    sftp._debug && sftp._debug(
-      `SFTP: Inbound: Received FSETSTAT (id:${reqID})`
-    );
-
-    if (!sftp.emit('FSETSTAT', reqID, handle, attrs)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.OPENDIR]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     path
-    */
-    const path = bufferParser.readString(true);
-    bufferParser.clear();
-
-    if (path === undefined)
-      return doFatalSFTPError(sftp, 'Malformed OPENDIR packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received OPENDIR (id:${reqID})`);
-
-    if (!sftp.emit('OPENDIR', reqID, path)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.READDIR]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string        handle
-    */
-    const handle = bufferParser.readString();
-    bufferParser.clear();
-
-    if (handle === undefined || handle.length > 256)
-      return doFatalSFTPError(sftp, 'Malformed READDIR packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received READDIR (id:${reqID})`);
-
-    if (!sftp.emit('READDIR', reqID, handle)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.REMOVE]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     path
-    */
-    const path = bufferParser.readString(true);
-    bufferParser.clear();
-
-    if (path === undefined)
-      return doFatalSFTPError(sftp, 'Malformed REMOVE packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received REMOVE (id:${reqID})`);
-
-    if (!sftp.emit('REMOVE', reqID, path)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.MKDIR]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     path
-      ATTRS      attrs
-    */
-    const path = bufferParser.readString(true);
-    const attrs = readAttrs(sftp._biOpt);
-    bufferParser.clear();
-
-    if (attrs === undefined)
-      return doFatalSFTPError(sftp, 'Malformed MKDIR packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received MKDIR (id:${reqID})`);
-
-    if (!sftp.emit('MKDIR', reqID, path, attrs)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.RMDIR]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     path
-    */
-    const path = bufferParser.readString(true);
-    bufferParser.clear();
-
-    if (path === undefined)
-      return doFatalSFTPError(sftp, 'Malformed RMDIR packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received RMDIR (id:${reqID})`);
-
-    if (!sftp.emit('RMDIR', reqID, path)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.REALPATH]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     path
-    */
-    const path = bufferParser.readString(true);
-    bufferParser.clear();
-
-    if (path === undefined)
-      return doFatalSFTPError(sftp, 'Malformed REALPATH packet');
-
-    sftp._debug && sftp._debug(
-      `SFTP: Inbound: Received REALPATH (id:${reqID})`
-    );
-
-    if (!sftp.emit('REALPATH', reqID, path)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.STAT]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     path
-    */
-    const path = bufferParser.readString(true);
-    bufferParser.clear();
-
-    if (path === undefined)
-      return doFatalSFTPError(sftp, 'Malformed STAT packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received STAT (id:${reqID})`);
-
-    if (!sftp.emit('STAT', reqID, path)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.RENAME]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     oldpath
-      string     newpath
-    */
-    const oldPath = bufferParser.readString(true);
-    const newPath = bufferParser.readString(true);
-    bufferParser.clear();
-
-    if (newPath === undefined)
-      return doFatalSFTPError(sftp, 'Malformed RENAME packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received RENAME (id:${reqID})`);
-
-    if (!sftp.emit('RENAME', reqID, oldPath, newPath)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.READLINK]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     path
-    */
-    const path = bufferParser.readString(true);
-    bufferParser.clear();
-
-    if (path === undefined)
-      return doFatalSFTPError(sftp, 'Malformed READLINK packet');
-
-    sftp._debug && sftp._debug(
-      `SFTP: Inbound: Received READLINK (id:${reqID})`
-    );
-
-    if (!sftp.emit('READLINK', reqID, path)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.SYMLINK]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     linkpath
-      string     targetpath
-    */
-    const linkPath = bufferParser.readString(true);
-    const targetPath = bufferParser.readString(true);
-    bufferParser.clear();
-
-    if (targetPath === undefined)
-      return doFatalSFTPError(sftp, 'Malformed SYMLINK packet');
-
-    sftp._debug && sftp._debug(`SFTP: Inbound: Received SYMLINK (id:${reqID})`);
-
-    let handled;
-    if (sftp._isOpenSSH) {
-      // OpenSSH has linkpath and targetpath positions switched
-      handled = sftp.emit('SYMLINK', reqID, targetPath, linkPath);
-    } else {
-      handled = sftp.emit('SYMLINK', reqID, linkPath, targetPath);
-    }
-    if (!handled) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-  [REQUEST.EXTENDED]: (sftp, payload) => {
-    bufferParser.init(payload, 1);
-    const reqID = bufferParser.readUInt32BE();
-    /*
-      string     extended-request
-      ... any request-specific data ...
-    */
-    const extName = bufferParser.readString(true);
-    if (extName === undefined) {
-      bufferParser.clear();
-      return doFatalSFTPError(sftp, 'Malformed EXTENDED packet');
-    }
-
-    let extData;
-    if (bufferParser.avail())
-      extData = bufferParser.readRaw();
-    bufferParser.clear();
-
-    sftp._debug && sftp._debug(
-      `SFTP: Inbound: Received EXTENDED (id:${reqID})`
-    );
-
-    if (!sftp.emit('EXTENDED', reqID, extName, extData)) {
-      // Automatically reject request if no handler for request type
-      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
-    }
-  },
-};
-
-// =============================================================================
-// ReadStream/WriteStream-related ==============================================
-// =============================================================================
-const {
-  ERR_INVALID_ARG_TYPE,
-  ERR_OUT_OF_RANGE,
-  validateNumber
-} = require('./node-fs-compat');
-
-const kMinPoolSpace = 128;
-
-let pool;
-// It can happen that we expect to read a large chunk of data, and reserve
-// a large chunk of the pool accordingly, but the read() call only filled
-// a portion of it. If a concurrently executing read() then uses the same pool,
-// the "reserved" portion cannot be used, so we allow it to be re-used as a
-// new pool later.
-const poolFragments = [];
-
-function allocNewPool(poolSize) {
-  if (poolFragments.length > 0)
-    pool = poolFragments.pop();
-  else
-    pool = Buffer.allocUnsafe(poolSize);
-  pool.used = 0;
-}
-
-// Check the `this.start` and `this.end` of stream.
-function checkPosition(pos, name) {
-  if (!Number.isSafeInteger(pos)) {
-    validateNumber(pos, name);
-    if (!Number.isInteger(pos))
-      throw new ERR_OUT_OF_RANGE(name, 'an integer', pos);
-    throw new ERR_OUT_OF_RANGE(name, '>= 0 and <= 2 ** 53 - 1', pos);
-  }
-  if (pos < 0)
-    throw new ERR_OUT_OF_RANGE(name, '>= 0 and <= 2 ** 53 - 1', pos);
-}
-
-function roundUpToMultipleOf8(n) {
-  return (n + 7) & ~7;  // Align to 8 byte boundary.
-}
-
-function ReadStream(sftp, path, options) {
-  if (options === undefined)
-    options = {};
-  else if (typeof options === 'string')
-    options = { encoding: options };
-  else if (options === null || typeof options !== 'object')
-    throw new TypeError('"options" argument must be a string or an object');
-  else
-    options = Object.create(options);
-
-  // A little bit bigger buffer and water marks by default
-  if (options.highWaterMark === undefined)
-    options.highWaterMark = 64 * 1024;
-
-  // For backwards compat do not emit close on destroy.
-  options.emitClose = false;
-  options.autoDestroy = false; // Node 14 major change.
-
-  ReadableStream.call(this, options);
-
-  this.path = path;
-  this.flags = options.flags === undefined ? 'r' : options.flags;
-  this.mode = options.mode === undefined ? 0o666 : options.mode;
-
-  this.start = options.start;
-  this.end = options.end;
-  this.autoClose = options.autoClose === undefined ? true : options.autoClose;
-  this.pos = 0;
-  this.bytesRead = 0;
-  this.isClosed = false;
-
-  this.handle = options.handle === undefined ? null : options.handle;
-  this.sftp = sftp;
-  this._opening = false;
-
-  if (this.start !== undefined) {
-    checkPosition(this.start, 'start');
-
-    this.pos = this.start;
-  }
-
-  if (this.end === undefined) {
-    this.end = Infinity;
-  } else if (this.end !== Infinity) {
-    checkPosition(this.end, 'end');
-
-    if (this.start !== undefined && this.start > this.end) {
-      throw new ERR_OUT_OF_RANGE(
-        'start',
-        `<= "end" (here: ${this.end})`,
-        this.start
-      );
-    }
-  }
-
-  this.on('end', function() {
-    if (this.autoClose)
-      this.destroy();
-  });
-
-  if (!Buffer.isBuffer(this.handle))
-    this.open();
-}
-inherits(ReadStream, ReadableStream);
-
-ReadStream.prototype.open = function() {
-  if (this._opening)
-    return;
-
-  this._opening = true;
-
-  this.sftp.open(this.path, this.flags, this.mode, (er, handle) => {
-    this._opening = false;
-
-    if (er) {
-      this.emit('error', er);
-      if (this.autoClose)
-        this.destroy();
-      return;
-    }
-
-    this.handle = handle;
-    this.emit('open', handle);
-    this.emit('ready');
-    // Start the flow of data.
-    this.read();
-  });
-};
-
-ReadStream.prototype._read = function(n) {
-  if (!Buffer.isBuffer(this.handle))
-    return this.once('open', () => this._read(n));
-
-  // XXX: safe to remove this?
-  if (this.destroyed)
-    return;
-
-  if (!pool || pool.length - pool.used < kMinPoolSpace) {
-    // Discard the old pool.
-    allocNewPool(this.readableHighWaterMark
-                 || this._readableState.highWaterMark);
-  }
-
-  // Grab another reference to the pool in the case that while we're
-  // in the thread pool another read() finishes up the pool, and
-  // allocates a new one.
-  const thisPool = pool;
-  let toRead = Math.min(pool.length - pool.used, n);
-  const start = pool.used;
-
-  if (this.end !== undefined)
-    toRead = Math.min(this.end - this.pos + 1, toRead);
-
-  // Already read everything we were supposed to read!
-  // treat as EOF.
-  if (toRead <= 0)
-    return this.push(null);
-
-  // the actual read.
-  this.sftp.read(this.handle,
-                 pool,
-                 pool.used,
-                 toRead,
-                 this.pos,
-                 (er, bytesRead) => {
-    if (er) {
-      this.emit('error', er);
-      if (this.autoClose)
-        this.destroy();
-      return;
-    }
-    let b = null;
-
-    // Now that we know how much data we have actually read, re-wind the
-    // 'used' field if we can, and otherwise allow the remainder of our
-    // reservation to be used as a new pool later.
-    if (start + toRead === thisPool.used && thisPool === pool) {
-      thisPool.used = roundUpToMultipleOf8(thisPool.used + bytesRead - toRead);
-    } else {
-      // Round down to the next lowest multiple of 8 to ensure the new pool
-      // fragment start and end positions are aligned to an 8 byte boundary.
-      const alignedEnd = (start + toRead) & ~7;
-      const alignedStart = roundUpToMultipleOf8(start + bytesRead);
-      if (alignedEnd - alignedStart >= kMinPoolSpace)
-        poolFragments.push(thisPool.slice(alignedStart, alignedEnd));
-    }
-
-    if (bytesRead > 0) {
-      this.bytesRead += bytesRead;
-      b = thisPool.slice(start, start + bytesRead);
-    }
-
-    // Move the pool positions, and internal position for reading.
-    this.pos += bytesRead;
-
-    this.push(b);
-  });
-
-  pool.used = roundUpToMultipleOf8(pool.used + toRead);
-};
-
-ReadStream.prototype._destroy = function(err, cb) {
-  if (this._opening && !Buffer.isBuffer(this.handle)) {
-    this.once('open', closeStream.bind(null, this, cb, err));
-    return;
-  }
-
-  closeStream(this, cb, err);
-  this.handle = null;
-  this._opening = false;
-};
-
-function closeStream(stream, cb, err) {
-  if (!stream.handle)
-    return onclose();
-
-  stream.sftp.close(stream.handle, onclose);
-
-  function onclose(er) {
-    er = er || err;
-    cb(er);
-    stream.isClosed = true;
-    if (!er)
-      stream.emit('close');
-  }
-}
-
-ReadStream.prototype.close = function(cb) {
-  this.destroy(null, cb);
-};
-
-Object.defineProperty(ReadStream.prototype, 'pending', {
-  get() {
-    return this.handle === null;
-  },
-  configurable: true
-});
-
-// TODO: add `concurrency` setting to allow more than one in-flight WRITE
-// request to server to improve throughput
-function WriteStream(sftp, path, options) {
-  if (options === undefined)
-    options = {};
-  else if (typeof options === 'string')
-    options = { encoding: options };
-  else if (options === null || typeof options !== 'object')
-    throw new TypeError('"options" argument must be a string or an object');
-  else
-    options = Object.create(options);
-
-  // For backwards compat do not emit close on destroy.
-  options.emitClose = false;
-  options.autoDestroy = false; // Node 14 major change.
-
-  WritableStream.call(this, options);
-
-  this.path = path;
-  this.flags = options.flags === undefined ? 'w' : options.flags;
-  this.mode = options.mode === undefined ? 0o666 : options.mode;
-
-  this.start = options.start;
-  this.autoClose = options.autoClose === undefined ? true : options.autoClose;
-  this.pos = 0;
-  this.bytesWritten = 0;
-  this.isClosed = false;
-
-  this.handle = options.handle === undefined ? null : options.handle;
-  this.sftp = sftp;
-  this._opening = false;
-
-  if (this.start !== undefined) {
-    checkPosition(this.start, 'start');
-
-    this.pos = this.start;
-  }
-
-  if (options.encoding)
-    this.setDefaultEncoding(options.encoding);
-
-  // Node v6.x only
-  this.on('finish', function() {
-    if (this._writableState.finalCalled)
-      return;
-    if (this.autoClose)
-      this.destroy();
-  });
-
-  if (!Buffer.isBuffer(this.handle))
-    this.open();
-}
-inherits(WriteStream, WritableStream);
-
-WriteStream.prototype._final = function(cb) {
-  if (this.autoClose)
-    this.destroy();
-  cb();
-};
-
-WriteStream.prototype.open = function() {
-  if (this._opening)
-    return;
-
-  this._opening = true;
-
-  this.sftp.open(this.path, this.flags, this.mode, (er, handle) => {
-    this._opening = false;
-
-    if (er) {
-      this.emit('error', er);
-      if (this.autoClose)
-        this.destroy();
-      return;
-    }
-
-    this.handle = handle;
-
-    const tryAgain = (err) => {
-      if (err) {
-        // Try chmod() for sftp servers that may not support fchmod() for
-        // whatever reason
-        this.sftp.chmod(this.path, this.mode, (err_) => tryAgain());
-        return;
-      }
-
-      // SFTPv3 requires absolute offsets, no matter the open flag used
-      if (this.flags[0] === 'a') {
-        const tryStat = (err, st) => {
-          if (err) {
-            // Try stat() for sftp servers that may not support fstat() for
-            // whatever reason
-            this.sftp.stat(this.path, (err_, st_) => {
-              if (err_) {
-                this.destroy();
-                this.emit('error', err);
-                return;
-              }
-              tryStat(null, st_);
-            });
-            return;
-          }
-
-          this.pos = st.size;
-          this.emit('open', handle);
-          this.emit('ready');
-        };
-
-        this.sftp.fstat(handle, tryStat);
-        return;
-      }
-
-      this.emit('open', handle);
-      this.emit('ready');
-    };
-
-    this.sftp.fchmod(handle, this.mode, tryAgain);
-  });
-};
-
-WriteStream.prototype._write = function(data, encoding, cb) {
-  if (!Buffer.isBuffer(data)) {
-    const err = new ERR_INVALID_ARG_TYPE('data', 'Buffer', data);
-    return this.emit('error', err);
-  }
-
-  if (!Buffer.isBuffer(this.handle)) {
-    return this.once('open', function() {
-      this._write(data, encoding, cb);
-    });
-  }
-
-  this.sftp.write(this.handle,
-                  data,
-                  0,
-                  data.length,
-                  this.pos,
-                  (er, bytes) => {
-    if (er) {
-      if (this.autoClose)
-        this.destroy();
-      return cb(er);
-    }
-    this.bytesWritten += bytes;
-    cb();
-  });
-
-  this.pos += data.length;
-};
-
-WriteStream.prototype._writev = function(data, cb) {
-  if (!Buffer.isBuffer(this.handle)) {
-    return this.once('open', function() {
-      this._writev(data, cb);
-    });
-  }
-
-  const sftp = this.sftp;
-  const handle = this.handle;
-  let writesLeft = data.length;
-
-  const onwrite = (er, bytes) => {
-    if (er) {
-      this.destroy();
-      return cb(er);
-    }
-    this.bytesWritten += bytes;
-    if (--writesLeft === 0)
-      cb();
-  };
-
-  // TODO: try to combine chunks to reduce number of requests to the server?
-  for (let i = 0; i < data.length; ++i) {
-    const chunk = data[i].chunk;
-
-    sftp.write(handle, chunk, 0, chunk.length, this.pos, onwrite);
-    this.pos += chunk.length;
-  }
-};
-
-if (typeof WritableStream.prototype.destroy !== 'function')
-  WriteStream.prototype.destroy = ReadStream.prototype.destroy;
-
-WriteStream.prototype._destroy = ReadStream.prototype._destroy;
-WriteStream.prototype.close = function(cb) {
-  if (cb) {
-    if (this.isClosed) {
-      process.nextTick(cb);
-      return;
-    }
-    this.on('close', cb);
-  }
-
-  // If we are not autoClosing, we should call
-  // destroy on 'finish'.
-  if (!this.autoClose)
-    this.on('finish', this.destroy.bind(this));
-
-  this.end();
-};
-
-// There is no shutdown() for files.
-WriteStream.prototype.destroySoon = WriteStream.prototype.end;
-
-Object.defineProperty(WriteStream.prototype, 'pending', {
-  get() {
-    return this.handle === null;
-  },
-  configurable: true
-});
-// =============================================================================
-
-module.exports = {
-  flagsToString,
-  OPEN_MODE,
-  SFTP,
-  Stats,
-  STATUS_CODE,
-  stringToFlags,
-};