Initial work on the server

node_modules/mysql/lib/protocol/packets/ClientAuthenticationPacket.js

@@ -0,0 +1,32 @@
+module.exports = ClientAuthenticationPacket;
+function ClientAuthenticationPacket(options) {
+  options = options || {};
+
+  this.clientFlags   = options.clientFlags;
+  this.maxPacketSize = options.maxPacketSize;
+  this.charsetNumber = options.charsetNumber;
+  this.filler        = undefined;
+  this.user          = options.user;
+  this.scrambleBuff  = options.scrambleBuff;
+  this.database      = options.database;
+}
+
+ClientAuthenticationPacket.prototype.parse = function(parser) {
+  this.clientFlags   = parser.parseUnsignedNumber(4);
+  this.maxPacketSize = parser.parseUnsignedNumber(4);
+  this.charsetNumber = parser.parseUnsignedNumber(1);
+  this.filler        = parser.parseFiller(23);
+  this.user          = parser.parseNullTerminatedString();
+  this.scrambleBuff  = parser.parseLengthCodedBuffer();
+  this.database      = parser.parseNullTerminatedString();
+};
+
+ClientAuthenticationPacket.prototype.write = function(writer) {
+  writer.writeUnsignedNumber(4, this.clientFlags);
+  writer.writeUnsignedNumber(4, this.maxPacketSize);
+  writer.writeUnsignedNumber(1, this.charsetNumber);
+  writer.writeFiller(23);
+  writer.writeNullTerminatedString(this.user);
+  writer.writeLengthCodedBuffer(this.scrambleBuff);
+  writer.writeNullTerminatedString(this.database);
+};

node_modules/mysql/lib/protocol/packets/ComChangeUserPacket.js

@@ -0,0 +1,25 @@
+module.exports = ComChangeUserPacket;
+function ComChangeUserPacket(options) {
+  options = options || {};
+
+  this.command       = 0x11;
+  this.user          = options.user;
+  this.scrambleBuff  = options.scrambleBuff;
+  this.database      = options.database;
+  this.charsetNumber = options.charsetNumber;
+}
+
+ComChangeUserPacket.prototype.parse = function(parser) {
+  this.user          = parser.parseNullTerminatedString();
+  this.scrambleBuff  = parser.parseLengthCodedBuffer();
+  this.database      = parser.parseNullTerminatedString();
+  this.charsetNumber = parser.parseUnsignedNumber(1);
+};
+
+ComChangeUserPacket.prototype.write = function(writer) {
+  writer.writeUnsignedNumber(1, this.command);
+  writer.writeNullTerminatedString(this.user);
+  writer.writeLengthCodedBuffer(this.scrambleBuff);
+  writer.writeNullTerminatedString(this.database);
+  writer.writeUnsignedNumber(1, this.charsetNumber);
+};

node_modules/mysql/lib/protocol/packets/ComPingPacket.js

@@ -0,0 +1,12 @@
+module.exports = ComPingPacket;
+function ComPingPacket(sql) {
+  this.command = 0x0e;
+}
+
+ComPingPacket.prototype.write = function(writer) {
+  writer.writeUnsignedNumber(1, this.command);
+};
+
+ComPingPacket.prototype.parse = function(parser) {
+  this.command = parser.parseUnsignedNumber(1);
+};

node_modules/mysql/lib/protocol/packets/ComQueryPacket.js

@@ -0,0 +1,15 @@
+module.exports = ComQueryPacket;
+function ComQueryPacket(sql) {
+  this.command = 0x03;
+  this.sql     = sql;
+}
+
+ComQueryPacket.prototype.write = function(writer) {
+  writer.writeUnsignedNumber(1, this.command);
+  writer.writeString(this.sql);
+};
+
+ComQueryPacket.prototype.parse = function(parser) {
+  this.command = parser.parseUnsignedNumber(1);
+  this.sql     = parser.parsePacketTerminatedString();
+};

