@tachybase/module-multi-app 0.23.8

package/dist/node_modules/mariadb/lib/cmd/handshake/handshake.js

@@ -0,0 +1,292 @@
+'use strict';
+
+const Command = require('../command');
+const InitialHandshake = require('./initial-handshake');
+const ClientHandshakeResponse = require('./client-handshake-response');
+const SslRequest = require('./ssl-request');
+const ClientCapabilities = require('./client-capabilities');
+const Errors = require('../../misc/errors');
+const Capabilities = require('../../const/capabilities');
+const process = require('process');
+
+/**
+ * Handle handshake.
+ * see https://mariadb.com/kb/en/library/1-connecting-connecting/
+ */
+class Handshake extends Command {
+  constructor(resolve, reject, _createSecureContext, _addCommand, getSocket) {
+    super(resolve, reject);
+    this._createSecureContext = _createSecureContext;
+    this._addCommand = _addCommand;
+    this.getSocket = getSocket;
+    this.onPacketReceive = this.parseHandshakeInit;
+    this.plugin = this;
+  }
+
+  ensureOptionCompatibility(opts, info) {
+    if (
+      opts.multipleStatements &&
+      (info.serverCapabilities & Capabilities.MULTI_STATEMENTS) === 0
+    ) {
+      return this.throwNewError(
+        "Option `multipleStatements` enable, but server doesn'permits multi-statment",
+        true,
+        info,
+        '08S01',
+        Errors.ER_CLIENT_OPTION_INCOMPATIBILITY
+      );
+    }
+
+    if (opts.permitLocalInfile && (info.serverCapabilities & Capabilities.LOCAL_FILES) === 0) {
+      return this.throwNewError(
+        "Option `permitLocalInfile` enable, but server doesn'permits using local file",
+        true,
+        info,
+        '08S01',
+        Errors.ER_CLIENT_OPTION_INCOMPATIBILITY
+      );
+    }
+  }
+
+  parseHandshakeInit(packet, out, opts, info) {
+    if (packet.peek() === 0xff) {
+      //in case that some host is not permit to connect server
+      const authErr = packet.readError(info);
+      authErr.fatal = true;
+      return this.throwError(authErr, info);
+    }
+
+    let handshake = new InitialHandshake(packet, info);
+    this.ensureOptionCompatibility(opts, info);
+    ClientCapabilities.init(opts, info);
+
+    if (opts.ssl) {
+      if (info.serverCapabilities & Capabilities.SSL) {
+        info.clientCapabilities |= Capabilities.SSL;
+        SslRequest.send(this, out, info, opts);
+        this._createSecureContext(
+          function () {
+            ClientHandshakeResponse.send(this, out, opts, handshake.pluginName, info);
+          }.bind(this)
+        );
+      } else {
+        return this.throwNewError(
+          'Trying to connect with ssl, but ssl not enabled in the server',
+          true,
+          info,
+          '08S01',
+          Errors.ER_SERVER_SSL_DISABLED
+        );
+      }
+    } else {
+      ClientHandshakeResponse.send(this, out, opts, handshake.pluginName, info);
+    }
+    this.onPacketReceive = this.handshakeResult;
+  }
+
+  /**
+   * Fast-path handshake results :
+   *  - if plugin was the one expected by server, server will send OK_Packet / ERR_Packet.
+   *  - if not, server send an AuthSwitchRequest packet, indicating the specific PLUGIN to use with this user.
+   *    dispatching to plugin handler then.
+   *
+   * @param packet    current packet
+   * @param out       output buffer
+   * @param opts      options
+   * @param info      connection info
+   * @returns {*}     return null if authentication succeed, depending on plugin conversation if not finished
+   */
+  handshakeResult(packet, out, opts, info) {
+    const marker = packet.peek();
+    switch (marker) {
+      //*********************************************************************************************************
+      //* AuthSwitchRequest packet
+      //*********************************************************************************************************
+      case 0xfe:
+        this.plugin.onPacketReceive = null;
+        this.plugin.emit('send_end');
+        this.plugin.emit('end');
+        this.dispatchAuthSwitchRequest(packet, out, opts, info);
+        return;
+
+      //*********************************************************************************************************
+      //* OK_Packet - authentication succeeded
+      //*********************************************************************************************************
+      case 0x00:
+        this.plugin.onPacketReceive = null;
+        packet.skip(1); //skip header
+        packet.skipLengthCodedNumber(); //skip affected rows
+        packet.skipLengthCodedNumber(); //skip last insert id
+        info.status = packet.readUInt16();
+        this.plugin.emit('send_end');
+        return this.plugin.successEnd();
+
+      //*********************************************************************************************************
+      //* ERR_Packet
+      //*********************************************************************************************************
+      case 0xff:
+        this.plugin.onPacketReceive = null;
+        const authErr = packet.readError(info, this.displaySql());
+        authErr.fatal = true;
+        return this.plugin.throwError(authErr, info);
+
+      //*********************************************************************************************************
+      //* unexpected
+      //*********************************************************************************************************
+      default:
+        this.throwNewError(
+          'Unexpected type of packet during handshake phase : ' + marker,
+          true,
+          info,
+          '42000',
+          Errors.ER_AUTHENTICATION_BAD_PACKET
+        );
+    }
+  }
+
+  /**
+   * Handle authentication switch request : dispatch to plugin handler.
+   *
+   * @param packet  packet
+   * @param out     output writer
+   * @param opts    options
+   * @param info    connection information
+   */
+  dispatchAuthSwitchRequest(packet, out, opts, info) {
+    let pluginName, pluginData;
+    if (info.clientCapabilities & Capabilities.PLUGIN_AUTH) {
+      packet.skip(1); //header
+      if (packet.remaining()) {
+        //AuthSwitchRequest packet.
+        pluginName = packet.readStringNullEnded();
+        pluginData = packet.readBufferRemaining();
+      } else {
+        //OldAuthSwitchRequest
+        pluginName = 'mysql_old_password';
+        pluginData = info.seed.slice(0, 8);
+      }
+    } else {
+      pluginName = packet.readStringNullEnded('cesu8');
+      pluginData = packet.readBufferRemaining();
+    }
+
+    try {
+      this.plugin = Handshake.pluginHandler(
+        pluginName,
+        this.plugin.sequenceNo,
+        this.plugin.compressSequenceNo,
+        pluginData,
+        info,
+        opts,
+        out,
+        this.resolve,
+        this.reject,
+        this.handshakeResult.bind(this)
+      );
+    } catch (err) {
+      this.reject(err);
+      return;
+    }
+
+    if (!this.plugin) {
+      this.reject(
+        Errors.createError(
+          "Client does not support authentication protocol '" +
+            pluginName +
+            "' requested by server. ",
+          null,
+          true,
+          info,
+          '08004',
+          Errors.ER_AUTHENTICATION_PLUGIN_NOT_SUPPORTED
+        )
+      );
+    } else {
+      this._addCommand(this.plugin, false);
+    }
+  }
+
+  static pluginHandler(
+    pluginName,
+    packSeq,
+    compressPackSeq,
+    pluginData,
+    info,
+    opts,
+    out,
+    authResolve,
+    authReject,
+    multiAuthResolver
+  ) {
+    let pluginAuth;
+    switch (pluginName) {
+      case 'mysql_native_password':
+        pluginAuth = require('./auth/native-password-auth.js');
+        break;
+
+      case 'mysql_clear_password':
+        pluginAuth = require('./auth/clear-password-auth.js');
+        break;
+
+      case 'client_ed25519':
+        pluginAuth = require('./auth/ed25519-password-auth.js');
+        break;
+
+      case 'dialog':
+        pluginAuth = require('./auth/pam-password-auth.js');
+        break;
+
+      case 'sha256_password':
+        if (!Handshake.ensureNodeVersion(11, 6, 0)) {
+          throw Errors.createError(
+            'sha256_password authentication plugin require node 11.6+',
+            null,
+            true,
+            info,
+            '08004',
+            Errors.ER_MINIMUM_NODE_VERSION_REQUIRED
+          );
+        }
+        pluginAuth = require('./auth/sha256-password-auth.js');
+        break;
+
+      case 'caching_sha2_password':
+        if (!Handshake.ensureNodeVersion(11, 6, 0)) {
+          throw Errors.createError(
+            'caching_sha2_password authentication plugin require node 11.6+',
+            null,
+            true,
+            info,
+            '08004',
+            Errors.ER_MINIMUM_NODE_VERSION_REQUIRED
+          );
+        }
+        pluginAuth = require('./auth/caching-sha2-password-auth.js');
+        break;
+
+      //TODO "auth_gssapi_client"
+
+      default:
+        return null;
+    }
+    return new pluginAuth(
+      packSeq,
+      compressPackSeq,
+      pluginData,
+      authResolve,
+      authReject,
+      multiAuthResolver
+    );
+  }
+
+  static ensureNodeVersion(major, minor, patch) {
+    const ver = process.versions.node.split('.');
+    return (
+      ver[0] > major ||
+      (ver[0] === major && ver[1] > minor) ||
+      (ver[0] === major && ver[1] === minor && ver[2] >= patch)
+    );
+  }
+}
+
+module.exports = Handshake;

