@tachybase/module-multi-app 0.23.8

package/dist/node_modules/mariadb/lib/io/packet-output-stream.js

@@ -0,0 +1,502 @@
+'use strict';
+
+const Iconv = require('iconv-lite');
+const Utils = require('../misc/utils');
+
+const QUOTE = 0x27;
+const DBL_QUOTE = 0x22;
+const ZERO_BYTE = 0x00;
+const SLASH = 0x5c;
+
+//increase by level to avoid buffer copy.
+const SMALL_BUFFER_SIZE = 1024;
+const MEDIUM_BUFFER_SIZE = 16384; //16k
+const LARGE_BUFFER_SIZE = 131072; //128k
+const BIG_BUFFER_SIZE = 1048576; //1M
+const MAX_BUFFER_SIZE = 16777219; //16M + 4
+const CHARS_GLOBAL_REGEXP = /[\0\"\'\\\b\n\r\t\u001A]/g; // eslint-disable-line no-control-regex
+
+/**
+ * MySQL packet builder.
+ *
+ * @param opts    options
+ * @param info    connection info
+ * @constructor
+ */
+class PacketOutputStream {
+  constructor(opts, info) {
+    this.opts = opts;
+    this.info = info;
+    this.pos = 4;
+    this.buf = Buffer.allocUnsafe(SMALL_BUFFER_SIZE);
+    this.changeEncoding(this.opts.collation);
+    this.changeDebug(this.opts.logPackets, this.opts.debug);
+
+    this.opts.on('collation', this.changeEncoding.bind(this));
+    this.opts.on('debug', this.changeDebug.bind(this));
+  }
+
+  changeEncoding(collation) {
+    this.encoding = collation.charset;
+    if (this.encoding === 'utf8') {
+      this.writeString = this.writeDefaultBufferString;
+      this.writeStringEscapeQuote = this.writeUtf8StringEscapeQuote;
+    } else if (Buffer.isEncoding(this.encoding)) {
+      this.writeString = this.writeDefaultBufferString;
+      this.writeStringEscapeQuote = this.writeDefaultStringEscapeQuote;
+    } else {
+      this.writeString = this.writeDefaultIconvString;
+      this.writeStringEscapeQuote = this.writeDefaultStringEscapeQuote;
+    }
+  }
+
+  changeDebug(logPackets, debug) {
+    this.logPackets = logPackets;
+    this.debug = debug;
+    this.flushBuffer =
+      this.logPackets || this.debug ? this.flushBufferDebug : this.flushBufferBasic;
+  }
+
+  setStream(stream) {
+    this.stream = stream;
+  }
+
+  growBuffer(len) {
+    let newCapacity;
+    if (len + this.pos < MEDIUM_BUFFER_SIZE) {
+      newCapacity = MEDIUM_BUFFER_SIZE;
+    } else if (len + this.pos < LARGE_BUFFER_SIZE) {
+      newCapacity = LARGE_BUFFER_SIZE;
+    } else if (len + this.pos < BIG_BUFFER_SIZE) {
+      newCapacity = BIG_BUFFER_SIZE;
+    } else newCapacity = MAX_BUFFER_SIZE;
+
+    let newBuf = Buffer.allocUnsafe(newCapacity);
+    this.buf.copy(newBuf, 0, 0, this.pos);
+    this.buf = newBuf;
+  }
+
+  startPacket(cmd) {
+    this.cmd = cmd;
+    this.pos = 4;
+  }
+
+  writeInt8(value) {
+    if (this.pos + 1 >= this.buf.length) {
+      if (this.pos >= MAX_BUFFER_SIZE) {
+        //buffer is more than a Packet, must flushBuffer()
+        this.flushBuffer(false, 1);
+      } else this.growBuffer(1);
+    }
+    this.buf[this.pos++] = value;
+  }
+
+  writeInt16(value) {
+    if (this.pos + 2 >= this.buf.length) {
+      let b = Buffer.allocUnsafe(2);
+      b.writeUInt16LE(value, 0);
+      this.writeBuffer(b, 0, 2);
+      return;
+    }
+    this.buf[this.pos] = value;
+    this.buf[this.pos + 1] = value >> 8;
+    this.pos += 2;
+  }
+
+  writeInt16AtPos(initPos) {
+    this.buf[initPos] = this.pos - initPos - 2;
+    this.buf[initPos + 1] = (this.pos - initPos - 2) >> 8;
+  }
+
+  writeInt32(value) {
+    if (this.pos + 4 >= this.buf.length) {
+      //not enough space remaining
+      let arr = Buffer.allocUnsafe(4);
+      arr.writeInt32LE(value, 0);
+      this.writeBuffer(arr, 0, 4);
+      return;
+    }
+
+    this.buf[this.pos] = value;
+    this.buf[this.pos + 1] = value >> 8;
+    this.buf[this.pos + 2] = value >> 16;
+    this.buf[this.pos + 3] = value >> 24;
+    this.pos += 4;
+  }
+
+  writeLengthCoded(len) {
+    //length encoded can be null(0xfb) or bigger than 65k, but only if using binary protocol
+    //so not implemented for now
+    if (len < 0xfb) {
+      this.writeInt8(len);
+      return;
+    }
+
+    //max length is len < 0xffff
+    this.writeInt8(0xfc);
+    this.writeInt16(len);
+  }
+
+  writeBuffer(arr, off, len) {
+    if (len > this.buf.length - this.pos) {
+      if (this.buf.length !== MAX_BUFFER_SIZE) {
+        this.growBuffer(len);
+      }
+
+      //max buffer size
+      if (len > this.buf.length - this.pos) {
+        //not enough space in buffer, will stream :
+        // fill buffer and flush until all data are snd
+        let remainingLen = len;
+
+        while (true) {
+          //filling buffer
+          let lenToFillBuffer = Math.min(MAX_BUFFER_SIZE - this.pos, remainingLen);
+          arr.copy(this.buf, this.pos, off, off + lenToFillBuffer);
+          remainingLen -= lenToFillBuffer;
+          off += lenToFillBuffer;
+          this.pos += lenToFillBuffer;
+
+          if (remainingLen === 0) return;
+          this.flushBuffer(false, remainingLen);
+        }
+      }
+    }
+    arr.copy(this.buf, this.pos, off, off + len);
+    this.pos += len;
+  }
+
+  /**
+   * Write ascii string to socket (no escaping)
+   *
+   * @param str                string
+   */
+  writeStringAscii(str) {
+    let len = str.length;
+
+    //not enough space remaining
+    if (len >= this.buf.length - this.pos) {
+      let strBuf = Buffer.from(str, 'ascii');
+      this.writeBuffer(strBuf, 0, strBuf.length);
+      return;
+    }
+
+    for (let off = 0; off < len; ) {
+      this.buf[this.pos++] = str.charCodeAt(off++);
+    }
+  }
+
+  writeUtf8StringEscapeQuote(str) {
+    const charsLength = str.length;
+
+    //not enough space remaining
+    if (charsLength * 3 + 2 >= this.buf.length - this.pos) {
+      const arr = Buffer.from(str, 'utf8');
+      this.writeInt8(QUOTE);
+      this.writeBufferEscape(arr);
+      this.writeInt8(QUOTE);
+      return;
+    }
+
+    //create UTF-8 byte array
+    //since javascript char are internally using UTF-16 using surrogate's pattern, 4 bytes unicode characters will
+    //represent 2 characters : example "\uD83C\uDFA4" = 🎤 unicode 8 "no microphones"
+    //so max size is 3 * charLength
+    //(escape characters are 1 byte encoded, so length might only be 2 when escaped)
+    // + 2 for the quotes for text protocol
+    let charsOffset = 0;
+    let currChar;
+    this.buf[this.pos++] = QUOTE;
+    //quick loop if only ASCII chars for faster escape
+    for (
+      ;
+      charsOffset < charsLength && (currChar = str.charCodeAt(charsOffset)) < 0x80;
+      charsOffset++
+    ) {
+      if (
+        currChar === SLASH ||
+        currChar === QUOTE ||
+        currChar === ZERO_BYTE ||
+        currChar === DBL_QUOTE
+      ) {
+        this.buf[this.pos++] = SLASH;
+      }
+      this.buf[this.pos++] = currChar;
+    }
+
+    //if quick loop not finished
+    while (charsOffset < charsLength) {
+      currChar = str.charCodeAt(charsOffset++);
+      if (currChar < 0x80) {
+        if (
+          currChar === SLASH ||
+          currChar === QUOTE ||
+          currChar === ZERO_BYTE ||
+          currChar === DBL_QUOTE
+        ) {
+          this.buf[this.pos++] = SLASH;
+        }
+        this.buf[this.pos++] = currChar;
+      } else if (currChar < 0x800) {
+        this.buf[this.pos++] = 0xc0 | (currChar >> 6);
+        this.buf[this.pos++] = 0x80 | (currChar & 0x3f);
+      } else if (currChar >= 0xd800 && currChar < 0xe000) {
+        //reserved for surrogate - see https://en.wikipedia.org/wiki/UTF-16
+        if (currChar < 0xdc00) {
+          //is high surrogate
+          if (charsOffset + 1 > charsLength) {
+            this.buf[this.pos++] = 0x3f;
+          } else {
+            const nextChar = str.charCodeAt(charsOffset);
+            if (nextChar >= 0xdc00 && nextChar < 0xe000) {
+              //is low surrogate
+              const surrogatePairs =
+                (currChar << 10) + nextChar + (0x010000 - (0xd800 << 10) - 0xdc00);
+              this.buf[this.pos++] = 0xf0 | (surrogatePairs >> 18);
+              this.buf[this.pos++] = 0x80 | ((surrogatePairs >> 12) & 0x3f);
+              this.buf[this.pos++] = 0x80 | ((surrogatePairs >> 6) & 0x3f);
+              this.buf[this.pos++] = 0x80 | (surrogatePairs & 0x3f);
+              charsOffset++;
+            } else {
+              //must have low surrogate
+              this.buf[this.pos++] = 0x3f;
+            }
+          }
+        } else {
+          //low surrogate without high surrogate before
+          this.buf[this.pos++] = 0x3f;
+        }
+      } else {
+        this.buf[this.pos++] = 0xe0 | (currChar >> 12);
+        this.buf[this.pos++] = 0x80 | ((currChar >> 6) & 0x3f);
+        this.buf[this.pos++] = 0x80 | (currChar & 0x3f);
+      }
+    }
+    this.buf[this.pos++] = QUOTE;
+  }
+
+  writeDefaultBufferString(str) {
+    //javascript use UCS-2 or UTF-16 string internal representation
+    //that means that string to byte will be a maximum of * 3
+    // (4 bytes utf-8 are represented on 2 UTF-16 characters)
+    if (str.length * 3 < this.buf.length - this.pos) {
+      this.pos += this.buf.write(str, this.pos, this.encoding);
+      return;
+    }
+
+    //checking real length
+    let byteLength = Buffer.byteLength(str, this.encoding);
+    if (byteLength > this.buf.length - this.pos) {
+      if (this.buf.length < MAX_BUFFER_SIZE) {
+        this.growBuffer(byteLength);
+      }
+      if (byteLength > this.buf.length - this.pos) {
+        //not enough space in buffer, will stream :
+        let strBuf = Buffer.from(str, this.encoding);
+        this.writeBuffer(strBuf, 0, strBuf.length);
+        return;
+      }
+    }
+    this.pos += this.buf.write(str, this.pos, this.encoding);
+  }
+
+  writeDefaultIconvString(str) {
+    let buf = Iconv.encode(str, this.encoding);
+    this.writeBuffer(buf, 0, buf.length);
+  }
+
+  /**
+   * Parameters need to be properly escaped :
+   * following characters are to be escaped by "\" :
+   * - \0
+   * - \\
+   * - \'
+   * - \"
+   * regex split part of string writing part, and escaping special char.
+   * Those chars are <= 7f meaning that this will work even with multi-byte encoding
+   *
+   * @param str string to escape.
+   */
+  writeDefaultStringEscapeQuote(str) {
+    this.writeInt8(QUOTE);
+    let match;
+    let lastIndex = 0;
+    while ((match = CHARS_GLOBAL_REGEXP.exec(str)) !== null) {
+      this.writeString(str.slice(lastIndex, match.index));
+      this.writeInt8(SLASH);
+      this.writeInt8(match[0].charCodeAt(0));
+      lastIndex = CHARS_GLOBAL_REGEXP.lastIndex;
+    }
+
+    if (lastIndex === 0) {
+      // Nothing was escaped
+      this.writeString(str);
+      this.writeInt8(QUOTE);
+      return;
+    }
+
+    if (lastIndex < str.length) {
+      this.writeString(str.slice(lastIndex));
+    }
+    this.writeInt8(QUOTE);
+  }
+
+  writeBufferEscape(val) {
+    let valLen = val.length;
+    if (valLen * 2 > this.buf.length - this.pos) {
+      //makes buffer bigger (up to 16M)
+      if (this.buf.length !== MAX_BUFFER_SIZE) this.growBuffer(valLen * 2);
+
+      //data may still be bigger than buffer.
+      //must flush buffer when full (and reset position to 4)
+      if (valLen * 2 > this.buf.length - this.pos) {
+        //not enough space in buffer, will fill buffer
+        for (let i = 0; i < valLen; i++) {
+          switch (val[i]) {
+            case QUOTE:
+            case SLASH:
+            case DBL_QUOTE:
+            case ZERO_BYTE:
+              if (this.pos >= this.buf.length) this.flushBuffer(false, (valLen - i) * 2);
+              this.buf[this.pos++] = SLASH; //add escape slash
+          }
+          if (this.pos >= this.buf.length) this.flushBuffer(false, (valLen - i) * 2);
+          this.buf[this.pos++] = val[i];
+        }
+        return;
+      }
+    }
+
+    //sure to have enough place to use buffer directly
+    for (let i = 0; i < valLen; i++) {
+      switch (val[i]) {
+        case QUOTE:
+        case SLASH:
+        case DBL_QUOTE:
+        case ZERO_BYTE:
+          this.buf[this.pos++] = SLASH; //add escape slash
+      }
+      this.buf[this.pos++] = val[i];
+    }
+  }
+
+  /**
+   * Indicate if buffer contain any data.
+   * @returns {boolean}
+   */
+  isEmpty() {
+    return this.pos <= 4;
+  }
+
+  /**
+   * Flush the internal buffer.
+   */
+  flushBufferDebug(commandEnd, remainingLen) {
+    this.buf[0] = this.pos - 4;
+    this.buf[1] = (this.pos - 4) >>> 8;
+    this.buf[2] = (this.pos - 4) >>> 16;
+    this.buf[3] = ++this.cmd.sequenceNo;
+
+    this.stream.writeBuf(this.buf.slice(0, this.pos), this.cmd);
+
+    const packet = Utils.log(this.opts, this.buf, 0, this.pos);
+    if (this.opts.logPackets) {
+      this.info.addPacket(
+        '==> conn:' +
+          (this.info.threadId ? this.info.threadId : -1) +
+          ' ' +
+          this.cmd.constructor.name +
+          '(0,' +
+          this.pos +
+          ')\n' +
+          packet
+      );
+    }
+
+    if (this.opts.debug) {
+      console.log(
+        '==> conn:%d %s\n%s',
+        this.info.threadId ? this.info.threadId : -1,
+        this.cmd.constructor.name + '(0,' + this.pos + ')',
+        Utils.log(this.opts, this.buf, 0, this.pos)
+      );
+    }
+
+    if (commandEnd) {
+      //if last packet fill the max size, must send an empty com to indicate that command end.
+      if (this.pos === MAX_BUFFER_SIZE) {
+        this.writeEmptyPacket();
+      } else {
+        this.stream.flush(true, this.cmd);
+        this.buf = Buffer.allocUnsafe(SMALL_BUFFER_SIZE);
+      }
+    } else {
+      this.buf = allocateBuffer(remainingLen + 4);
+      this.pos = 4;
+    }
+  }
+
+  flushBufferBasic(commandEnd, remainingLen) {
+    this.buf[0] = this.pos - 4;
+    this.buf[1] = (this.pos - 4) >>> 8;
+    this.buf[2] = (this.pos - 4) >>> 16;
+    this.buf[3] = ++this.cmd.sequenceNo;
+    this.stream.writeBuf(this.buf.slice(0, this.pos), this.cmd);
+    if (commandEnd) {
+      //if last packet fill the max size, must send an empty com to indicate that command end.
+      if (this.pos === MAX_BUFFER_SIZE) {
+        this.writeEmptyPacket();
+      } else {
+        this.stream.flush(true, this.cmd);
+        this.buf = Buffer.allocUnsafe(SMALL_BUFFER_SIZE);
+      }
+    } else {
+      this.buf = allocateBuffer(remainingLen + 4);
+      this.pos = 4;
+    }
+  }
+
+  writeEmptyPacket() {
+    const emptyBuf = Buffer.from([0x00, 0x00, 0x00, ++this.cmd.sequenceNo]);
+
+    if (this.opts.logPackets || this.opts.debug) {
+      const packet = Utils.log(this.opts, emptyBuf, 0, 4);
+      if (this.opts.logPackets) {
+        this.info.addPacket(
+          '==> conn:' +
+            (this.info.threadId ? this.info.threadId : -1) +
+            ' ' +
+            this.cmd.constructor.name +
+            '(0,4)\n' +
+            packet
+        );
+      }
+      if (this.opts.debug) {
+        console.log(
+          '==> conn:%d %s\n%s',
+          this.info.threadId ? this.info.threadId : -1,
+          this.cmd.constructor.name + '(0,4)',
+          packet
+        );
+      }
+    }
+
+    this.stream.writeBuf(emptyBuf, this.cmd);
+    this.stream.flush(true, this.cmd);
+  }
+}
+
+function allocateBuffer(len) {
+  if (len < SMALL_BUFFER_SIZE) {
+    return Buffer.allocUnsafe(SMALL_BUFFER_SIZE);
+  } else if (len < MEDIUM_BUFFER_SIZE) {
+    return Buffer.allocUnsafe(MEDIUM_BUFFER_SIZE);
+  } else if (len < LARGE_BUFFER_SIZE) {
+    return Buffer.allocUnsafe(LARGE_BUFFER_SIZE);
+  } else if (len < BIG_BUFFER_SIZE) {
+    return Buffer.allocUnsafe(BIG_BUFFER_SIZE);
+  }
+  return Buffer.allocUnsafe(MAX_BUFFER_SIZE);
+}
+
+module.exports = PacketOutputStream;