node_modules/mysql/lib/protocol/packets/ComQuitPacket.js

@@ -0,0 +1,7 @@
+module.exports = ComQuitPacket;
+function ComQuitPacket(sql) {
+}
+
+ComQuitPacket.prototype.write = function(writer) {
+  writer.writeUnsignedNumber(1, 0x01);
+};

node_modules/mysql/lib/protocol/packets/ComStatisticsPacket.js

@@ -0,0 +1,12 @@
+module.exports = ComStatisticsPacket;
+function ComStatisticsPacket(sql) {
+  this.command = 0x09;
+}
+
+ComStatisticsPacket.prototype.write = function(writer) {
+  writer.writeUnsignedNumber(1, this.command);
+};
+
+ComStatisticsPacket.prototype.parse = function(parser) {
+  this.command = parser.parseUnsignedNumber(1);
+};

node_modules/mysql/lib/protocol/packets/EmptyPacket.js

@@ -0,0 +1,6 @@
+module.exports = EmptyPacket;
+function EmptyPacket() {
+}
+
+EmptyPacket.prototype.write = function(writer) {
+};

node_modules/mysql/lib/protocol/packets/EofPacket.js

@@ -0,0 +1,20 @@
+module.exports = EofPacket;
+function EofPacket(options) {
+  options = options || {};
+
+  this.fieldCount   = undefined;
+  this.warningCount = options.warningCount;
+  this.serverStatus = options.serverStatus;
+}
+
+EofPacket.prototype.parse = function(parser) {
+  this.fieldCount   = parser.parseUnsignedNumber(1);
+  this.warningCount = parser.parseUnsignedNumber(2);
+  this.serverStatus = parser.parseUnsignedNumber(2);
+};
+
+EofPacket.prototype.write = function(writer) {
+  writer.writeUnsignedNumber(1, 0xfe);
+  writer.writeUnsignedNumber(2, this.warningCount);
+  writer.writeUnsignedNumber(2, this.serverStatus);
+};

node_modules/mysql/lib/protocol/packets/ErrorPacket.js

@@ -0,0 +1,35 @@
+module.exports = ErrorPacket;
+function ErrorPacket(options) {
+  options = options || {};
+
+  this.fieldCount     = options.fieldCount;
+  this.errno          = options.errno;
+  this.sqlStateMarker = options.sqlStateMarker;
+  this.sqlState       = options.sqlState;
+  this.message        = options.message;
+}
+
+ErrorPacket.prototype.parse = function(parser) {
+  this.fieldCount = parser.parseUnsignedNumber(1);
+  this.errno      = parser.parseUnsignedNumber(2);
+
+  // sqlStateMarker ('#' = 0x23) indicates error packet format
+  if (parser.peak() === 0x23) {
+    this.sqlStateMarker = parser.parseString(1);
+    this.sqlState       = parser.parseString(5);
+  }
+
+  this.message = parser.parsePacketTerminatedString();
+};
+
+ErrorPacket.prototype.write = function(writer) {
+  writer.writeUnsignedNumber(1, 0xff);
+  writer.writeUnsignedNumber(2, this.errno);
+
+  if (this.sqlStateMarker) {
+    writer.writeString(this.sqlStateMarker);
+    writer.writeString(this.sqlState);
+  }
+
+  writer.writeString(this.message);
+};

node_modules/mysql/lib/protocol/packets/Field.js

@@ -0,0 +1,31 @@
+var Types = require('../constants/types');
+
+module.exports = Field;
+function Field(options) {
+  options = options || {};
+
+  this.parser = options.parser;
+  this.db     = options.packet.db;
+  this.table  = options.packet.table;
+  this.name   = options.packet.name;
+  this.type   = typeToString(options.packet.type);
+  this.length = options.packet.length;
+}
+
+Field.prototype.string = function () {
+  return this.parser.parseLengthCodedString();
+};
+
+Field.prototype.buffer = function () {
+  return this.parser.parseLengthCodedBuffer();
+};
+
+Field.prototype.geometry = function () {
+  return this.parser.parseGeometryValue();
+};
+
+function typeToString(t) {
+  for (var k in Types) {
+    if (Types[k] == t) return k;
+  }
+}

