Make errors from the parser catchable

Author: dougwilson

Changes.md

@@ -14,6 +14,7 @@ you spot any mistakes.
 * Default `connectTimeout` to 10 seconds
 * Fix domain binding with `conn.connect`
 * Fix `packet.default` to actually be a string
+* Fix `PARSER_*` errors to be catchable
 * Fix `PROTOCOL_PACKETS_OUT_OF_ORDER` error to be catchable #844
 * Return `Query` object from `pool.query` like `conn.query` #830
 * Use `EventEmitter.listenerCount` when possible for faster counting

lib/protocol/Parser.js

@@ -13,6 +13,7 @@ function Parser(options) {
   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;
@@ -44,7 +45,8 @@ Parser.prototype.write = function(buffer) {
           'Expected: ' + this._nextPacketNumber
         );
 
-        err.code = 'PROTOCOL_PACKETS_OUT_OF_ORDER';
+        err.code  = 'PROTOCOL_PACKETS_OUT_OF_ORDER';
+        err.fatal = true;
 
         this._onError(err);
       }
@@ -56,10 +58,11 @@ Parser.prototype.write = function(buffer) {
       break;
     }
 
-    this._packetEnd = this._offset + this._packetHeader.length;
+    this._packetEnd    = this._offset + this._packetHeader.length;
+    this._packetOffset = this._offset;
 
     if (this._packetHeader.length === MAX_PACKET_LENGTH) {
-      this._longPacketBuffers.push(this._buffer.slice(this._offset, this._packetEnd));
+      this._longPacketBuffers.push(this._buffer.slice(this._packetOffset, this._packetEnd));
 
       this._advanceToNextPacket();
       continue;
@@ -73,6 +76,15 @@ Parser.prototype.write = function(buffer) {
     try {
       this._onPacket(this._packetHeader);
       hadException = false;
+    } catch (err) {
+      if (typeof err.code !== 'string' || err.code.substr(0, 7) !== 'PARSER_') {
+        // Rethrow unknown errors
+        throw err;
+      }
+
+      // Pass down parser errors
+      this._onError(err);
+      hadException = false;
     } finally {
       this._advanceToNextPacket();
 
@@ -133,7 +145,10 @@ Parser.prototype.parseUnsignedNumber = function(bytes) {
   var value  = 0;
 
   if (bytes > 4) {
-    throw new Error('parseUnsignedNumber: Supports only up to 4 bytes');
+    var err    = new Error('parseUnsignedNumber: Supports only up to 4 bytes');
+    err.offset = (this._offset - this._packetOffset - 1);
+    err.code   = 'PARSER_UNSIGNED_TOO_LONG';
+    throw err;
   }
 
   while (offset >= this._offset) {
@@ -168,7 +183,10 @@ Parser.prototype.parseLengthCodedBuffer = function() {
 
 Parser.prototype.parseLengthCodedNumber = function parseLengthCodedNumber() {
   if (this._offset >= this._buffer.length) {
-    throw new Error('Parser: read past end');
+    var err    = new Error('Parser: read past end');
+    err.offset = (this._offset - this._packetOffset);
+    err.code   = 'PARSER_READ_PAST_END';
+    throw err;
   }
 
   var bits = this._buffer[this._offset++];
@@ -187,7 +205,10 @@ Parser.prototype.parseLengthCodedNumber = function parseLengthCodedNumber() {
     case 254:
       break;
     default:
-      throw new Error('parseLengthCodedNumber: Unexpected first byte: 0x' + bits.toString(16));
+      var err    = new Error('Unexpected first byte' + (bits ? ': 0x' + bits.toString(16) : ''));
+      err.offset = (this._offset - this._packetOffset - 1);
+      err.code   = 'PARSER_BAD_LENGTH_BYTE';
+      throw err;
   }
 
   var low = this.parseUnsignedNumber(4);
@@ -201,10 +222,13 @@ Parser.prototype.parseLengthCodedNumber = function parseLengthCodedNumber() {
       return value;
     }
 
-    throw new Error(
+    var err    = new Error(
       'parseLengthCodedNumber: JS precision range exceeded, ' +
       'number is >= 53 bit: "' + value + '"'
     );
+    err.offset = (this._offset - this._packetOffset - 8);
+    err.code   = 'PARSER_JS_PRECISION_RANGE_EXCEEDED';
+    throw err;
   }
 
   value = low + (MUL_32BIT * high);
@@ -239,7 +263,10 @@ Parser.prototype._nullByteOffset = function() {
     offset++;
 
     if (offset >= this._buffer.length) {
-      throw new Error('Offset of null terminated string not found.');
+      var err    = new Error('Offset of null terminated string not found.');
+      err.offset = (this._offset - this._packetOffset);
+      err.code   = 'PARSER_MISSING_NULL_BYTE';
+      throw err;
     }
   }
 
@@ -374,10 +401,12 @@ Parser.prototype._combineLongPacketBuffers = function() {
   this._longPacketBuffers = [];
   this._offset            = 0;
   this._packetEnd         = this._buffer.length - trailingPacketBytes;
+  this._packetOffset      = 0;
 };
 
 Parser.prototype._advanceToNextPacket = function() {
   this._offset       = this._packetEnd;
   this._packetHeader = null;
   this._packetEnd    = null;
+  this._packetOffset = null;
 };

lib/protocol/Protocol.js

@@ -29,7 +29,7 @@ function Protocol(options) {
   this._handshakeInitializationPacket = null;
 
   this._parser = new Parser({
-    onError  : this.handleNetworkError.bind(this),
+    onError  : this.handleParserError.bind(this),
     onPacket : this._parsePacket.bind(this),
     config   : this._config
   });
@@ -330,6 +330,15 @@ Protocol.prototype.handleNetworkError = function(err) {
   }
 };
 
+Protocol.prototype.handleParserError = function handleParserError(err) {
+  var sequence = this._queue[0];
+  if (sequence) {
+    sequence.end(err);
+  } else {
+    this._delegateError(err);
+  }
+};
+
 Protocol.prototype._delegateError = function(err, sequence) {
   // Stop delegating errors after the first fatal error
   if (this._fatalError) {

lib/protocol/packets/FieldPacket.js

@@ -28,7 +28,9 @@ FieldPacket.prototype.parse = function(parser) {
     this.orgName     = parser.parseLengthCodedString();
 
     if (parser.parseLengthCodedNumber() !== 0x0c) {
-      throw new TypeError('Received invalid field length');
+      var err  = new TypeError('Received invalid field length');
+      err.code = 'PARSER_INVALID_FIELD_LENGTH';
+      throw err;
     }
 
     this.charsetNr   = parser.parseUnsignedNumber(2);
@@ -39,7 +41,9 @@ FieldPacket.prototype.parse = function(parser) {
 
     var filler       = parser.parseBuffer(2);
     if (filler[0] !== 0x0 || filler[1] !== 0x0) {
-      throw new TypeError('Received invalid filler');
+      var err  = new TypeError('Received invalid filler');
+      err.code = 'PARSER_INVALID_FILLER';
+      throw err;
     }
 
     // parsed flags

test/unit/connection/test-parser-error.js

@@ -0,0 +1,40 @@
+var assert       = require('assert');
+var common       = require('../../common');
+var connection   = common.createConnection({port: common.fakeServerPort});
+var Packets      = require(common.lib + '/protocol/packets');
+var PacketWriter = require(common.lib + '/protocol/PacketWriter');
+var server       = common.createFakeServer();
+
+server.listen(common.fakeServerPort, function(err) {
+  assert.ifError(err);
+
+  connection.query('SELECT value FROM stuff', function (err) {
+    assert.ok(err, 'got err');
+    assert.equal(err.code, 'PARSER_READ_PAST_END');
+    assert.equal(!!err.fatal, false);
+    assert.equal(err.offset, 4);
+    connection.destroy();
+    server.destroy();
+  });
+});
+
+server.on('connection', function(conn) {
+  conn.handshake();
+  conn.on('query', function(packet) {
+    switch (packet.sql) {
+      case 'SELECT value FROM stuff':
+        this._sendPacket(new Packets.ResultSetHeaderPacket({
+          fieldCount: 1
+        }));
+
+        var writer = new PacketWriter();
+        writer.writeLengthCodedString('def');
+        this._socket.write(writer.toBuffer(this._parser));
+        this._parser.resetPacketNumber();
+        break;
+      default:
+        this._handlePacketQuery(packet);
+        break;
+    }
+  });
+});