package/dist/node_modules/mariadb/lib/cmd/handshake/initial-handshake.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const Capabilities = require('../../const/capabilities');
+const ConnectionInformation = require('../../misc/connection-information');
+
+/**
+ * Parser server initial handshake.
+ * see https://mariadb.com/kb/en/library/1-connecting-connecting/#initial-handshake-packet
+ */
+class InitialHandshake {
+  constructor(packet, info) {
+    //protocolVersion
+    packet.skip(1);
+    info.serverVersion = {};
+    info.serverVersion.raw = packet.readStringNullEnded();
+    info.threadId = packet.readUInt32();
+
+    let seed1 = packet.readBuffer(8);
+    packet.skip(1); //reserved byte
+
+    let serverCapabilities = BigInt(packet.readUInt16());
+    //skip characterSet
+    packet.skip(1);
+    info.status = packet.readUInt16();
+    serverCapabilities += BigInt(packet.readUInt16()) << BigInt(16);
+
+    let saltLength = 0;
+    if (serverCapabilities & Capabilities.PLUGIN_AUTH) {
+      saltLength = Math.max(12, packet.readUInt8() - 9);
+    } else {
+      packet.skip(1);
+    }
+    if (serverCapabilities & Capabilities.MYSQL) {
+      packet.skip(10);
+    } else {
+      packet.skip(6);
+      serverCapabilities += BigInt(packet.readUInt32()) << BigInt(32);
+    }
+
+    if (serverCapabilities & Capabilities.SECURE_CONNECTION) {
+      let seed2 = packet.readBuffer(saltLength);
+      info.seed = Buffer.concat([seed1, seed2]);
+    } else {
+      info.seed = seed1;
+    }
+    packet.skip(1);
+    info.serverCapabilities = serverCapabilities;
+
+    /**
+     * check for MariaDB 10.x replication hack , remove fake prefix if needed
+     * MDEV-4088: in 10.0+, the real version string maybe prefixed with "5.5.5-",
+     * to workaround bugs in Oracle MySQL replication
+     **/
+
+    if (info.serverVersion.raw.startsWith('5.5.5-')) {
+      info.serverVersion.mariaDb = true;
+      info.serverVersion.raw = info.serverVersion.raw.substring('5.5.5-'.length);
+    } else {
+      //Support for MDEV-7780 faking server version
+      info.serverVersion.mariaDb =
+        info.serverVersion.raw.includes('MariaDB') ||
+        (serverCapabilities & Capabilities.MYSQL) === BigInt(0);
+    }
+
+    if (serverCapabilities & Capabilities.PLUGIN_AUTH) {
+      this.pluginName = packet.readStringNullEnded();
+    } else {
+      this.pluginName = '';
+    }
+    ConnectionInformation.parseVersionString(info);
+  }
+}
+
+module.exports = InitialHandshake;