node_modules/mysql/lib/protocol/packets/FieldPacket.js

@@ -0,0 +1,65 @@
+module.exports = FieldPacket;
+function FieldPacket(options) {
+  options = options || {};
+
+  this.catalog   = options.catalog;
+  this.db        = options.db;
+  this.table     = options.table;
+  this.orgTable  = options.orgTable;
+  this.name      = options.name;
+  this.orgName   = options.orgName;
+  this.filler1   = undefined;
+  this.charsetNr = options.charsetNr;
+  this.length    = options.length;
+  this.type      = options.type;
+  this.flags     = options.flags;
+  this.decimals  = options.decimals;
+  this.filler2   = undefined;
+  this.default   = options.default;
+  this.zeroFill  = options.zeroFill;
+}
+
+FieldPacket.prototype.parse = function(parser) {
+  this.catalog     = parser.parseLengthCodedString();
+  this.db          = parser.parseLengthCodedString();
+  this.table       = parser.parseLengthCodedString();
+  this.orgTable    = parser.parseLengthCodedString();
+  this.name        = parser.parseLengthCodedString();
+  this.orgName     = parser.parseLengthCodedString();
+  this.filler1     = parser.parseFiller(1);
+  this.charsetNr   = parser.parseUnsignedNumber(2);
+  this.fieldLength = parser.parseUnsignedNumber(4);
+  this.type        = parser.parseUnsignedNumber(1);
+  this.flags       = parser.parseUnsignedNumber(2);
+  this.decimals    = parser.parseUnsignedNumber(1);
+  this.filler2     = parser.parseFiller(2);
+
+  // parsed flags
+  this.zeroFill    = (this.flags & 0x0040 ? true : false);
+
+  if (parser.reachedPacketEnd()) {
+    return;
+  }
+
+  this.default = parser.parseLengthCodedNumber();
+};
+
+FieldPacket.prototype.write = function(writer) {
+  writer.writeLengthCodedString(this.catalog);
+  writer.writeLengthCodedString(this.db);
+  writer.writeLengthCodedString(this.table);
+  writer.writeLengthCodedString(this.orgTable);
+  writer.writeLengthCodedString(this.name);
+  writer.writeLengthCodedString(this.orgName);
+  writer.writeFiller(1);
+  writer.writeUnsignedNumber(2, this.charsetNr || 0);
+  writer.writeUnsignedNumber(4, this.fieldLength || 0);
+  writer.writeUnsignedNumber(1, this.type) || 0;
+  writer.writeUnsignedNumber(2, this.flags || 0);
+  writer.writeUnsignedNumber(1, this.decimals || 0);
+  writer.writeFiller(2);
+
+  if (this.default !== undefined) {
+    writer.writeLengthCodedString(this.default);
+  }
+};

node_modules/mysql/lib/protocol/packets/HandshakeInitializationPacket.js

