Fix/error suppress

Changes.md

@@ -31,6 +31,7 @@ you spot any mistakes.
 * Fix `connection.threadId` missing on handshake failure
 * Fix duplicate packet name in debug output
 * Fix no password support for old password protocol
+* Fix suppression of fatal protocol server errors #2021
 * Remove special case for handshake in determine packet code
 * Small performance improvement starting command sequence
 * Support auth switch in change user flow #1776

lib/Connection.js

@@ -15,6 +15,7 @@ function Connection(options) {
 
   this.config = options.config;
 
+  this._buffer        = [];
   this._socket        = options.socket;
   this._protocol      = new Protocol({config: this.config, connection: this});
   this._connectCalled = false;
@@ -81,8 +82,18 @@ Connection.prototype.connect = function connect(options, callback) {
     }
 
     var connection = this;
-    this._protocol.on('data', function(data) {
-      connection._socket.write(data);
+    var onWrite    = function onWrite() {
+      if (connection._buffer.shift() && connection._buffer.length > 0) {
+        setTimeout(function () {
+          connection._socket.write(connection._buffer[0], onWrite);
+        }, 10);
+      }
+    };
+
+    this._protocol.on('data', function (data) {
+      if (connection._buffer.push(data) === 1) {
+        connection._socket.write(data, onWrite);
+      }
     });
     this._socket.on('data', wrapToDomain(connection, function (data) {
       connection._protocol.write(data);

lib/protocol/PacketWriter.js

@@ -5,13 +5,17 @@ var BUFFER_ALLOC_SIZE = Math.pow(2, 8);
 // Don't panic: Good enough to represent byte values up to 8192 TB
 var IEEE_754_BINARY_64_PRECISION = Math.pow(2, 53);
 var MAX_PACKET_LENGTH            = Math.pow(2, 24) - 1;
-var Buffer                       = require('safe-buffer').Buffer;
+
+var Buffer       = require('safe-buffer').Buffer;
+var EventEmitter = require('events').EventEmitter;
+var Util         = require('util');
 
 module.exports = PacketWriter;
 function PacketWriter() {
   this._buffer = null;
   this._offset = 0;
 }
+Util.inherits(PacketWriter, EventEmitter);
 
 PacketWriter.prototype.toBuffer = function toBuffer(parser) {
   if (!this._buffer) {
@@ -32,7 +36,8 @@ PacketWriter.prototype.toBuffer = function toBuffer(parser) {
       ? length % MAX_PACKET_LENGTH
       : MAX_PACKET_LENGTH;
 
-    var packetNumber = parser.incrementPacketNumber();
+    var packetNumber = parser.incrementPacketNumber(packet > 0);
+    var packetOffset = this._offset;
 
     this.writeUnsignedNumber(3, packetLength);
     this.writeUnsignedNumber(1, packetNumber);
@@ -41,6 +46,8 @@ PacketWriter.prototype.toBuffer = function toBuffer(parser) {
     var end   = start + packetLength;
 
     this.writeBuffer(buffer.slice(start, end));
+
+    this.emit('data', this._buffer.slice(packetOffset, this._offset));
   }
 
   return this._buffer;

lib/protocol/Parser.js

@@ -11,19 +11,20 @@ module.exports = Parser;
 function Parser(options) {
   options = options || {};
 
-  this._supportBigNumbers = options.config && options.config.supportBigNumbers;
-  this._buffer            = Buffer.alloc(0);
-  this._nextBuffers       = new BufferList();
-  this._longPacketBuffers = new BufferList();
-  this._offset            = 0;
-  this._packetEnd         = null;
-  this._packetHeader      = null;
-  this._packetOffset      = null;
-  this._onError           = options.onError || function(err) { throw err; };
-  this._onPacket          = options.onPacket || function() {};
-  this._nextPacketNumber  = 0;
-  this._encoding          = 'utf-8';
-  this._paused            = false;
+  this._supportBigNumbers    = options.config && options.config.supportBigNumbers;
+  this._buffer               = Buffer.alloc(0);
+  this._nextBuffers          = new BufferList();
+  this._expectedPacketNumber = 0;
+  this._longPacketBuffers    = new BufferList();
+  this._offset               = 0;
+  this._packetEnd            = null;
+  this._packetHeader         = null;
+  this._packetOffset         = null;
+  this._onError              = options.onError || function(err) { throw err; };
+  this._onPacket             = options.onPacket || function() {};
+  this._nextPacketNumber     = 0;
+  this._encoding             = 'utf-8';
+  this._paused               = false;
 }
 
 Parser.prototype.write = function write(chunk) {
@@ -103,6 +104,16 @@ Parser.prototype.append = function append(chunk) {
     : null;
 };
 
+Parser.prototype.isExpectedPacketNumber = function isExpectedPacketNumber(num) {
+  if (this._expectedPacketNumber === this._nextPacketNumber) {
+    return this._expectedPacketNumber === num;
+  } else if (this._expectedPacketNumber < this._nextPacketNumber) {
+    return this._expectedPacketNumber <= num && this._nextPacketNumber >= num;
+  } else {
+    return this._expectedPacketNumber <= num || this._nextPacketNumber >= num;
+  }
+};
+
 Parser.prototype.pause = function() {
   this._paused = true;
 };
@@ -345,15 +356,20 @@ Parser.prototype.reachedPacketEnd = function() {
   return this._offset === this._packetEnd;
 };
 
-Parser.prototype.incrementPacketNumber = function() {
+Parser.prototype.incrementPacketNumber = function incrementPacketNumber(isContinuation) {
   var currentPacketNumber = this._nextPacketNumber;
   this._nextPacketNumber = (this._nextPacketNumber + 1) % 256;
 
+  if (!isContinuation) {
+    this._expectedPacketNumber = this._nextPacketNumber;
+  }
+
   return currentPacketNumber;
 };
 
 Parser.prototype.resetPacketNumber = function() {
-  this._nextPacketNumber = 0;
+  this._expectedPacketNumber = 0;
+  this._nextPacketNumber     = 0;
 };
 
 Parser.prototype.packetLength = function packetLength() {
@@ -466,7 +482,7 @@ Parser.prototype._tryReadPacketHeader = function _tryReadPacketHeader() {
     this.parseUnsignedNumber(1)
   );
 
-  if (this._packetHeader.number !== this._nextPacketNumber) {
+  if (!this.isExpectedPacketNumber(this._packetHeader.number)) {
     var err = new Error(
       'Packets out of order. Got: ' + this._packetHeader.number + ' ' +
       'Expected: ' + this._nextPacketNumber

lib/protocol/Protocol.js

@@ -301,8 +301,14 @@ Protocol.prototype._parsePacketDebug = function _parsePacketDebug(packet) {
 
 Protocol.prototype._emitPacket = function(packet) {
   var packetWriter = new PacketWriter();
+  var protocol     = this;
+
+  packetWriter.on('data', function (data) {
+    protocol.emit('data', data);
+  });
+
   packet.write(packetWriter);
-  this.emit('data', packetWriter.toBuffer(this._parser));
+  packetWriter.toBuffer(this._parser);
 
   if (this._config.debug) {
     this._debugPacket(false, packet);

lib/protocol/sequences/Sequence.js

@@ -51,6 +51,11 @@ Sequence.prototype._packetToError = function(packet) {
   err.sqlMessage = packet.message;
   err.sqlState   = packet.sqlState;
 
+  // fatal sql state
+  if (packet.sqlState === '08S01') {
+    err.fatal = true;
+  }
+
   return err;
 };
 

test/integration/connection/test-exceed-max-packet-size.js

@@ -0,0 +1,31 @@
+var assert = require('assert');
+var common = require('../../common');
+var crypto = require('crypto');
+
+if (process.platform === 'win32') {
+  common.skipTest('windows sockets close immediately');
+}
+
+common.getTestConnection(function (err, conn) {
+  assert.ifError(err);
+
+  conn.query('SHOW VARIABLES WHERE Variable_name = ?', ['max_allowed_packet'], function (err, rows) {
+    assert.ifError(err);
+    assert.strictEqual(rows.length, 1);
+
+    var maxAllowedPacket = Number(rows[0].Value);
+    assert.ok(maxAllowedPacket > 0);
+
+    var length = maxAllowedPacket;
+    var random = crypto.pseudoRandomBytes || crypto.randomBytes; // Depends on node.js version
+
+    random(length, function (err, buf) {
+      assert.ifError(err);
+      conn.query('SELECT ?', [buf], function (err) {
+        assert.ok(err);
+        assert.strictEqual(err.code, 'ER_NET_PACKET_TOO_LARGE');
+        assert.strictEqual(err.fatal, true);
+      });
+    });
+  });
+});