package/dist/node_modules/mariadb/lib/cmd/handshake/ssl-request.js

@@ -0,0 +1,29 @@
+'use strict';
+const Capabilities = require('../../const/capabilities');
+
+/**
+ * Send SSL Request packet.
+ * see : https://mariadb.com/kb/en/library/1-connecting-connecting/#sslrequest-packet
+ *
+ * @param cmd     current command
+ * @param out     output writer
+ * @param info    client information
+ * @param opts    connection options
+ */
+module.exports.send = function sendSSLRequest(cmd, out, info, opts) {
+  out.startPacket(cmd);
+  out.writeInt32(Number(info.clientCapabilities & BigInt(0xffffffff)));
+  out.writeInt32(1024 * 1024 * 1024); // max packet size
+  out.writeInt8(opts.collation.index);
+  for (let i = 0; i < 19; i++) {
+    out.writeInt8(0);
+  }
+
+  if (info.serverCapabilities & Capabilities.MYSQL) {
+    out.writeInt32(0);
+  } else {
+    out.writeInt32(Number(info.clientCapabilities >> BigInt(32)));
+  }
+
+  out.flushBuffer(true);
+};

package/dist/node_modules/mariadb/lib/cmd/ping.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const Command = require('./command');
+const Errors = require('../misc/errors');
+
+/**
+ * send a COM_PING: permits sending a packet containing one byte to check that the connection is active.
+ * see https://mariadb.com/kb/en/library/com_ping/
+ */
+class Ping extends Command {
+  constructor(resolve, reject) {
+    super(resolve, reject);
+  }
+
+  start(out, opts, info) {
+    out.startPacket(this);
+    out.writeInt8(0x0e);
+    out.flushBuffer(true);
+    this.emit('send_end');
+    this.onPacketReceive = this.readPingResponsePacket;
+  }
+
+  /**
+   * Read ping response packet.
+   * packet can be :
+   * - an ERR_Packet
+   * - a OK_Packet
+   *
+   * @param packet  query response
+   * @param out     output writer
+   * @param opts    connection options
+   * @param info    connection info
+   */
+  readPingResponsePacket(packet, out, opts, info) {
+    if (packet.peek() !== 0x00) {
+      return this.throwNewError(
+        'unexpected packet',
+        false,
+        info,
+        '42000',
+        Errors.ER_PING_BAD_PACKET
+      );
+    }
+    packet.skip(1); //skip header
+    packet.skipLengthCodedNumber(); //affected rows
+    packet.skipLengthCodedNumber(); //insert ids
+    info.status = packet.readUInt16();
+    this.successEnd(null);
+  }
+}
+
+module.exports = Ping;

