Use safe-buffer for improved Buffer API

Changes.md

@@ -4,6 +4,10 @@ This file is a manually maintained list of changes for each release. Feel free
 to add your changes here when sending pull requests. Also send corrections if
 you spot any mistakes.
 
+## HEAD
+
+* Use `safe-buffer` for improved Buffer API
+
 ## v2.13.0 (2017-01-24)
 
 * Accept regular expression as pool cluster pattern #1572

benchmark/parse-100k-blog-rows.js

@@ -1,15 +1,17 @@
 var lib          = __dirname + '/../lib';
+var Buffer       = require('safe-buffer').Buffer;
 var Protocol     = require(lib + '/protocol/protocol');
 var Packets      = require(lib + '/protocol/packets');
 var PacketWriter = require(lib + '/protocol/PacketWriter');
 var Parser       = require(lib + '/protocol/Parser');
 
-var buffers = createBuffers();
 var options = {
   rows       : 100000,
   bufferSize : 64 * 1024
 };
 
+var buffers = createBuffers();
+
 console.error('Config:', options);
 run();
 
@@ -63,7 +65,7 @@ function createRowDataPacketBuffer(parser) {
 }
 
 function mergeBuffers(buffers) {
-  var mergeBuffer  = new Buffer(options.bufferSize);
+  var mergeBuffer  = Buffer.alloc(options.bufferSize);
   var mergeBuffers = [];
   var offset       = 0;
 
@@ -78,7 +80,7 @@ function mergeBuffers(buffers) {
       buffer.copy(mergeBuffer, offset, 0, bytesRemaining);
       mergeBuffers.push(mergeBuffer);
 
-      mergeBuffer = new Buffer(options.bufferSize);
+      mergeBuffer = Buffer.alloc(options.bufferSize);
       buffer.copy(mergeBuffer, 0, bytesRemaining);
       offset = buffer.length - bytesRemaining;
     }

lib/protocol/Auth.js

@@ -1,4 +1,4 @@
-var Buffer = require('buffer').Buffer;
+var Buffer = require('safe-buffer').Buffer;
 var Crypto = require('crypto');
 var Auth   = exports;
 
@@ -10,9 +10,9 @@ function sha1(msg) {
 Auth.sha1 = sha1;
 
 function xor(a, b) {
-  a = new Buffer(a, 'binary');
-  b = new Buffer(b, 'binary');
-  var result = new Buffer(a.length);
+  a = Buffer.from(a, 'binary');
+  b = Buffer.from(b, 'binary');
+  var result = Buffer.allocUnsafe(a.length);
   for (var i = 0; i < a.length; i++) {
     result[i] = (a[i] ^ b[i]);
   }
@@ -22,11 +22,11 @@ Auth.xor = xor;
 
 Auth.token = function(password, scramble) {
   if (!password) {
-    return new Buffer(0);
+    return Buffer.alloc(0);
   }
 
   // password must be in binary format, not utf8
-  var stage1 = sha1((new Buffer(password, 'utf8')).toString('binary'));
+  var stage1 = sha1((Buffer.from(password, 'utf8')).toString('binary'));
   var stage2 = sha1(stage1);
   var stage3 = sha1(scramble.toString('binary') + stage2);
   return xor(stage3, stage1);
@@ -38,10 +38,10 @@ Auth.hashPassword = function(password) {
   var nr = [0x5030, 0x5735],
       add = 7,
       nr2 = [0x1234, 0x5671],
-      result = new Buffer(8);
+      result = Buffer.alloc(8);
 
   if (typeof password === 'string'){
-    password = new Buffer(password);
+    password = Buffer.from(password);
   }
 
   for (var i = 0; i < password.length; i++) {
@@ -86,7 +86,7 @@ Auth.myRnd = function(r){
 };
 
 Auth.scramble323 = function(message, password) {
-  var to = new Buffer(8),
+  var to = Buffer.allocUnsafe(8),
       hashPass = this.hashPassword(password),
       hashMessage = this.hashPassword(message.slice(0, 8)),
       seed1 = this.int32Read(hashPass, 0) ^ this.int32Read(hashMessage, 0),

lib/protocol/PacketWriter.js

@@ -5,6 +5,7 @@ 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;
 
 module.exports = PacketWriter;
 function PacketWriter() {
@@ -14,15 +15,15 @@ function PacketWriter() {
 
 PacketWriter.prototype.toBuffer = function toBuffer(parser) {
   if (!this._buffer) {
-    this._buffer = new Buffer(0);
+    this._buffer = Buffer.alloc(0);
     this._offset = 0;
   }
 
   var buffer  = this._buffer;
   var length  = this._offset;
   var packets = Math.floor(length / MAX_PACKET_LENGTH) + 1;
 
-  this._buffer = new Buffer(length + packets * 4);
+  this._buffer = Buffer.allocUnsafe(length + packets * 4);
   this._offset = 0;
 
   for (var packet = 0; packet < packets; packet++) {
@@ -192,7 +193,7 @@ PacketWriter.prototype.writeLengthCodedString = function(value) {
 
 PacketWriter.prototype._allocate = function _allocate(bytes) {
   if (!this._buffer) {
-    this._buffer = new Buffer(Math.max(BUFFER_ALLOC_SIZE, bytes));
+    this._buffer = Buffer.alloc(Math.max(BUFFER_ALLOC_SIZE, bytes));
     this._offset = 0;
     return;
   }
@@ -205,6 +206,6 @@ PacketWriter.prototype._allocate = function _allocate(bytes) {
   var newSize   = this._buffer.length + Math.max(BUFFER_ALLOC_SIZE, bytes);
   var oldBuffer = this._buffer;
 
-  this._buffer = new Buffer(newSize);
+  this._buffer = Buffer.alloc(newSize);
   oldBuffer.copy(this._buffer);
 };

lib/protocol/Parser.js

@@ -2,14 +2,15 @@ var MAX_PACKET_LENGTH = Math.pow(2, 24) - 1;
 var MUL_32BIT         = Math.pow(2, 32);
 var PacketHeader      = require('./PacketHeader');
 var BigNumber         = require('bignumber.js');
+var Buffer            = require('safe-buffer').Buffer;
 var BufferList        = require('./BufferList');
 
 module.exports = Parser;
 function Parser(options) {
   options = options || {};
 
   this._supportBigNumbers = options.config && options.config.supportBigNumbers;
-  this._buffer            = new Buffer(0);
+  this._buffer            = Buffer.alloc(0);
   this._nextBuffers       = new BufferList();
   this._longPacketBuffers = new BufferList();
   this._offset            = 0;
@@ -119,7 +120,7 @@ Parser.prototype.append = function append(chunk) {
 
   if (sliceLength !== 0) {
     // Create a new Buffer
-    buffer = new Buffer(sliceLength + length);
+    buffer = Buffer.allocUnsafe(sliceLength + length);
     offset = 0;
 
     // Copy data slice
@@ -131,7 +132,7 @@ Parser.prototype.append = function append(chunk) {
     }
   } else if (chunks.length > 1) {
     // Create a new Buffer
-    buffer = new Buffer(length);
+    buffer = Buffer.allocUnsafe(length);
     offset = 0;
 
     // Copy chunks
@@ -314,7 +315,7 @@ Parser.prototype.parsePacketTerminatedString = function() {
 };
 
 Parser.prototype.parseBuffer = function(length) {
-  var response = new Buffer(length);
+  var response = Buffer.alloc(length);
   this._buffer.copy(response, 0, this._offset, this._offset + length);
 
   this._offset += length;
@@ -445,7 +446,7 @@ Parser.prototype._combineLongPacketBuffers = function _combineLongPacketBuffers(
 
   // Create buffer
   var buf    = null;
-  var buffer = new Buffer(remainingBytes + this._longPacketBuffers.size);
+  var buffer = Buffer.allocUnsafe(remainingBytes + this._longPacketBuffers.size);
   var offset = 0;
 
   // Copy long buffers

lib/protocol/packets/ClientAuthenticationPacket.js

@@ -1,3 +1,5 @@
+var Buffer = require('safe-buffer').Buffer;
+
 module.exports = ClientAuthenticationPacket;
 function ClientAuthenticationPacket(options) {
   options = options || {};
@@ -46,7 +48,7 @@ ClientAuthenticationPacket.prototype.write = function(writer) {
     writer.writeBuffer(this.scrambleBuff);
     if (this.database && this.database.length) {
       writer.writeFiller(1);
-      writer.writeBuffer(new Buffer(this.database));
+      writer.writeBuffer(Buffer.from(this.database));
     }
   }
 };

lib/protocol/packets/HandshakeInitializationPacket.js

@@ -1,3 +1,4 @@
+var Buffer = require('safe-buffer').Buffer;
 var Client = require('../constants/client');
 
 module.exports = HandshakeInitializationPacket;
@@ -88,11 +89,13 @@ HandshakeInitializationPacket.prototype.write = function(writer) {
 };
 
 HandshakeInitializationPacket.prototype.scrambleBuff = function() {
-  var buffer = new Buffer(this.scrambleBuff1.length +
-                          (typeof this.scrambleBuff2 !== 'undefined' ? this.scrambleBuff2.length : 0));
+  var buffer = null;
 
-  this.scrambleBuff1.copy(buffer);
-  if (typeof this.scrambleBuff2 !== 'undefined') {
+  if (typeof this.scrambleBuff2 === 'undefined') {
+    buffer = Buffer.from(this.scrambleBuff1);
+  } else {
+    buffer = Buffer.allocUnsafe(this.scrambleBuff1.length + this.scrambleBuff2.length);
+    this.scrambleBuff1.copy(buffer, 0);
     this.scrambleBuff2.copy(buffer, this.scrambleBuff1.length);
   }
 

package.json

@@ -14,6 +14,7 @@
   "dependencies": {
     "bignumber.js": "3.1.2",
     "readable-stream": "1.1.14",
+    "safe-buffer": "5.0.1",
     "sqlstring": "2.2.0"
   },
   "devDependencies": {

test/FakeServer.js

@@ -1,6 +1,7 @@
 // An experimental fake MySQL server for tricky integration tests. Expanded
 // as needed.
 
+var Buffer       = require('safe-buffer').Buffer;
 var common       = require('./common');
 var Charsets     = common.Charsets;
 var Crypto       = require('crypto');
@@ -72,8 +73,8 @@ FakeConnection.prototype.handshake = function(options) {
   this._handshakeOptions = options || {};
 
   var packetOpiotns = common.extend({
-    scrambleBuff1       : new Buffer('1020304050607080', 'hex'),
-    scrambleBuff2       : new Buffer('0102030405060708090A0B0C', 'hex'),
+    scrambleBuff1       : Buffer.from('1020304050607080', 'hex'),
+    scrambleBuff2       : Buffer.from('0102030405060708090A0B0C', 'hex'),
     serverCapabilities1 : 512, // only 1 flag, PROTOCOL_41
     protocol41          : true
   }, this._handshakeOptions);
@@ -269,7 +270,7 @@ FakeConnection.prototype._parsePacket = function(header) {
       if (this._handshakeOptions.oldPassword) {
         this._sendPacket(new Packets.UseOldPasswordPacket());
       } else if (this._handshakeOptions.password === 'passwd') {
-        var expected = new Buffer('3DA0ADA7C9E1BB3A110575DF53306F9D2DE7FD09', 'hex');
+        var expected = Buffer.from('3DA0ADA7C9E1BB3A110575DF53306F9D2DE7FD09', 'hex');
         this._sendAuthResponse(packet, expected);
       } else if (this._handshakeOptions.user || this._handshakeOptions.password) {
         throw new Error('not implemented');

test/integration/connection/test-type-casting.js

@@ -1,4 +1,5 @@
 var assert = require('assert');
+var Buffer = require('safe-buffer').Buffer;
 var common = require('../../common');
 
 var tests = [
@@ -23,13 +24,13 @@ var tests = [
   {type: 'datetime', insert: new Date('2012-05-12 12:00:23')},
   {type: 'date', insert: new Date('2012-05-12 00:00:00')},
   {type: 'time', insert: '13:13:23'},
-  {type: 'binary(4)', insert: new Buffer([0, 1, 254, 255])},
-  {type: 'varbinary(4)', insert: new Buffer([0, 1, 254, 255])},
-  {type: 'tinyblob', insert: new Buffer([0, 1, 254, 255])},
-  {type: 'mediumblob', insert: new Buffer([0, 1, 254, 255])},
-  {type: 'longblob', insert: new Buffer([0, 1, 254, 255])},
-  {type: 'blob', insert: new Buffer([0, 1, 254, 255])},
-  {type: 'bit(32)', insert: new Buffer([0, 1, 254, 255])},
+  {type: 'binary(4)', insert: Buffer.from([0, 1, 254, 255])},
+  {type: 'varbinary(4)', insert: Buffer.from([0, 1, 254, 255])},
+  {type: 'tinyblob', insert: Buffer.from([0, 1, 254, 255])},
+  {type: 'mediumblob', insert: Buffer.from([0, 1, 254, 255])},
+  {type: 'longblob', insert: Buffer.from([0, 1, 254, 255])},
+  {type: 'blob', insert: Buffer.from([0, 1, 254, 255])},
+  {type: 'bit(32)', insert: Buffer.from([0, 1, 254, 255])},
   {type: 'char(5)', insert: 'Hello'},
   {type: 'varchar(5)', insert: 'Hello'},
   {type: 'varchar(3) character set utf8 collate utf8_bin', insert: 'bin'},

test/unit/connection/test-large-blobs.js

@@ -1,4 +1,5 @@
 var assert     = require('assert');
+var Buffer     = require('safe-buffer').Buffer;
 var common     = require('../../common');
 var connection = common.createConnection({port: common.fakeServerPort});
 var server     = common.createFakeServer();
@@ -41,27 +42,27 @@ server.on('connection', function(conn) {
         this._sendPacket(new common.Packets.EofPacket());
 
         var writer = new common.PacketWriter();
-        writer.writeLengthCodedBuffer(new Buffer(0));
+        writer.writeLengthCodedBuffer(Buffer.alloc(0));
         this._socket.write(writer.toBuffer(this._parser));
 
         var writer = new common.PacketWriter();
-        writer.writeLengthCodedBuffer(filledBuffer(8, '.'));
+        writer.writeLengthCodedBuffer(Buffer.alloc(8, '.'));
         this._socket.write(writer.toBuffer(this._parser));
 
         var writer = new common.PacketWriter();
-        writer.writeLengthCodedBuffer(filledBuffer((Math.pow(2, 16) - 1), '.'));
+        writer.writeLengthCodedBuffer(Buffer.alloc((Math.pow(2, 16) - 1), '.'));
         this._socket.write(writer.toBuffer(this._parser));
 
         var writer = new common.PacketWriter();
-        writer.writeLengthCodedBuffer(filledBuffer(Math.pow(2, 16), '.'));
+        writer.writeLengthCodedBuffer(Buffer.alloc(Math.pow(2, 16), '.'));
         this._socket.write(writer.toBuffer(this._parser));
 
         var writer = new common.PacketWriter();
-        writer.writeLengthCodedBuffer(filledBuffer((Math.pow(2, 24) - 1), '.'));
+        writer.writeLengthCodedBuffer(Buffer.alloc((Math.pow(2, 24) - 1), '.'));
         this._socket.write(writer.toBuffer(this._parser));
 
         var writer = new common.PacketWriter();
-        writer.writeLengthCodedBuffer(filledBuffer(Math.pow(2, 24), '.'));
+        writer.writeLengthCodedBuffer(Buffer.alloc(Math.pow(2, 24), '.'));
         this._socket.write(writer.toBuffer(this._parser));
 
         this._sendPacket(new common.Packets.EofPacket());
@@ -73,13 +74,3 @@ server.on('connection', function(conn) {
     }
   });
 });
-
-function filledBuffer(size, fill) {
-  if (Buffer.alloc) {
-    return Buffer.alloc(size, fill);
-  }
-
-  var buf = new Buffer(size);
-  buf.fill(fill);
-  return buf;
-}

test/unit/protocol/test-Parser.js

@@ -1,10 +1,11 @@
+var Buffer = require('safe-buffer').Buffer;
 var common = require('../../common');
 var test   = require('utest');
 var assert = require('assert');
 var Parser = common.Parser;
 
 function packet(bytes) {
-  var buffer = new Buffer(bytes);
+  var buffer = Buffer.from(bytes);
   var parser = new Parser();
 
   parser.append(buffer);
@@ -14,17 +15,16 @@ function packet(bytes) {
 
 test('Parser', {
   "parseBuffer: buffer won\'t change after appending another one": function() {
-    var startBuffer = new Buffer(5);
-    startBuffer.fill('a');
+    var startBuffer = Buffer.alloc(5, 'a');
+    var parser      = new Parser();
 
-    var parser = new Parser();
     parser.append(startBuffer);
 
     var value = parser.parseBuffer(4);
 
     assert.equal(value.toString(), 'aaaa');
 
-    parser.append(new Buffer('b'));
+    parser.append(Buffer.from('b'));
 
     assert.equal(value.toString(), 'aaaa');
   },