@@ -0,0 +1,81 @@
+module.exports = HandshakeInitializationPacket;
+function HandshakeInitializationPacket(options) {
+  options = options || {};
+
+  this.protocolVersion     = options.protocolVersion;
+  this.serverVersion       = options.serverVersion;
+  this.threadId            = options.threadId;
+  this.scrambleBuff1       = options.scrambleBuff1;
+  this.filler1             = options.filler1;
+  this.serverCapabilities1 = options.serverCapabilities1;
+  this.serverLanguage      = options.serverLanguage;
+  this.serverStatus        = options.serverStatus;
+  this.serverCapabilities2 = options.serverCapabilities2;
+  this.scrambleLength      = options.scrambleLength;
+  this.filler2             = options.filler2;
+  this.scrambleBuff2       = options.scrambleBuff2;
+  this.filler3             = options.filler3;
+  this.pluginData          = options.pluginData;
+}
+
+HandshakeInitializationPacket.prototype.parse = function(parser) {
+  this.protocolVersion     = parser.parseUnsignedNumber(1);
+  this.serverVersion       = parser.parseNullTerminatedString();
+  this.threadId            = parser.parseUnsignedNumber(4);
+  this.scrambleBuff1       = parser.parseBuffer(8);
+  this.filler1             = parser.parseFiller(1);
+  this.serverCapabilities1 = parser.parseUnsignedNumber(2);
+  this.serverLanguage      = parser.parseUnsignedNumber(1);
+  this.serverStatus        = parser.parseUnsignedNumber(2);
+  this.serverCapabilities2 = parser.parseUnsignedNumber(2);
+  this.scrambleLength      = parser.parseUnsignedNumber(1);
+  this.filler2             = parser.parseFiller(10);
+
+  // scrambleBuff2 should be 0x00 terminated, but sphinx does not do this
+  // so we assume scrambleBuff2 to be 12 byte and treat the next byte as a
+  // filler byte.
+  this.scrambleBuff2       = parser.parseBuffer(12);
+  this.filler3             = parser.parseFiller(1);
+
+  if (parser.reachedPacketEnd()) {
+    return;
+  }
+
+  // According to the docs this should be 0x00 terminated, but MariaDB does
+  // not do this, so we assume this string to be packet terminated.
+  this.pluginData = parser.parsePacketTerminatedString();
+
+  // However, if there is a trailing '\0', strip it
+  var lastChar = this.pluginData.length - 1;
+  if (this.pluginData[lastChar] === '\0') {
+    this.pluginData = this.pluginData.substr(0, lastChar);
+  }
+};
+
+HandshakeInitializationPacket.prototype.write = function(writer) {
+  writer.writeUnsignedNumber(1, this.protocolVersion);
+  writer.writeNullTerminatedString(this.serverVersion);
+  writer.writeUnsignedNumber(4, this.threadId);
+  writer.writeBuffer(this.scrambleBuff1);
+  writer.writeFiller(1);
+  writer.writeUnsignedNumber(2, this.serverCapabilities1);
+  writer.writeUnsignedNumber(1, this.serverLanguage);
+  writer.writeUnsignedNumber(2, this.serverStatus);
+  writer.writeUnsignedNumber(2, this.serverCapabilities2);
+  writer.writeUnsignedNumber(1, this.scrambleLength);
+  writer.writeFiller(10);
+  writer.writeNullTerminatedBuffer(this.scrambleBuff2);
+
+  if (this.pluginData !== undefined) {
+    writer.writeNullTerminatedString(this.pluginData);
+  }
+};
+
+HandshakeInitializationPacket.prototype.scrambleBuff = function() {
+  var buffer = new Buffer(this.scrambleBuff1.length + this.scrambleBuff2.length);
+
+  this.scrambleBuff1.copy(buffer);
+  this.scrambleBuff2.copy(buffer, this.scrambleBuff1.length);
+
+  return buffer;
+};

node_modules/mysql/lib/protocol/packets/LocalDataFilePacket.js

@@ -0,0 +1,8 @@
+module.exports = LocalDataFilePacket;
+function LocalDataFilePacket(data) {
+  this.data = data;
+}
+
+LocalDataFilePacket.prototype.write = function(writer) {
+  writer.writeString(this.data);
+};

node_modules/mysql/lib/protocol/packets/OkPacket.js