package/dist/node_modules/mariadb/lib/cmd/query.js

@@ -0,0 +1,255 @@
+'use strict';
+
+const CommonText = require('./common-text-cmd');
+const Errors = require('../misc/errors');
+const Parse = require('../misc/parse');
+const QUOTE = 0x27;
+
+/**
+ * Protocol COM_QUERY
+ * see : https://mariadb.com/kb/en/library/com_query/
+ */
+class Query extends CommonText {
+  constructor(resolve, reject, options, connOpts, sql, values) {
+    super(resolve, reject, options, connOpts, sql, values);
+  }
+
+  /**
+   * Send COM_QUERY
+   *
+   * @param out   output writer
+   * @param opts  connection options
+   * @param info  connection information
+   */
+  start(out, opts, info) {
+    if (this.initialValues === undefined) {
+      //shortcut if no parameters
+      out.startPacket(this);
+      out.writeInt8(0x03);
+      if (!this.handleTimeout(out, info)) return;
+      out.writeString(this.sql);
+      out.flushBuffer(true);
+      this.emit('send_end');
+      return (this.onPacketReceive = this.readResponsePacket);
+    }
+
+    if (this.opts.namedPlaceholders) {
+      try {
+        const parsed = Parse.splitQueryPlaceholder(
+          this.sql,
+          info,
+          this.initialValues,
+          this.displaySql.bind(this)
+        );
+        this.queryParts = parsed.parts;
+        this.values = parsed.values;
+      } catch (err) {
+        this.emit('send_end');
+        return this.throwError(err, info);
+      }
+    } else {
+      this.queryParts = Parse.splitQuery(this.sql);
+      this.values = Array.isArray(this.initialValues) ? this.initialValues : [this.initialValues];
+      if (!this.validateParameters(info)) return;
+    }
+
+    out.startPacket(this);
+    out.writeInt8(0x03);
+    if (!this.handleTimeout(out, info)) return;
+    out.writeString(this.queryParts[0]);
+    this.onPacketReceive = this.readResponsePacket;
+
+    //********************************************
+    // send params
+    //********************************************
+    const len = this.queryParts.length;
+    for (let i = 1; i < len; i++) {
+      const value = this.values[i - 1];
+
+      if (
+        value !== null &&
+        typeof value === 'object' &&
+        typeof value.pipe === 'function' &&
+        typeof value.read === 'function'
+      ) {
+        this.sending = true;
+        //********************************************
+        // param is stream,
+        // now all params will be written by event
+        //********************************************
+        this.registerStreamSendEvent(out, info);
+        this.currentParam = i;
+        out.writeInt8(QUOTE); //'
+
+        value.on('data', function (chunk) {
+          out.writeBufferEscape(chunk);
+        });
+
+        value.on(
+          'end',
+          function () {
+            out.writeInt8(QUOTE); //'
+            out.writeString(this.queryParts[this.currentParam++]);
+            this.paramWritten();
+          }.bind(this)
+        );
+
+        return;
+      } else {
+        //********************************************
+        // param isn't stream. directly write in buffer
+        //********************************************
+        this.writeParam(out, value, this.opts, info);
+        out.writeString(this.queryParts[i]);
+      }
+    }
+    out.flushBuffer(true);
+    this.emit('send_end');
+  }
+
+  /**
+   * If timeout is set, prepend query with SET STATEMENT max_statement_time=xx FOR, or throw an error
+   * @param out buffer
+   * @param info server information
+   * @returns {boolean} false if an error has been thrown
+   */
+  handleTimeout(out, info) {
+    if (this.opts.timeout) {
+      if (info.isMariaDB()) {
+        if (info.hasMinVersion(10, 1, 2)) {
+          out.writeString('SET STATEMENT max_statement_time=' + this.opts.timeout / 1000 + ' FOR ');
+          return true;
+        } else {
+          const err = Errors.createError(
+            'Cannot use timeout for MariaDB server before 10.1.2. timeout value: ' +
+              this.opts.timeout,
+            this.sql,
+            false,
+            info,
+            'HY000',
+            Errors.ER_TIMEOUT_NOT_SUPPORTED
+          );
+          this.emit('send_end');
+          this.throwError(err, info);
+          return false;
+        }
+      } else {
+        //not available for MySQL
+        // max_execution time exist, but only for select, and as hint
+        const err = Errors.createError(
+          'Cannot use timeout for MySQL server. timeout value: ' + this.opts.timeout,
+          this.sql,
+          false,
+          info,
+          'HY000',
+          Errors.ER_TIMEOUT_NOT_SUPPORTED
+        );
+        this.emit('send_end');
+        this.throwError(err, info);
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Validate that parameters exists and are defined.
+   *
+   * @param info        connection info
+   * @returns {boolean} return false if any error occur.
+   */
+  validateParameters(info) {
+    //validate parameter size.
+    if (this.queryParts.length - 1 > this.values.length) {
+      this.emit('send_end');
+      this.throwNewError(
+        'Parameter at position ' + (this.values.length + 1) + ' is not set',
+        false,
+        info,
+        'HY000',
+        Errors.ER_MISSING_PARAMETER
+      );
+      return false;
+    }
+
+    //validate parameter is defined.
+    for (let i = 0; i < this.queryParts.length - 1; i++) {
+      if (this.values[i] === undefined) {
+        this.emit('send_end');
+        this.throwNewError(
+          'Parameter at position ' + (i + 1) + ' is undefined\n' + this.displaySql(),
+          false,
+          info,
+          'HY000',
+          Errors.ER_PARAMETER_UNDEFINED
+        );
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Define params events.
+   * Each parameter indicate that he is written to socket,
+   * emitting event so next stream parameter can be written.
+   */
+  registerStreamSendEvent(out, info) {
+    // note : Implementation use recursive calls, but stack won't never get near v8 max call stack size
+    //since event launched for stream parameter only
+    this.paramWritten = function () {
+      while (true) {
+        if (this.currentParam === this.queryParts.length) {
+          //********************************************
+          // all parameters are written.
+          // flush packet
+          //********************************************
+          out.flushBuffer(true);
+          this.sending = false;
+          this.emit('send_end');
+          return;
+        } else {
+          const value = this.values[this.currentParam - 1];
+
+          if (value === null) {
+            out.writeStringAscii('NULL');
+            out.writeString(this.queryParts[this.currentParam++]);
+            continue;
+          }
+
+          if (
+            typeof value === 'object' &&
+            typeof value.pipe === 'function' &&
+            typeof value.read === 'function'
+          ) {
+            //********************************************
+            // param is stream,
+            //********************************************
+            out.writeInt8(QUOTE);
+            value.once(
+              'end',
+              function () {
+                out.writeInt8(QUOTE);
+                out.writeString(this.queryParts[this.currentParam++]);
+                this.paramWritten();
+              }.bind(this)
+            );
+            value.on('data', function (chunk) {
+              out.writeBufferEscape(chunk);
+            });
+            return;
+          }
+
+          //********************************************
+          // param isn't stream. directly write in buffer
+          //********************************************
+          this.writeParam(out, value, this.opts, info);
+          out.writeString(this.queryParts[this.currentParam++]);
+        }
+      }
+    }.bind(this);
+  }
+}
+
+module.exports = Query;