@@ -0,0 +1,34 @@
+module.exports = OkPacket;
+function OkPacket() {
+  this.fieldCount   = undefined;
+  this.affectedRows = undefined;
+  this.insertId     = undefined;
+  this.serverStatus = undefined;
+  this.warningCount = undefined;
+  this.message      = undefined;
+}
+
+OkPacket.prototype.parse = function(parser) {
+  this.fieldCount   = parser.parseUnsignedNumber(1);
+  this.affectedRows = parser.parseLengthCodedNumber();
+  this.insertId     = parser.parseLengthCodedNumber();
+  this.serverStatus = parser.parseUnsignedNumber(2);
+  this.warningCount = parser.parseUnsignedNumber(2);
+  this.message      = parser.parsePacketTerminatedString();
+  this.changedRows  = 0;
+
+  var m = this.message.match(/\schanged:\s*(\d+)/i);
+
+  if (m !== null) {
+    this.changedRows = parseInt(m[1], 10);
+  }
+};
+
+OkPacket.prototype.write = function(writer) {
+  writer.writeUnsignedNumber(1, 0x00);
+  writer.writeLengthCodedNumber(this.affectedRows || 0);
+  writer.writeLengthCodedNumber(this.insertId || 0);
+  writer.writeUnsignedNumber(2, this.serverStatus || 0);
+  writer.writeUnsignedNumber(2, this.warningCount || 0);
+  writer.writeString(this.message);
+};

node_modules/mysql/lib/protocol/packets/OldPasswordPacket.js

@@ -0,0 +1,15 @@
+module.exports = OldPasswordPacket;
+function OldPasswordPacket(options) {
+  options = options || {};
+
+  this.scrambleBuff = options.scrambleBuff;
+}
+
+OldPasswordPacket.prototype.parse = function(parser) {
+  this.scrambleBuff = parser.parseNullTerminatedBuffer();
+};
+
+OldPasswordPacket.prototype.write = function(writer) {
+  writer.writeBuffer(this.scrambleBuff);
+  writer.writeFiller(1);
+};

node_modules/mysql/lib/protocol/packets/ResultSetHeaderPacket.js

@@ -0,0 +1,25 @@
+module.exports = ResultSetHeaderPacket;
+function ResultSetHeaderPacket(options) {
+  options = options || {};
+
+  this.fieldCount = options.fieldCount;
+  this.extra      = options.extra;
+}
+
+ResultSetHeaderPacket.prototype.parse = function(parser) {
+  this.fieldCount = parser.parseLengthCodedNumber();
+
+  if (parser.reachedPacketEnd()) return;
+
+  this.extra = (this.fieldCount === null)
+    ? parser.parsePacketTerminatedString()
+    : parser.parseLengthCodedNumber();
+};
+
+ResultSetHeaderPacket.prototype.write = function(writer) {
+  writer.writeLengthCodedNumber(this.fieldCount);
+
+  if (this.extra !== undefined) {
+    writer.writeLengthCodedNumber(this.extra);
+  }
+};

node_modules/mysql/lib/protocol/packets/RowDataPacket.js

@@ -0,0 +1,92 @@
+var Types                        = require('../constants/types');
+var Charsets                     = require('../constants/charsets');
+var Field                        = require('./Field');
+var IEEE_754_BINARY_64_PRECISION = Math.pow(2, 53);
+
+module.exports = RowDataPacket;
+function RowDataPacket() {
+}
+
+RowDataPacket.prototype.parse = function(parser, fieldPackets, typeCast, nestTables, connection) {
+  var self = this;
+  var next = function () {
+    return self._typeCast(fieldPacket, parser, connection.config.timezone, connection.config.supportBigNumbers);
+  };
+
+  for (var i = 0; i < fieldPackets.length; i++) {
+    var fieldPacket = fieldPackets[i];
+    var value;
+
+    if (typeof typeCast == "function") {
+      value = typeCast.apply(connection, [ new Field({ packet: fieldPacket, parser: parser }), next ]);
+    } else {
+      value = (typeCast)
+        ? this._typeCast(fieldPacket, parser, connection.config.timezone, connection.config.supportBigNumbers)
+        : ( (fieldPacket.charsetNr === Charsets.BINARY)
+          ? parser.parseLengthCodedBuffer()
+          : parser.parseLengthCodedString() );
+    }
+
+    if (typeof nestTables == "string" && nestTables.length) {
+      this[fieldPacket.table + nestTables + fieldPacket.name] = value;
+    } else if (nestTables) {
+      this[fieldPacket.table] = this[fieldPacket.table] || {};
+      this[fieldPacket.table][fieldPacket.name] = value;
+    } else {
+      this[fieldPacket.name] = value;
+    }
+  }
+};
+
+RowDataPacket.prototype._typeCast = function(field, parser, timeZone, supportBigNumbers) {
+  switch (field.type) {
+    case Types.TIMESTAMP:
+    case Types.DATE:
+    case Types.DATETIME:
+    case Types.NEWDATE:
+      var dateString = parser.parseLengthCodedString();
+      if (dateString === null) {
+        return null;
+      }
+
+      if (timeZone != 'local') {
+        if (field.type === Types.DATE) {
+          dateString += ' 00:00:00 ' + timeZone;
+        } else {
+          dateString += timeZone;
+        }
+      }
+
+      return new Date(dateString);
+    case Types.TINY:
+    case Types.SHORT:
+    case Types.LONG:
+    case Types.INT24:
+    case Types.YEAR:
+    case Types.FLOAT:
+    case Types.DOUBLE:
+    case Types.LONGLONG:
+    case Types.NEWDECIMAL:
+      var numberString = parser.parseLengthCodedString();
+      return (numberString === null || (field.zeroFill && numberString[0] == "0"))
+        ? numberString
+        : ((supportBigNumbers && Number(numberString) > IEEE_754_BINARY_64_PRECISION)
+          ? numberString
+          : Number(numberString));
+    case Types.BIT:
+      return parser.parseLengthCodedBuffer();
+    case Types.STRING:
+    case Types.VAR_STRING:
+    case Types.TINY_BLOB:
+    case Types.MEDIUM_BLOB:
+    case Types.LONG_BLOB:
+    case Types.BLOB:
+      return (field.charsetNr === Charsets.BINARY)
+        ? parser.parseLengthCodedBuffer()
+        : parser.parseLengthCodedString();
+    case Types.GEOMETRY:
+      return parser.parseGeometryValue();
+    default:
+      return parser.parseLengthCodedString();
+  }
+};

node_modules/mysql/lib/protocol/packets/StatisticsPacket.js

@@ -0,0 +1,20 @@
+module.exports = StatisticsPacket;
+function StatisticsPacket() {
+  this.message      = undefined;
+}
+
+StatisticsPacket.prototype.parse = function(parser) {
+  this.message      = parser.parsePacketTerminatedString();
+
+  var items = this.message.split(/\s\s/);
+  for (var i = 0; i < items.length; i++) {
+    var m = items[i].match(/^(.+)\:\s+(.+)$/);
+    if (m !== null) {
+      this[m[1].toLowerCase().replace(/\s/g, '_')] = Number(m[2]);
+    }
+  }
+};
+
+StatisticsPacket.prototype.write = function(writer) {
+  writer.writeString(this.message);
+};

node_modules/mysql/lib/protocol/packets/UseOldPasswordPacket.js

@@ -0,0 +1,14 @@
+module.exports = UseOldPasswordPacket;
+function UseOldPasswordPacket(options) {
+  options = options || {};
+
+  this.firstByte = options.firstByte || 0xfe;
+}
+
+UseOldPasswordPacket.prototype.parse = function(parser) {
+  this.firstByte = parser.parseUnsignedNumber(1);
+};
+
+UseOldPasswordPacket.prototype.write = function(writer) {
+  writer.writeUnsignedNumber(1, this.firstByte);
+};

node_modules/mysql/lib/protocol/packets/index.js

@@ -0,0 +1,4 @@
+var Elements = module.exports = require('require-all')({
+  dirname : __dirname,
+  filter  : /([A-Z].+)\.js$/,
+});