onsaliyo/DiscofyAPI
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

API inicial

Browse Source
This commit is contained in:
onsaliyo
2021-03-25 17:23:36 +01:00
commit 218326c402
1878 changed files with 274122 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

276
node_modules/mariadb/lib/cmd/batch-bulk.js generated vendored Normal file
View File

@@ -0,0 +1,276 @@
'use strict';
const CommonBinary = require('./common-binary-cmd');
const Errors = require('../misc/errors');
const Parse = require('../misc/parse');
const BulkPacket = require('../io/bulk-packet');
/**
* Protocol COM_STMT_BULK_EXECUTE
* see : https://mariadb.com/kb/en/library/com_stmt_bulk_execute/
*/
class BatchBulk extends CommonBinary {
constructor(resolve, reject, options, connOpts, sql, values) {
super(resolve, reject, options, connOpts, sql, values);
this.onPacketReceive = this.readPrepareResultPacket;
}
/**
* Send COM_STMT_BULK_EXECUTE
*
* @param out output writer
* @param opts connection options
* @param info connection information
*/
start(out, opts, info) {
this.sending = true;
this.info = info;
this.values = this.initialValues;
if (this.opts.timeout) {
const err = Errors.createError(
'Cannot use timeout for Batch statement',
false,
info,
'HY000',
Errors.ER_TIMEOUT_NOT_SUPPORTED
);
this.emit('send_end');
this.throwError(err, info);
return;
}
let questionMarkSql = this.sql;
if (this.opts.namedPlaceholders) {
const res = Parse.searchPlaceholder(
this.sql,
info,
this.initialValues,
this.displaySql.bind(this)
);
questionMarkSql = res.sql;
this.values = res.values;
}
if (!this.validateParameters(info)) {
this.sending = false;
return;
}
//send COM_STMT_PREPARE command
this.out = out;
this.packet = new BulkPacket(this.opts, out, this.values[0]);
out.startPacket(this);
out.writeInt8(0x16);
out.writeString(questionMarkSql);
out.flushBuffer(true);
if (this.opts.pipelining) {
out.startPacket(this);
this.valueIdx = 0;
this.sendQueries();
} else {
this.out = out;
}
}
sendQueries() {
let flushed = false;
while (!flushed && this.sending && this.valueIdx < this.values.length) {
this.valueRow = this.values[this.valueIdx++];
//********************************************
// send params
//********************************************
const len = this.valueRow.length;
for (let i = 0; i < len; i++) {
const value = this.valueRow[i];
if (value === null) {
flushed = this.packet.writeInt8(0x01) || flushed;
continue;
}
//********************************************
// param has no stream. directly write in buffer
//********************************************
flushed = this.writeParam(this.packet, value, this.opts, this.info) || flushed;
}
const last = this.valueIdx === this.values.length;
flushed = this.packet.mark(last, last ? null : this.values[this.valueIdx]) || flushed;
}
if (this.valueIdx < this.values.length && !this.packet.haveErrorResponse) {
//there is still data to send
setImmediate(this.sendQueries.bind(this));
} else {
if (this.sending && this.valueIdx === this.values.length) this.emit('send_end');
this.sending = false;
}
}
displaySql() {
if (this.opts && this.initialValues) {
if (this.sql.length > this.opts.debugLen) {
return 'sql: ' + this.sql.substring(0, this.opts.debugLen) + '...';
}
let sqlMsg = 'sql: ' + this.sql + ' - parameters:';
sqlMsg += '[';
for (let i = 0; i < this.initialValues.length; i++) {
if (i !== 0) sqlMsg += ',';
let param = this.initialValues[i];
sqlMsg = this.logParameters(sqlMsg, param);
if (sqlMsg.length > this.opts.debugLen) {
sqlMsg = sqlMsg.substr(0, this.opts.debugLen) + '...';
break;
}
}
sqlMsg += ']';
return sqlMsg;
}
return 'sql: ' + this.sql + ' - parameters:[]';
}
success(val) {
this.packet.waitingResponseNo--;
if (!this.opts.pipelining && this.packet.statementId === -1) {
this.packet.statementId = this.statementId;
this.out.startPacket(this);
this.valueIdx = 0;
this.sendQueries();
this._responseIndex++;
this.onPacketReceive = this.readResponsePacket;
return;
}
if (!this.sending && this.packet.waitingResponseNo === 0) {
//send COM_STMT_CLOSE packet
if (!this.firstError || !this.firstError.fatal) {
this.sequenceNo = -1;
this.compressSequenceNo = -1;
this.out.startPacket(this);
this.out.writeInt8(0x19);
this.out.writeInt32(this.statementId);
this.out.flushBuffer(true);
}
this.sending = false;
this.emit('send_end');
if (this.packet.haveErrorResponse) {
this.packet = null;
this.resolve = null;
this.onPacketReceive = null;
this._columns = null;
this._rows = null;
process.nextTick(this.reject, this.firstError);
this.reject = null;
this.emit('end', this.firstError);
} else {
this.packet = null;
let totalAffectedRows = 0;
this._rows.forEach((row) => {
totalAffectedRows += row.affectedRows;
});
const rs = {
affectedRows: totalAffectedRows,
insertId: this._rows[0].insertId,
warningStatus: this._rows[this._rows.length - 1].warningStatus
};
this.successEnd(rs);
this._columns = null;
this._rows = null;
}
return;
}
if (!this.packet.haveErrorResponse) {
this._responseIndex++;
this.onPacketReceive = this.readResponsePacket;
}
}
throwError(err, info) {
this.packet.waitingResponseNo--;
this.sending = false;
if (this.packet && !this.packet.haveErrorResponse) {
if (err.fatal) {
this.packet.waitingResponseNo = 0;
}
if (this.stack) {
err = Errors.createError(
err.message,
err.fatal,
info,
err.sqlState,
err.errno,
this.stack,
false
);
}
this.firstError = err;
this.packet.endedWithError();
}
if (!this.sending && this.packet.waitingResponseNo === 0) {
this.resolve = null;
//send COM_STMT_CLOSE packet
if (!err.fatal && this.statementId) {
this.sequenceNo = -1;
this.compressSequenceNo = -1;
this.out.startPacket(this);
this.out.writeInt8(0x19);
this.out.writeInt32(this.statementId);
this.out.flushBuffer(true);
}
this.emit('send_end');
process.nextTick(this.reject, this.firstError);
this.reject = null;
this.onPacketReceive = null;
this.emit('end', this.firstError);
} else {
this._responseIndex++;
this.onPacketReceive = this.readResponsePacket;
}
}
/**
* Validate that parameters exists and are defined.
*
* @param info connection info
* @returns {boolean} return false if any error occur.
*/
validateParameters(info) {
//validate parameter size.
for (let r = 0; r < this.values.length; r++) {
if (!Array.isArray(this.values[r])) this.values[r] = [this.values[r]];
//validate parameter is defined.
for (let i = 0; i < this.values[r].length; i++) {
if (this.values[r][i] === undefined) {
this.emit('send_end');
this.throwNewError(
'Parameter at position ' +
(i + 1) +
' is undefined for values ' +
r +
'\n' +
this.displaySql(),
false,
info,
'HY000',
Errors.ER_PARAMETER_UNDEFINED
);
return false;
}
}
}
return true;
}
}
module.exports = BatchBulk;

370
node_modules/mariadb/lib/cmd/batch-rewrite.js generated vendored Normal file
View File

@@ -0,0 +1,370 @@
'use strict';
const CommonText = require('./common-text-cmd');
const Errors = require('../misc/errors');
const Parse = require('../misc/parse');
const RewritePacket = require('../io/rewrite-packet');
const QUOTE = 0x27;
/**
* Protocol COM_QUERY
* see : https://mariadb.com/kb/en/library/com_query/
*/
class BatchRewrite extends CommonText {
constructor(resolve, reject, options, connOpts, sql, values) {
super(resolve, reject, options, connOpts, sql, values);
}
/**
* Send COM_QUERY
*
* @param out output writer
* @param opts connection options
* @param info connection information
*/
start(out, opts, info) {
this.sending = true;
this.info = info;
if (this.opts.timeout) {
const err = Errors.createError(
'Cannot use timeout for Batch statement',
false,
info,
'HY000',
Errors.ER_TIMEOUT_NOT_SUPPORTED
);
this.emit('send_end');
this.throwError(err, info);
return;
}
if (this.initialValues.length === 0) this.initialValues = [[]];
if (this.opts.namedPlaceholders) {
this.parseResults = Parse.splitRewritableNamedParameterQuery(this.sql, this.initialValues);
this.values = this.parseResults.values;
} else {
this.parseResults = Parse.splitRewritableQuery(this.sql);
this.values = this.initialValues;
if (!this.validateParameters(info)) {
this.sending = false;
return;
}
}
out.startPacket(this);
this.packet = new RewritePacket(
this.opts.maxAllowedPacket,
out,
this.parseResults.partList[0],
this.parseResults.partList[this.parseResults.partList.length - 1]
);
this.onPacketReceive = this.readResponsePacket;
this.valueIdx = 0;
this.sendQueries();
}
sendQueries() {
let flushed = false;
while (!flushed && this.sending && this.valueIdx < this.values.length) {
this.valueRow = this.values[this.valueIdx++];
//********************************************
// send params
//********************************************
const len = this.parseResults.partList.length - 3;
for (let i = 0; i < len; i++) {
const value = this.valueRow[i];
flushed = this.packet.writeString(this.parseResults.partList[i + 1]) || flushed;
if (value === null) {
flushed = this.packet.writeStringAscii('NULL') || flushed;
continue;
}
if (
typeof value === 'object' &&
typeof value.pipe === 'function' &&
typeof value.read === 'function'
) {
//********************************************
// param is stream,
// now all params will be written by event
//********************************************
this.registerStreamSendEvent(this.packet, this.info);
this.currentParam = i;
this.packet.writeInt8(QUOTE); //'
value.on(
'data',
function (chunk) {
this.packet.writeBufferEscape(chunk);
}.bind(this)
);
value.on(
'end',
function () {
this.packet.writeInt8(QUOTE); //'
this.currentParam++;
this.paramWritten();
}.bind(this)
);
return;
} else {
//********************************************
// param isn't stream. directly write in buffer
//********************************************
flushed = this.writeParam(this.packet, value, this.opts, this.info) || flushed;
}
}
this.packet.writeString(this.parseResults.partList[this.parseResults.partList.length - 2]);
this.packet.mark(!this.parseResults.reWritable || this.valueIdx === this.values.length);
}
if (this.valueIdx < this.values.length && !this.packet.haveErrorResponse) {
//there is still data to send
setImmediate(this.sendQueries.bind(this));
} else {
if (this.sending && this.valueIdx === this.values.length) this.emit('send_end');
this.sending = false;
}
}
displaySql() {
if (this.opts && this.initialValues) {
if (this.sql.length > this.opts.debugLen) {
return 'sql: ' + this.sql.substring(0, this.opts.debugLen) + '...';
}
let sqlMsg = 'sql: ' + this.sql + ' - parameters:';
sqlMsg += '[';
for (let i = 0; i < this.initialValues.length; i++) {
if (i !== 0) sqlMsg += ',';
let param = this.initialValues[i];
sqlMsg = this.logParameters(sqlMsg, param);
if (sqlMsg.length > this.opts.debugLen) {
sqlMsg = sqlMsg.substr(0, this.opts.debugLen) + '...';
break;
}
}
sqlMsg += ']';
return sqlMsg;
}
return 'sql: ' + this.sql + ' - parameters:[]';
}
success(val) {
this.packet.waitingResponseNo--;
if (this.packet.haveErrorResponse) {
if (!this.sending && this.packet.waitingResponseNo === 0) {
this.packet = null;
this.onPacketReceive = null;
this.resolve = null;
this._columns = null;
this._rows = null;
process.nextTick(this.reject, this.firstError);
this.reject = null;
this.emit('end', this.firstError);
}
} else {
if (!this.sending && this.packet.waitingResponseNo === 0) {
if (this.parseResults.reWritable) {
this.packet = null;
let totalAffectedRows = 0;
this._rows.forEach((row) => {
totalAffectedRows += row.affectedRows;
});
const rs = {
affectedRows: totalAffectedRows,
insertId: this._rows[0].insertId,
warningStatus: this._rows[this._rows.length - 1].warningStatus
};
this.successEnd(rs);
return;
} else {
this.successEnd(this._rows);
}
this._columns = null;
this._rows = null;
return;
}
this._responseIndex++;
this.onPacketReceive = this.readResponsePacket;
}
}
throwError(err, info) {
this.packet.waitingResponseNo--;
this.sending = false;
if (this.packet && !this.packet.haveErrorResponse) {
if (err.fatal) {
this.packet.waitingResponseNo = 0;
}
if (this.stack) {
err = Errors.createError(
err.message,
err.fatal,
info,
err.sqlState,
err.errno,
this.stack,
false
);
}
this.firstError = err;
this.packet.endedWithError();
}
if (!this.sending && this.packet.waitingResponseNo === 0) {
this.packet = null;
this.onPacketReceive = null;
this.resolve = null;
process.nextTick(this.reject, this.firstError);
this.reject = null;
this.emit('end', this.firstError);
} else {
this._responseIndex++;
this.onPacketReceive = this.readResponsePacket;
}
}
/**
* Validate that parameters exists and are defined.
*
* @param info connection info
* @returns {boolean} return false if any error occur.
*/
validateParameters(info) {
//validate parameter size.
for (let r = 0; r < this.values.length; r++) {
let val = this.values[r];
if (!Array.isArray(val)) {
val = [val];
this.values[r] = val;
}
if (this.parseResults.partList.length - 3 > val.length) {
this.emit('send_end');
this.throwNewError(
'Parameter at position ' +
val.length +
' is not set for values ' +
r +
'\n' +
this.displaySql(),
false,
info,
'HY000',
Errors.ER_MISSING_PARAMETER
);
return false;
}
//validate parameter is defined.
for (let i = 0; i < this.parseResults.partList.length - 3; i++) {
if (val[i] === undefined) {
this.emit('send_end');
this.throwNewError(
'Parameter at position ' +
(i + 1) +
' is undefined for values ' +
r +
'\n' +
this.displaySql(),
false,
info,
'HY000',
Errors.ER_PARAMETER_UNDEFINED
);
return false;
}
}
}
return true;
}
/**
* Define params events.
* Each parameter indicate that he is written to socket,
* emitting event so next parameter can be written.
*/
registerStreamSendEvent(packet, info) {
this.paramWritten = function () {
let flushed = false;
while (!flushed) {
if (this.packet.haveErrorResponse) {
this.sending = false;
this.emit('send_end');
return;
}
if (this.currentParam === this.valueRow.length) {
// all parameters from row are written.
flushed =
packet.writeString(this.parseResults.partList[this.parseResults.partList.length - 2]) ||
flushed;
flushed =
packet.mark(!this.parseResults.reWritable || this.valueIdx === this.values.length) ||
flushed;
if (this.valueIdx < this.values.length) {
// still remaining rows
this.valueRow = this.values[this.valueIdx++];
this.currentParam = 0;
} else {
// all rows are written
this.sending = false;
this.emit('send_end');
return;
}
}
flushed = packet.writeString(this.parseResults.partList[this.currentParam + 1]) || flushed;
const value = this.valueRow[this.currentParam];
if (value === null) {
flushed = packet.writeStringAscii('NULL') || flushed;
this.currentParam++;
continue;
}
if (
typeof value === 'object' &&
typeof value.pipe === 'function' &&
typeof value.read === 'function'
) {
//********************************************
// param is stream,
//********************************************
flushed = packet.writeInt8(QUOTE) || flushed;
value.once(
'end',
function () {
packet.writeInt8(QUOTE);
this.currentParam++;
this.paramWritten();
}.bind(this)
);
value.on('data', function (chunk) {
packet.writeBufferEscape(chunk);
});
return;
}
//********************************************
// param isn't stream. directly write in buffer
//********************************************
flushed = this.writeParam(packet, value, this.opts, info) || flushed;
this.currentParam++;
}
if (this.sending) setImmediate(this.paramWritten.bind(this));
}.bind(this);
}
}
module.exports = BatchRewrite;

149
node_modules/mariadb/lib/cmd/change-user.js generated vendored Normal file
View File

@@ -0,0 +1,149 @@
'use strict';
const Iconv = require('iconv-lite');
const Capabilities = require('../const/capabilities');
const Ed25519PasswordAuth = require('./handshake/auth/ed25519-password-auth');
const NativePasswordAuth = require('./handshake/auth/native-password-auth');
const Collations = require('../const/collations');
const Handshake = require('./handshake/handshake');
/**
* send a COM_CHANGE_USER: resets the connection and re-authenticates with the given credentials
* see https://mariadb.com/kb/en/library/com_change_user/
*/
class ChangeUser extends Handshake {
constructor(options, resolve, reject, addCommand) {
super(resolve, reject, () => {}, addCommand);
this.opts = options;
}
start(out, opts, info) {
this.configAssign(opts, this.opts);
let authToken;
const pwd = Array.isArray(this.opts.password) ? this.opts.password[0] : this.opts.password;
switch (info.defaultPluginName) {
case 'mysql_native_password':
case '':
authToken = NativePasswordAuth.encryptPassword(pwd, info.seed, 'sha1');
break;
case 'client_ed25519':
authToken = Ed25519PasswordAuth.encryptPassword(pwd, info.seed);
break;
default:
authToken = Buffer.alloc(0);
break;
}
out.startPacket(this);
out.writeInt8(0x11);
out.writeString(this.opts.user || '');
out.writeInt8(0);
if (info.serverCapabilities & Capabilities.SECURE_CONNECTION) {
out.writeInt8(authToken.length);
out.writeBuffer(authToken, 0, authToken.length);
} else {
out.writeBuffer(authToken, 0, authToken.length);
out.writeInt8(0);
}
if (info.clientCapabilities & Capabilities.CONNECT_WITH_DB) {
out.writeString(this.opts.database);
out.writeInt8(0);
info.database = this.opts.database;
}
out.writeInt16(this.opts.collation.index);
if (info.clientCapabilities & Capabilities.PLUGIN_AUTH) {
out.writeString(info.defaultPluginName);
out.writeInt8(0);
}
if (info.clientCapabilities & Capabilities.CONNECT_ATTRS) {
out.writeInt8(0xfc);
let initPos = out.pos; //save position, assuming connection attributes length will be less than 2 bytes length
out.writeInt16(0);
const encoding = this.opts.collation.charset;
writeParam(out, '_client_name', encoding);
writeParam(out, 'MariaDB connector/Node', encoding);
let packageJson = require('../../package.json');
writeParam(out, '_client_version', encoding);
writeParam(out, packageJson.version, encoding);
writeParam(out, '_node_version', encoding);
writeParam(out, process.versions.node, encoding);
if (opts.connectAttributes !== true) {
let attrNames = Object.keys(this.opts.connectAttributes);
for (let k = 0; k < attrNames.length; ++k) {
writeParam(out, attrNames[k], encoding);
writeParam(out, this.opts.connectAttributes[attrNames[k]], encoding);
}
}
//write end size
out.writeInt16AtPos(initPos);
}
out.flushBuffer(true);
this.onPacketReceive = this.handshakeResult;
}
/**
* Assign global configuration option used by result-set to current query option.
* a little faster than Object.assign() since doest copy all information
*
* @param connOpts connection global configuration
* @param opt current options
*/
configAssign(connOpts, opt) {
if (!opt) {
this.opts = connOpts;
return;
}
this.opts.database = opt.database ? opt.database : connOpts.database;
this.opts.connectAttributes = opt.connectAttributes
? opt.connectAttributes
: connOpts.connectAttributes;
if (opt.charset && typeof opt.charset === 'string') {
this.opts.collation = Collations.fromCharset(opt.charset.toLowerCase());
if (this.opts.collation === undefined) {
this.opts.collation = Collations.fromName(opt.charset.toUpperCase());
if (this.opts.collation !== undefined) {
console.log(
"warning: please use option 'collation' " +
"in replacement of 'charset' when using a collation name ('" +
opt.charset +
"')\n" +
"(collation looks like 'UTF8MB4_UNICODE_CI', charset like 'utf8')."
);
}
}
if (this.opts.collation === undefined)
throw new RangeError("Unknown charset '" + opt.charset + "'");
} else if (opt.collation && typeof opt.collation === 'string') {
const initial = opt.collation;
this.opts.collation = Collations.fromName(initial.toUpperCase());
if (this.opts.collation === undefined)
throw new RangeError("Unknown collation '" + initial + "'");
} else {
this.opts.collation = Collations.fromIndex(opt.charsetNumber) || connOpts.collation;
}
connOpts.password = opt.password;
}
}
function writeParam(out, val, encoding) {
let param = Buffer.isEncoding(encoding)
? Buffer.from(val, encoding)
: Iconv.encode(val, encoding);
out.writeLengthCoded(param.length);
out.writeBuffer(param, 0, param.length);
}
module.exports = ChangeUser;

17
node_modules/mariadb/lib/cmd/class/ok-packet.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
'use strict';
const Command = require('../command');
/**
* Ok_Packet
* see https://mariadb.com/kb/en/ok_packet/
*/
class OkPacket {
constructor(affectedRows, insertId, warningStatus) {
this.affectedRows = affectedRows;
this.insertId = insertId;
this.warningStatus = warningStatus;
}
}
module.exports = OkPacket;

102
node_modules/mariadb/lib/cmd/column-definition.js generated vendored Normal file
View File

@@ -0,0 +1,102 @@
'use strict';
const Collations = require('../const/collations.js');
const FieldType = require('../const/field-type');
const Capabilities = require('../const/capabilities');
/**
* Column definition
* see https://mariadb.com/kb/en/library/resultset/#column-definition-packet
*/
class ColumnDef {
constructor(packet, info) {
this._parse = new StringParser(packet);
if (info.serverCapabilities & Capabilities.MARIADB_CLIENT_EXTENDED_TYPE_INFO) {
const subPacket = packet.subPacketLengthEncoded();
while (subPacket.remaining()) {
switch (subPacket.readUInt8()) {
case 0:
this.dataTypeName = subPacket.readAsciiStringLengthEncoded();
break;
case 1:
this.dataTypeFormat = subPacket.readAsciiStringLengthEncoded();
break;
default:
// skip data
const len = subPacket.readUnsignedLength();
if (len) {
subPacket.skip(len);
}
break;
}
}
}
packet.skip(1); // length of fixed fields
this.collation = Collations.fromIndex(packet.readUInt16());
this.columnLength = packet.readUInt32();
this.columnType = packet.readUInt8();
this.flags = packet.readUInt16();
this.scale = packet.readUInt8();
this.type = FieldType.TYPES[this.columnType];
}
db() {
return this._parse.packet.readString(this._parse.dbOffset, this._parse.dbLength);
}
schema() {
return this._parse.packet.readString(this._parse.dbOffset, this._parse.dbLength);
}
table() {
return this._parse.packet.readString(this._parse.tableOffset, this._parse.tableLength);
}
orgTable() {
return this._parse.packet.readString(this._parse.orgTableOffset, this._parse.orgTableLength);
}
name() {
return this._parse.packet.readString(this._parse.nameOffset, this._parse.nameLength);
}
orgName() {
return this._parse.packet.readString(this._parse.orgNameOffset, this._parse.orgNameLength);
}
}
/**
* String parser.
* This object permits to avoid listing all private information to metadata object.
*/
class StringParser {
constructor(packet) {
packet.skip(4); // skip 'def'
this.dbLength = packet.readUnsignedLength();
this.dbOffset = packet.pos;
packet.skip(this.dbLength);
this.tableLength = packet.readUnsignedLength();
this.tableOffset = packet.pos;
packet.skip(this.tableLength);
this.orgTableLength = packet.readUnsignedLength();
this.orgTableOffset = packet.pos;
packet.skip(this.orgTableLength);
this.nameLength = packet.readUnsignedLength();
this.nameOffset = packet.pos;
packet.skip(this.nameLength);
this.orgNameLength = packet.readUnsignedLength();
this.orgNameOffset = packet.pos;
packet.skip(this.orgNameLength);
this.packet = packet;
}
}
module.exports = ColumnDef;

165
node_modules/mariadb/lib/cmd/command.js generated vendored Normal file
View File

@@ -0,0 +1,165 @@
'use strict';
const EventEmitter = require('events');
const Errors = require('../misc/errors');
const ServerStatus = require('../const/server-status');
const StateChange = require('../const/state-change');
const Collations = require('../const/collations');
const OkPacket = require('./class/ok-packet');
/**
* Default command interface.
*/
class Command extends EventEmitter {
constructor(resolve, reject) {
super();
this.sequenceNo = -1;
this.compressSequenceNo = -1;
this.resolve = resolve;
this.reject = reject;
this.sending = false;
}
displaySql() {}
/**
* Throw an an unexpected error.
* server exchange will still be read to keep connection in a good state, but promise will be rejected.
*
* @param msg message
* @param fatal is error fatal for connection
* @param info current server state information
* @param sqlState error sqlState
* @param errno error number
*/
throwUnexpectedError(msg, fatal, info, sqlState, errno) {
if (this.reject) {
process.nextTick(
this.reject,
Errors.createError(msg, fatal, info, sqlState, errno, this.stack, false)
);
this.resolve = null;
this.reject = null;
}
}
/**
* Create and throw new Error from error information
* only first called throwing an error or successfully end will be executed.
*
* @param msg message
* @param fatal is error fatal for connection
* @param info current server state information
* @param sqlState error sqlState
* @param errno error number
*/
throwNewError(msg, fatal, info, sqlState, errno) {
this.onPacketReceive = null;
if (this.reject) {
process.nextTick(
this.reject,
Errors.createError(msg, fatal, info, sqlState, errno, this.stack, false)
);
this.resolve = null;
this.reject = null;
}
this.emit('end');
}
/**
* Throw Error
* only first called throwing an error or successfully end will be executed.
*
* @param err error to be thrown
* @param info current server state information
*/
throwError(err, info) {
this.onPacketReceive = null;
if (this.reject) {
if (this.stack) {
err = Errors.createError(
err.message,
err.fatal,
info,
err.sqlState,
err.errno,
this.stack,
false
);
}
this.resolve = null;
process.nextTick(this.reject, err);
this.reject = null;
}
this.emit('end', err);
}
/**
* Successfully end command.
* only first called throwing an error or successfully end will be executed.
*
* @param val return value.
*/
successEnd(val) {
this.onPacketReceive = null;
if (this.resolve) {
this.reject = null;
process.nextTick(this.resolve, val);
this.resolve = null;
}
this.emit('end');
}
static parseOkPacket(packet, out, opts, info) {
packet.skip(1); //skip header
const affectedRows = packet.readUnsignedLength();
const insertId = opts.supportBigInt
? packet.readSignedLengthBigInt()
: packet.readSignedLength();
info.status = packet.readUInt16();
const okPacket = new OkPacket(affectedRows, insertId, packet.readUInt16());
if (info.status & ServerStatus.SESSION_STATE_CHANGED) {
packet.skipLengthCodedNumber();
while (packet.remaining()) {
const subPacket = packet.subPacketLengthEncoded();
while (subPacket.remaining()) {
const type = subPacket.readUInt8();
switch (type) {
case StateChange.SESSION_TRACK_SYSTEM_VARIABLES:
const subSubPacket = subPacket.subPacketLengthEncoded();
const variable = subSubPacket.readStringLength();
const value = subSubPacket.readStringLength();
switch (variable) {
case 'character_set_client':
opts.collation = Collations.fromCharset(value);
if (opts.collation === undefined) {
this.throwError(new Error("unknown charset : '" + value + "'"), info);
return;
}
opts.emit('collation', opts.collation);
break;
default:
//variable not used by driver
}
break;
case StateChange.SESSION_TRACK_SCHEMA:
const subSubPacket2 = subPacket.subPacketLengthEncoded();
info.database = subSubPacket2.readStringLength();
break;
}
}
}
}
return okPacket;
}
}
module.exports = Command;

327
node_modules/mariadb/lib/cmd/common-binary-cmd.js generated vendored Normal file
View File

@@ -0,0 +1,327 @@
'use strict';
const ResultSet = require('./resultset');
class CommonBinary extends ResultSet {
constructor(resolve, reject, cmdOpts, connOpts, sql, values) {
super(resolve, reject);
this.configAssign(connOpts, cmdOpts);
this.sql = sql;
this.initialValues = values;
}
/**
* Write (and escape) current parameter value to output writer
*
* @param out output writer
* @param value current parameter
* @param opts connection options
* @param info connection information
*/
writeParam(out, value, opts, info) {
let flushed = false;
switch (typeof value) {
case 'boolean':
flushed = out.writeInt8(0x00);
flushed = out.writeInt8(value ? 0x01 : 0x00) || flushed;
break;
case 'bigint':
case 'number':
flushed = out.writeInt8(0x00);
flushed = out.writeLengthStringAscii('' + value) || flushed;
break;
case 'object':
if (Object.prototype.toString.call(value) === '[object Date]') {
flushed = out.writeInt8(0x00);
flushed = out.writeBinaryDate(value, opts) || flushed;
} else if (Buffer.isBuffer(value)) {
flushed = out.writeInt8(0x00);
flushed = out.writeLengthEncodedBuffer(value) || flushed;
} else if (typeof value.toSqlString === 'function') {
flushed = out.writeInt8(0x00);
flushed = out.writeLengthEncodedString(String(value.toSqlString())) || flushed;
} else {
if (
value.type != null &&
[
'Point',
'LineString',
'Polygon',
'MultiPoint',
'MultiLineString',
'MultiPolygon',
'GeometryCollection'
].includes(value.type)
) {
const geoBuff = this.getBufferFromGeometryValue(value);
if (geoBuff) {
flushed = out.writeInt8(0x00); //Value follow
flushed =
out.writeLengthEncodedBuffer(Buffer.concat([Buffer.from([0, 0, 0, 0]), geoBuff])) ||
flushed;
} else {
flushed = out.writeInt8(0x01); //NULL
}
} else {
//TODO check if permitSetMultiParamEntries is needed !?
flushed = out.writeInt8(0x00);
flushed = out.writeLengthEncodedString(JSON.stringify(value)) || flushed;
}
}
break;
default:
flushed = out.writeInt8(0x00);
flushed = out.writeLengthEncodedString(value) || flushed;
}
return flushed;
}
getBufferFromGeometryValue(value, headerType) {
let geoBuff;
let pos;
let type;
if (!headerType) {
switch (value.type) {
case 'Point':
geoBuff = Buffer.allocUnsafe(21);
geoBuff.writeInt8(0x01, 0); //LITTLE ENDIAN
geoBuff.writeInt32LE(1, 1); //wkbPoint
if (
value.coordinates &&
Array.isArray(value.coordinates) &&
value.coordinates.length >= 2 &&
!isNaN(value.coordinates[0]) &&
!isNaN(value.coordinates[1])
) {
geoBuff.writeDoubleLE(value.coordinates[0], 5); //X
geoBuff.writeDoubleLE(value.coordinates[1], 13); //Y
return geoBuff;
} else {
return null;
}
case 'LineString':
if (value.coordinates && Array.isArray(value.coordinates)) {
const pointNumber = value.coordinates.length;
geoBuff = Buffer.allocUnsafe(9 + 16 * pointNumber);
geoBuff.writeInt8(0x01, 0); //LITTLE ENDIAN
geoBuff.writeInt32LE(2, 1); //wkbLineString
geoBuff.writeInt32LE(pointNumber, 5);
for (let i = 0; i < pointNumber; i++) {
if (
value.coordinates[i] &&
Array.isArray(value.coordinates[i]) &&
value.coordinates[i].length >= 2 &&
!isNaN(value.coordinates[i][0]) &&
!isNaN(value.coordinates[i][1])
) {
geoBuff.writeDoubleLE(value.coordinates[i][0], 9 + 16 * i); //X
geoBuff.writeDoubleLE(value.coordinates[i][1], 17 + 16 * i); //Y
} else {
return null;
}
}
return geoBuff;
} else {
return null;
}
case 'Polygon':
if (value.coordinates && Array.isArray(value.coordinates)) {
const numRings = value.coordinates.length;
let size = 0;
for (let i = 0; i < numRings; i++) {
size += 4 + 16 * value.coordinates[i].length;
}
geoBuff = Buffer.allocUnsafe(9 + size);
geoBuff.writeInt8(0x01, 0); //LITTLE ENDIAN
geoBuff.writeInt32LE(3, 1); //wkbPolygon
geoBuff.writeInt32LE(numRings, 5);
pos = 9;
for (let i = 0; i < numRings; i++) {
const lineString = value.coordinates[i];
if (lineString && Array.isArray(lineString)) {
geoBuff.writeInt32LE(lineString.length, pos);
pos += 4;
for (let j = 0; j < lineString.length; j++) {
if (
lineString[j] &&
Array.isArray(lineString[j]) &&
lineString[j].length >= 2 &&
!isNaN(lineString[j][0]) &&
!isNaN(lineString[j][1])
) {
geoBuff.writeDoubleLE(lineString[j][0], pos); //X
geoBuff.writeDoubleLE(lineString[j][1], pos + 8); //Y
pos += 16;
} else {
return null;
}
}
}
}
return geoBuff;
} else {
return null;
}
case 'MultiPoint':
type = 'MultiPoint';
geoBuff = Buffer.allocUnsafe(9);
geoBuff.writeInt8(0x01, 0); //LITTLE ENDIAN
geoBuff.writeInt32LE(4, 1); //wkbMultiPoint
break;
case 'MultiLineString':
type = 'MultiLineString';
geoBuff = Buffer.allocUnsafe(9);
geoBuff.writeInt8(0x01, 0); //LITTLE ENDIAN
geoBuff.writeInt32LE(5, 1); //wkbMultiLineString
break;
case 'MultiPolygon':
type = 'MultiPolygon';
geoBuff = Buffer.allocUnsafe(9);
geoBuff.writeInt8(0x01, 0); //LITTLE ENDIAN
geoBuff.writeInt32LE(6, 1); //wkbMultiPolygon
break;
case 'GeometryCollection':
geoBuff = Buffer.allocUnsafe(9);
geoBuff.writeInt8(0x01, 0); //LITTLE ENDIAN
geoBuff.writeInt32LE(7, 1); //wkbGeometryCollection
if (value.geometries && Array.isArray(value.geometries)) {
const coordinateLength = value.geometries.length;
const subArrays = [geoBuff];
for (let i = 0; i < coordinateLength; i++) {
const tmpBuf = this.getBufferFromGeometryValue(value.geometries[i]);
if (tmpBuf == null) break;
subArrays.push(tmpBuf);
}
geoBuff.writeInt32LE(subArrays.length - 1, 5);
return Buffer.concat(subArrays);
} else {
geoBuff.writeInt32LE(0, 5);
return geoBuff;
}
default:
return null;
}
if (value.coordinates && Array.isArray(value.coordinates)) {
const coordinateLength = value.coordinates.length;
const subArrays = [geoBuff];
for (let i = 0; i < coordinateLength; i++) {
const tmpBuf = this.getBufferFromGeometryValue(value.coordinates[i], type);
if (tmpBuf == null) break;
subArrays.push(tmpBuf);
}
geoBuff.writeInt32LE(subArrays.length - 1, 5);
return Buffer.concat(subArrays);
} else {
geoBuff.writeInt32LE(0, 5);
return geoBuff;
}
} else {
switch (headerType) {
case 'MultiPoint':
if (
value &&
Array.isArray(value) &&
value.length >= 2 &&
!isNaN(value[0]) &&
!isNaN(value[1])
) {
geoBuff = Buffer.allocUnsafe(21);
geoBuff.writeInt8(0x01, 0); //LITTLE ENDIAN
geoBuff.writeInt32LE(1, 1); //wkbPoint
geoBuff.writeDoubleLE(value[0], 5); //X
geoBuff.writeDoubleLE(value[1], 13); //Y
return geoBuff;
}
return null;
case 'MultiLineString':
if (value && Array.isArray(value)) {
const pointNumber = value.length;
geoBuff = Buffer.allocUnsafe(9 + 16 * pointNumber);
geoBuff.writeInt8(0x01, 0); //LITTLE ENDIAN
geoBuff.writeInt32LE(2, 1); //wkbLineString
geoBuff.writeInt32LE(pointNumber, 5);
for (let i = 0; i < pointNumber; i++) {
if (
value[i] &&
Array.isArray(value[i]) &&
value[i].length >= 2 &&
!isNaN(value[i][0]) &&
!isNaN(value[i][1])
) {
geoBuff.writeDoubleLE(value[i][0], 9 + 16 * i); //X
geoBuff.writeDoubleLE(value[i][1], 17 + 16 * i); //Y
} else {
return null;
}
}
return geoBuff;
}
return null;
case 'MultiPolygon':
if (value && Array.isArray(value)) {
const numRings = value.length;
let size = 0;
for (let i = 0; i < numRings; i++) {
size += 4 + 16 * value[i].length;
}
geoBuff = Buffer.allocUnsafe(9 + size);
geoBuff.writeInt8(0x01, 0); //LITTLE ENDIAN
geoBuff.writeInt32LE(3, 1); //wkbPolygon
geoBuff.writeInt32LE(numRings, 5);
pos = 9;
for (let i = 0; i < numRings; i++) {
const lineString = value[i];
if (lineString && Array.isArray(lineString)) {
geoBuff.writeInt32LE(lineString.length, pos);
pos += 4;
for (let j = 0; j < lineString.length; j++) {
if (
lineString[j] &&
Array.isArray(lineString[j]) &&
lineString[j].length >= 2 &&
!isNaN(lineString[j][0]) &&
!isNaN(lineString[j][1])
) {
geoBuff.writeDoubleLE(lineString[j][0], pos); //X
geoBuff.writeDoubleLE(lineString[j][1], pos + 8); //Y
pos += 16;
} else {
return null;
}
}
}
}
return geoBuff;
}
return null;
}
return null;
}
}
/**
* Read text result-set row
*
* see: https://mariadb.com/kb/en/library/resultset-row/#text-resultset-row
* data are created according to their type.
*
* @param columns columns metadata
* @param packet current row packet
* @param connOpts connection options
* @returns {*} row data
*/
parseRow(columns, packet, connOpts) {
throw new Error('not implemented');
}
}
module.exports = CommonBinary;

427
node_modules/mariadb/lib/cmd/common-text-cmd.js generated vendored Normal file
View File

@@ -0,0 +1,427 @@
'use strict';
const ResultSet = require('./resultset');
const FieldDetail = require('../const/field-detail');
const FieldType = require('../const/field-type');
const Long = require('long');
const moment = require('moment-timezone');
const QUOTE = 0x27;
class CommonText extends ResultSet {
constructor(resolve, reject, cmdOpts, connOpts, sql, values) {
super(resolve, reject);
this.configAssign(connOpts, cmdOpts);
this.sql = sql;
this.initialValues = values;
this.getDateQuote = this.opts.tz
? this.opts.tz === 'Etc/UTC'
? CommonText.getUtcDate
: CommonText.getTimezoneDate
: CommonText.getLocalDate;
}
/**
* Write (and escape) current parameter value to output writer
*
* @param out output writer
* @param value current parameter
* @param opts connection options
* @param info connection information
*/
writeParam(out, value, opts, info) {
switch (typeof value) {
case 'boolean':
out.writeStringAscii(value ? 'true' : 'false');
break;
case 'bigint':
case 'number':
out.writeStringAscii('' + value);
break;
case 'object':
if (value === null) {
out.writeStringAscii('NULL');
} else if (Object.prototype.toString.call(value) === '[object Date]') {
out.writeStringAscii(this.getDateQuote(value, opts));
} else if (Buffer.isBuffer(value)) {
out.writeStringAscii("_BINARY '");
out.writeBufferEscape(value);
out.writeInt8(QUOTE);
} else if (typeof value.toSqlString === 'function') {
out.writeStringEscapeQuote(String(value.toSqlString()));
} else if (Long.isLong(value)) {
out.writeStringAscii(value.toString());
} else if (Array.isArray(value)) {
if (opts.arrayParenthesis) {
out.writeStringAscii('(');
}
for (let i = 0; i < value.length; i++) {
if (i !== 0) out.writeStringAscii(',');
this.writeParam(out, value[i], opts, info);
}
if (opts.arrayParenthesis) {
out.writeStringAscii(')');
}
} else {
if (
value.type != null &&
[
'Point',
'LineString',
'Polygon',
'MultiPoint',
'MultiLineString',
'MultiPolygon',
'GeometryCollection'
].includes(value.type)
) {
//GeoJSON format.
let prefix =
(info.isMariaDB() && info.hasMinVersion(10, 1, 4)) ||
(!info.isMariaDB() && info.hasMinVersion(5, 7, 6))
? 'ST_'
: '';
switch (value.type) {
case 'Point':
out.writeStringAscii(
prefix +
"PointFromText('POINT(" +
CommonText.geoPointToString(value.coordinates) +
")')"
);
break;
case 'LineString':
out.writeStringAscii(
prefix +
"LineFromText('LINESTRING(" +
CommonText.geoArrayPointToString(value.coordinates) +
")')"
);
break;
case 'Polygon':
out.writeStringAscii(
prefix +
"PolygonFromText('POLYGON(" +
CommonText.geoMultiArrayPointToString(value.coordinates) +
")')"
);
break;
case 'MultiPoint':
out.writeStringAscii(
prefix +
"MULTIPOINTFROMTEXT('MULTIPOINT(" +
CommonText.geoArrayPointToString(value.coordinates) +
")')"
);
break;
case 'MultiLineString':
out.writeStringAscii(
prefix +
"MLineFromText('MULTILINESTRING(" +
CommonText.geoMultiArrayPointToString(value.coordinates) +
")')"
);
break;
case 'MultiPolygon':
out.writeStringAscii(
prefix +
"MPolyFromText('MULTIPOLYGON(" +
CommonText.geoMultiPolygonToString(value.coordinates) +
")')"
);
break;
case 'GeometryCollection':
out.writeStringAscii(
prefix +
"GeomCollFromText('GEOMETRYCOLLECTION(" +
CommonText.geometricCollectionToString(value.geometries) +
")')"
);
break;
}
} else {
if (opts.permitSetMultiParamEntries) {
let first = true;
for (let key in value) {
const val = value[key];
if (typeof val === 'function') continue;
if (first) {
first = false;
} else {
out.writeStringAscii(',');
}
out.writeString('`' + key + '`');
out.writeStringAscii('=');
this.writeParam(out, val, opts, info);
}
if (first) out.writeStringEscapeQuote(JSON.stringify(value));
} else {
out.writeStringEscapeQuote(JSON.stringify(value));
}
}
}
break;
default:
out.writeStringEscapeQuote(value);
}
}
static geometricCollectionToString(geo) {
if (!geo) return '';
let st = '';
for (let i = 0; i < geo.length; i++) {
//GeoJSON format.
st += i !== 0 ? ',' : '';
switch (geo[i].type) {
case 'Point':
st += 'POINT(' + CommonText.geoPointToString(geo[i].coordinates) + ')';
break;
case 'LineString':
st += 'LINESTRING(' + CommonText.geoArrayPointToString(geo[i].coordinates) + ')';
break;
case 'Polygon':
st += 'POLYGON(' + CommonText.geoMultiArrayPointToString(geo[i].coordinates) + ')';
break;
case 'MultiPoint':
st += 'MULTIPOINT(' + CommonText.geoArrayPointToString(geo[i].coordinates) + ')';
break;
case 'MultiLineString':
st +=
'MULTILINESTRING(' + CommonText.geoMultiArrayPointToString(geo[i].coordinates) + ')';
break;
case 'MultiPolygon':
st += 'MULTIPOLYGON(' + CommonText.geoMultiPolygonToString(geo[i].coordinates) + ')';
break;
}
}
return st;
}
static geoMultiPolygonToString(coords) {
if (!coords) return '';
let st = '';
for (let i = 0; i < coords.length; i++) {
st += (i !== 0 ? ',(' : '(') + CommonText.geoMultiArrayPointToString(coords[i]) + ')';
}
return st;
}
static geoMultiArrayPointToString(coords) {
if (!coords) return '';
let st = '';
for (let i = 0; i < coords.length; i++) {
st += (i !== 0 ? ',(' : '(') + CommonText.geoArrayPointToString(coords[i]) + ')';
}
return st;
}
static geoArrayPointToString(coords) {
if (!coords) return '';
let st = '';
for (let i = 0; i < coords.length; i++) {
st += (i !== 0 ? ',' : '') + CommonText.geoPointToString(coords[i]);
}
return st;
}
static geoPointToString(coords) {
if (!coords) return '';
return (isNaN(coords[0]) ? '' : coords[0]) + ' ' + (isNaN(coords[1]) ? '' : coords[1]);
}
parseRowAsArray(columns, packet, connOpts) {
const row = new Array(this._columnCount);
for (let i = 0; i < this._columnCount; i++) {
row[i] = this._getValue(i, columns[i], this.opts, connOpts, packet);
}
return row;
}
parseRowNested(columns, packet, connOpts) {
const row = {};
for (let i = 0; i < this._columnCount; i++) {
if (!row[this.tableHeader[i][0]]) row[this.tableHeader[i][0]] = {};
row[this.tableHeader[i][0]][this.tableHeader[i][1]] = this._getValue(
i,
columns[i],
this.opts,
connOpts,
packet
);
}
return row;
}
parseRowStd(columns, packet, connOpts) {
const row = {};
for (let i = 0; i < this._columnCount; i++) {
row[this.tableHeader[i]] = this._getValue(i, columns[i], this.opts, connOpts, packet);
}
return row;
}
castTextWrapper(column, opts, connOpts, packet) {
column.string = () => packet.readStringLength();
column.buffer = () => packet.readBufferLengthEncoded();
column.float = () => packet.readFloatLengthCoded();
column.int = () => packet.readIntLengthEncoded();
column.long = () =>
packet.readLongLengthEncoded(
opts.supportBigInt,
opts.supportBigNumbers,
opts.bigNumberStrings,
(column.flags & FieldDetail.UNSIGNED) > 0
);
column.decimal = () => packet.readDecimalLengthEncoded(opts.bigNumberStrings);
column.date = () => packet.readDateTime(opts);
column.geometry = () => {
return column.readGeometry();
};
}
readCastValue(index, column, opts, connOpts, packet) {
this.castTextWrapper(column, opts, connOpts, packet);
return opts.typeCast(
column,
this.readRowData.bind(this, index, column, opts, connOpts, packet)
);
}
/**
* Read row data.
*
* @param index current data index in row
* @param column associate metadata
* @param opts query options
* @param connOpts connection options
* @param packet row packet
* @returns {*} data
*/
readRowData(index, column, opts, connOpts, packet) {
switch (column.columnType) {
case FieldType.TINY:
case FieldType.SHORT:
case FieldType.LONG:
case FieldType.INT24:
case FieldType.YEAR:
return packet.readIntLengthEncoded();
case FieldType.FLOAT:
case FieldType.DOUBLE:
return packet.readFloatLengthCoded();
case FieldType.LONGLONG:
return packet.readLongLengthEncoded(
opts.supportBigInt,
opts.supportBigNumbers,
opts.bigNumberStrings,
(column.flags & FieldDetail.UNSIGNED) > 0
);
case FieldType.DECIMAL:
case FieldType.NEWDECIMAL:
return packet.readDecimalLengthEncoded(opts.bigNumberStrings);
case FieldType.DATE:
if (opts.dateStrings) {
return packet.readAsciiStringLengthEncoded();
}
return packet.readDate();
case FieldType.DATETIME:
case FieldType.TIMESTAMP:
if (opts.dateStrings) {
return packet.readAsciiStringLengthEncoded();
}
return packet.readDateTime(opts);
case FieldType.TIME:
return packet.readAsciiStringLengthEncoded();
case FieldType.GEOMETRY:
return packet.readGeometry(column.dataTypeName);
case FieldType.JSON:
//for mysql only => parse string as JSON object
return JSON.parse(packet.readStringLengthEncoded('utf8'));
default:
if (column.dataTypeFormat && column.dataTypeFormat === 'json' && opts.autoJsonMap) {
return JSON.parse(packet.readStringLengthEncoded('utf8'));
}
if (column.collation.index === 63) {
return packet.readBufferLengthEncoded();
}
const string = packet.readStringLength();
if (column.flags & 2048) {
//SET
return string == null ? null : string === '' ? [] : string.split(',');
}
return string;
}
}
}
function getDatePartQuote(year, mon, day, hour, min, sec, ms) {
//return 'YYYY-MM-DD HH:MM:SS' datetime format
//see https://mariadb.com/kb/en/library/datetime/
return (
"'" +
(year > 999 ? year : year > 99 ? '0' + year : year > 9 ? '00' + year : '000' + year) +
'-' +
(mon < 10 ? '0' : '') +
mon +
'-' +
(day < 10 ? '0' : '') +
day +
' ' +
(hour < 10 ? '0' : '') +
hour +
':' +
(min < 10 ? '0' : '') +
min +
':' +
(sec < 10 ? '0' : '') +
sec +
'.' +
(ms > 99 ? ms : ms > 9 ? '0' + ms : '00' + ms) +
"'"
);
}
function getLocalDate(date, opts) {
const year = date.getFullYear();
const mon = date.getMonth() + 1;
const day = date.getDate();
const hour = date.getHours();
const min = date.getMinutes();
const sec = date.getSeconds();
const ms = date.getMilliseconds();
return getDatePartQuote(year, mon, day, hour, min, sec, ms);
}
function getUtcDate(date, opts) {
const year = date.getUTCFullYear();
const mon = date.getUTCMonth() + 1;
const day = date.getUTCDate();
const hour = date.getUTCHours();
const min = date.getUTCMinutes();
const sec = date.getUTCSeconds();
const ms = date.getUTCMilliseconds();
return getDatePartQuote(year, mon, day, hour, min, sec, ms);
}
function getTimezoneDate(date, opts) {
if (date.getMilliseconds() != 0) {
return moment.tz(date, opts.tz).format("'YYYY-MM-DD HH:mm:ss.SSS'");
}
return moment.tz(date, opts.tz).format("'YYYY-MM-DD HH:mm:ss'");
}
module.exports = CommonText;
module.exports.getTimezoneDate = getTimezoneDate;
module.exports.getUtcDate = getUtcDate;
module.exports.getLocalDate = getLocalDate;

167
node_modules/mariadb/lib/cmd/handshake/auth/caching-sha2-password-auth.js generated vendored Normal file
View File

@@ -0,0 +1,167 @@
const PluginAuth = require('./plugin-auth');
const fs = require('fs');
const crypto = require('crypto');
const Errors = require('../../../misc/errors');
const NativePasswordAuth = require('./native-password-auth');
const Sha256PasswordAuth = require('./sha256-password-auth');
const State = {
INIT: 'INIT',
FAST_AUTH_RESULT: 'FAST_AUTH_RESULT',
REQUEST_SERVER_KEY: 'REQUEST_SERVER_KEY',
SEND_AUTH: 'SEND_AUTH'
};
/**
* Use caching Sha2 password authentication
*/
class CachingSha2PasswordAuth extends PluginAuth {
constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
super(resolve, reject, multiAuthResolver);
this.pluginData = pluginData;
this.sequenceNo = packSeq;
this.counter = 0;
this.state = State.INIT;
}
start(out, opts, info) {
this.exchange(this.pluginData, out, opts, info);
this.onPacketReceive = this.response;
}
exchange(buffer, out, opts, info) {
switch (this.state) {
case State.INIT:
const truncatedSeed = this.pluginData.slice(0, this.pluginData.length - 1);
const encPwd = NativePasswordAuth.encryptPassword(opts.password, truncatedSeed, 'sha256');
out.startPacket(this);
if (encPwd.length > 0) {
out.writeBuffer(encPwd, 0, encPwd.length);
out.flushBuffer(true);
} else {
out.writeEmptyPacket(true);
}
this.state = State.FAST_AUTH_RESULT;
return;
case State.FAST_AUTH_RESULT:
// length encoded numeric : 0x01 0x03/0x04
const fastAuthResult = buffer[1];
switch (fastAuthResult) {
case 0x03:
// success authentication
this.emit('send_end');
return this.successSend(packet, out, opts, info);
case 0x04:
if (opts.ssl) {
// using SSL, so sending password in clear
out.startPacket(this);
out.writeString(opts.password);
out.writeInt8(0);
out.flushBuffer(true);
return;
}
// retrieve public key from configuration or from server
if (opts.cachingRsaPublicKey) {
try {
let key = opts.cachingRsaPublicKey;
if (!key.includes('-----BEGIN')) {
// rsaPublicKey contain path
key = fs.readFileSync(key, 'utf8');
}
this.publicKey = Sha256PasswordAuth.retreivePublicKey(key);
} catch (err) {
return this.throwError(err, info);
}
// send Sha256Password Packet
Sha256PasswordAuth.sendSha256PwdPacket(
this,
this.pluginData,
this.publicKey,
opts.password,
out
);
} else {
if (!opts.allowPublicKeyRetrieval) {
return this.throwError(
Errors.createError(
'RSA public key is not available client side. Either set option `cachingRsaPublicKey` to indicate' +
' public key path, or allow public key retrieval with option `allowPublicKeyRetrieval`',
true,
info,
'08S01',
Errors.ER_CANNOT_RETRIEVE_RSA_KEY
),
info
);
}
this.state = State.REQUEST_SERVER_KEY;
// ask caching public Key Retrieval
out.startPacket(this);
out.writeInt8(0x02);
out.flushBuffer(true);
}
return;
}
case State.REQUEST_SERVER_KEY:
this.publicKey = Sha256PasswordAuth.retreivePublicKey(buffer.toString('utf8', 1));
this.state = State.SEND_AUTH;
Sha256PasswordAuth.sendSha256PwdPacket(
this,
this.pluginData,
this.publicKey,
opts.password,
out
);
}
}
static retreivePublicKey(key) {
return key.replace('(-+BEGIN PUBLIC KEY-+\\r?\\n|\\n?-+END PUBLIC KEY-+\\r?\\n?)', '');
}
static sendSha256PwdPacket(cmd, pluginData, publicKey, password, out) {
const truncatedSeed = pluginData.slice(0, pluginData.length - 1);
out.startPacket(cmd);
const enc = Sha256PasswordAuth.encrypt(truncatedSeed, password, publicKey);
out.writeBuffer(enc, 0, enc.length);
out.flushBuffer(cmd);
}
// encrypt password with public key
static encrypt(seed, password, publicKey) {
const nullFinishedPwd = Buffer.from(password + '\0');
const xorBytes = Buffer.allocUnsafe(nullFinishedPwd.length);
const seedLength = seed.length;
for (let i = 0; i < xorBytes.length; i++) {
xorBytes[i] = nullFinishedPwd[i] ^ seed[i % seedLength];
}
return crypto.publicEncrypt(
{ key: publicKey, padding: crypto.constants.RSA_PKCS1_OAEP_PADDING },
xorBytes
);
}
response(packet, out, opts, info) {
const marker = packet.peek();
switch (marker) {
//*********************************************************************************************************
//* OK_Packet and Err_Packet ending packet
//*********************************************************************************************************
case 0x00:
case 0xff:
this.emit('send_end');
return this.successSend(packet, out, opts, info);
default:
let promptData = packet.readBufferRemaining();
this.exchange(promptData, out, opts, info);
this.onPacketReceive = this.response;
}
}
}
module.exports = CachingSha2PasswordAuth;

23
node_modules/mariadb/lib/cmd/handshake/auth/clear-password-auth.js generated vendored Normal file
View File

@@ -0,0 +1,23 @@
const PluginAuth = require('./plugin-auth');
/**
* Send password in clear.
* (used only when SSL is active)
*/
class ClearPasswordAuth extends PluginAuth {
constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
super(resolve, reject, multiAuthResolver);
this.sequenceNo = packSeq;
}
start(out, opts, info) {
out.startPacket(this);
if (opts.password) out.writeString(opts.password);
out.writeInt8(0);
out.flushBuffer(true);
this.emit('send_end');
this.onPacketReceive = this.successSend;
}
}
module.exports = ClearPasswordAuth;

833
node_modules/mariadb/lib/cmd/handshake/auth/ed25519-password-auth.js generated vendored Normal file
View File

@@ -0,0 +1,833 @@
'use strict';
const PluginAuth = require('./plugin-auth');
const Crypto = require('crypto');
/**
* Standard authentication plugin
*/
class Ed25519PasswordAuth extends PluginAuth {
constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
super(resolve, reject, multiAuthResolver);
this.pluginData = pluginData;
this.sequenceNo = packSeq;
}
start(out, opts, info) {
//seed is ended with a null byte value.
const data = this.pluginData;
const sign = Ed25519PasswordAuth.encryptPassword(opts.password, data);
out.startPacket(this);
out.writeBuffer(sign, 0, sign.length);
out.flushBuffer(true);
this.emit('send_end');
this.onPacketReceive = this.successSend;
}
static encryptPassword(password, seed) {
if (!password) return Buffer.alloc(0);
let i, j;
let p = [gf(), gf(), gf(), gf()];
const signedMsg = Buffer.alloc(96);
const bytePwd = Buffer.from(password);
let hash = Crypto.createHash('sha512');
const d = hash.update(bytePwd).digest();
d[0] &= 248;
d[31] &= 127;
d[31] |= 64;
for (i = 0; i < 32; i++) signedMsg[64 + i] = seed[i];
for (i = 0; i < 32; i++) signedMsg[32 + i] = d[32 + i];
hash = Crypto.createHash('sha512');
const r = hash.update(signedMsg.slice(32, 96)).digest();
reduce(r);
scalarbase(p, r);
pack(signedMsg, p);
p = [gf(), gf(), gf(), gf()];
scalarbase(p, d);
const tt = Buffer.alloc(32);
pack(tt, p);
for (i = 32; i < 64; i++) signedMsg[i] = tt[i - 32];
hash = Crypto.createHash('sha512');
const h = hash.update(signedMsg).digest();
reduce(h);
const x = new Float64Array(64);
for (i = 0; i < 64; i++) x[i] = 0;
for (i = 0; i < 32; i++) x[i] = r[i];
for (i = 0; i < 32; i++) {
for (j = 0; j < 32; j++) {
x[i + j] += h[i] * d[j];
}
}
modL(signedMsg.subarray(32), x);
return signedMsg.slice(0, 64);
}
}
/*******************************************************
*
* This plugin uses the following public domain tweetnacl-js code by Dmitry Chestnykh (from https://github.com/dchest/tweetnacl-js/blob/master/nacl-fast.js).
* tweetnacl cannot be used directly (secret key mandatory size is 32 in nacl + implementation differ : second scalarbase use hash of secret key, not secret key).
*
*******************************************************/
const gf = function (init) {
const r = new Float64Array(16);
if (init) for (let i = 0; i < init.length; i++) r[i] = init[i];
return r;
};
const gf0 = gf(),
gf1 = gf([1]),
D2 = gf([
0xf159,
0x26b2,
0x9b94,
0xebd6,
0xb156,
0x8283,
0x149a,
0x00e0,
0xd130,
0xeef3,
0x80f2,
0x198e,
0xfce7,
0x56df,
0xd9dc,
0x2406
]),
X = gf([
0xd51a,
0x8f25,
0x2d60,
0xc956,
0xa7b2,
0x9525,
0xc760,
0x692c,
0xdc5c,
0xfdd6,
0xe231,
0xc0a4,
0x53fe,
0xcd6e,
0x36d3,
0x2169
]),
Y = gf([
0x6658,
0x6666,
0x6666,
0x6666,
0x6666,
0x6666,
0x6666,
0x6666,
0x6666,
0x6666,
0x6666,
0x6666,
0x6666,
0x6666,
0x6666,
0x6666
]);
const L = new Float64Array([
0xed,
0xd3,
0xf5,
0x5c,
0x1a,
0x63,
0x12,
0x58,
0xd6,
0x9c,
0xf7,
0xa2,
0xde,
0xf9,
0xde,
0x14,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0x10
]);
function reduce(r) {
const x = new Float64Array(64);
let i;
for (i = 0; i < 64; i++) x[i] = r[i];
for (i = 0; i < 64; i++) r[i] = 0;
modL(r, x);
}
function modL(r, x) {
let carry, i, j, k;
for (i = 63; i >= 32; --i) {
carry = 0;
for (j = i - 32, k = i - 12; j < k; ++j) {
x[j] += carry - 16 * x[i] * L[j - (i - 32)];
carry = (x[j] + 128) >> 8;
x[j] -= carry * 256;
}
x[j] += carry;
x[i] = 0;
}
carry = 0;
for (j = 0; j < 32; j++) {
x[j] += carry - (x[31] >> 4) * L[j];
carry = x[j] >> 8;
x[j] &= 255;
}
for (j = 0; j < 32; j++) x[j] -= carry * L[j];
for (i = 0; i < 32; i++) {
x[i + 1] += x[i] >> 8;
r[i] = x[i] & 255;
}
}
function scalarbase(p, s) {
const q = [gf(), gf(), gf(), gf()];
set25519(q[0], X);
set25519(q[1], Y);
set25519(q[2], gf1);
M(q[3], X, Y);
scalarmult(p, q, s);
}
function set25519(r, a) {
for (let i = 0; i < 16; i++) r[i] = a[i] | 0;
}
function M(o, a, b) {
let v,
c,
t0 = 0,
t1 = 0,
t2 = 0,
t3 = 0,
t4 = 0,
t5 = 0,
t6 = 0,
t7 = 0,
t8 = 0,
t9 = 0,
t10 = 0,
t11 = 0,
t12 = 0,
t13 = 0,
t14 = 0,
t15 = 0,
t16 = 0,
t17 = 0,
t18 = 0,
t19 = 0,
t20 = 0,
t21 = 0,
t22 = 0,
t23 = 0,
t24 = 0,
t25 = 0,
t26 = 0,
t27 = 0,
t28 = 0,
t29 = 0,
t30 = 0;
const b0 = b[0],
b1 = b[1],
b2 = b[2],
b3 = b[3],
b4 = b[4],
b5 = b[5],
b6 = b[6],
b7 = b[7],
b8 = b[8],
b9 = b[9],
b10 = b[10],
b11 = b[11],
b12 = b[12],
b13 = b[13],
b14 = b[14],
b15 = b[15];
v = a[0];
t0 += v * b0;
t1 += v * b1;
t2 += v * b2;
t3 += v * b3;
t4 += v * b4;
t5 += v * b5;
t6 += v * b6;
t7 += v * b7;
t8 += v * b8;
t9 += v * b9;
t10 += v * b10;
t11 += v * b11;
t12 += v * b12;
t13 += v * b13;
t14 += v * b14;
t15 += v * b15;
v = a[1];
t1 += v * b0;
t2 += v * b1;
t3 += v * b2;
t4 += v * b3;
t5 += v * b4;
t6 += v * b5;
t7 += v * b6;
t8 += v * b7;
t9 += v * b8;
t10 += v * b9;
t11 += v * b10;
t12 += v * b11;
t13 += v * b12;
t14 += v * b13;
t15 += v * b14;
t16 += v * b15;
v = a[2];
t2 += v * b0;
t3 += v * b1;
t4 += v * b2;
t5 += v * b3;
t6 += v * b4;
t7 += v * b5;
t8 += v * b6;
t9 += v * b7;
t10 += v * b8;
t11 += v * b9;
t12 += v * b10;
t13 += v * b11;
t14 += v * b12;
t15 += v * b13;
t16 += v * b14;
t17 += v * b15;
v = a[3];
t3 += v * b0;
t4 += v * b1;
t5 += v * b2;
t6 += v * b3;
t7 += v * b4;
t8 += v * b5;
t9 += v * b6;
t10 += v * b7;
t11 += v * b8;
t12 += v * b9;
t13 += v * b10;
t14 += v * b11;
t15 += v * b12;
t16 += v * b13;
t17 += v * b14;
t18 += v * b15;
v = a[4];
t4 += v * b0;
t5 += v * b1;
t6 += v * b2;
t7 += v * b3;
t8 += v * b4;
t9 += v * b5;
t10 += v * b6;
t11 += v * b7;
t12 += v * b8;
t13 += v * b9;
t14 += v * b10;
t15 += v * b11;
t16 += v * b12;
t17 += v * b13;
t18 += v * b14;
t19 += v * b15;
v = a[5];
t5 += v * b0;
t6 += v * b1;
t7 += v * b2;
t8 += v * b3;
t9 += v * b4;
t10 += v * b5;
t11 += v * b6;
t12 += v * b7;
t13 += v * b8;
t14 += v * b9;
t15 += v * b10;
t16 += v * b11;
t17 += v * b12;
t18 += v * b13;
t19 += v * b14;
t20 += v * b15;
v = a[6];
t6 += v * b0;
t7 += v * b1;
t8 += v * b2;
t9 += v * b3;
t10 += v * b4;
t11 += v * b5;
t12 += v * b6;
t13 += v * b7;
t14 += v * b8;
t15 += v * b9;
t16 += v * b10;
t17 += v * b11;
t18 += v * b12;
t19 += v * b13;
t20 += v * b14;
t21 += v * b15;
v = a[7];
t7 += v * b0;
t8 += v * b1;
t9 += v * b2;
t10 += v * b3;
t11 += v * b4;
t12 += v * b5;
t13 += v * b6;
t14 += v * b7;
t15 += v * b8;
t16 += v * b9;
t17 += v * b10;
t18 += v * b11;
t19 += v * b12;
t20 += v * b13;
t21 += v * b14;
t22 += v * b15;
v = a[8];
t8 += v * b0;
t9 += v * b1;
t10 += v * b2;
t11 += v * b3;
t12 += v * b4;
t13 += v * b5;
t14 += v * b6;
t15 += v * b7;
t16 += v * b8;
t17 += v * b9;
t18 += v * b10;
t19 += v * b11;
t20 += v * b12;
t21 += v * b13;
t22 += v * b14;
t23 += v * b15;
v = a[9];
t9 += v * b0;
t10 += v * b1;
t11 += v * b2;
t12 += v * b3;
t13 += v * b4;
t14 += v * b5;
t15 += v * b6;
t16 += v * b7;
t17 += v * b8;
t18 += v * b9;
t19 += v * b10;
t20 += v * b11;
t21 += v * b12;
t22 += v * b13;
t23 += v * b14;
t24 += v * b15;
v = a[10];
t10 += v * b0;
t11 += v * b1;
t12 += v * b2;
t13 += v * b3;
t14 += v * b4;
t15 += v * b5;
t16 += v * b6;
t17 += v * b7;
t18 += v * b8;
t19 += v * b9;
t20 += v * b10;
t21 += v * b11;
t22 += v * b12;
t23 += v * b13;
t24 += v * b14;
t25 += v * b15;
v = a[11];
t11 += v * b0;
t12 += v * b1;
t13 += v * b2;
t14 += v * b3;
t15 += v * b4;
t16 += v * b5;
t17 += v * b6;
t18 += v * b7;
t19 += v * b8;
t20 += v * b9;
t21 += v * b10;
t22 += v * b11;
t23 += v * b12;
t24 += v * b13;
t25 += v * b14;
t26 += v * b15;
v = a[12];
t12 += v * b0;
t13 += v * b1;
t14 += v * b2;
t15 += v * b3;
t16 += v * b4;
t17 += v * b5;
t18 += v * b6;
t19 += v * b7;
t20 += v * b8;
t21 += v * b9;
t22 += v * b10;
t23 += v * b11;
t24 += v * b12;
t25 += v * b13;
t26 += v * b14;
t27 += v * b15;
v = a[13];
t13 += v * b0;
t14 += v * b1;
t15 += v * b2;
t16 += v * b3;
t17 += v * b4;
t18 += v * b5;
t19 += v * b6;
t20 += v * b7;
t21 += v * b8;
t22 += v * b9;
t23 += v * b10;
t24 += v * b11;
t25 += v * b12;
t26 += v * b13;
t27 += v * b14;
t28 += v * b15;
v = a[14];
t14 += v * b0;
t15 += v * b1;
t16 += v * b2;
t17 += v * b3;
t18 += v * b4;
t19 += v * b5;
t20 += v * b6;
t21 += v * b7;
t22 += v * b8;
t23 += v * b9;
t24 += v * b10;
t25 += v * b11;
t26 += v * b12;
t27 += v * b13;
t28 += v * b14;
t29 += v * b15;
v = a[15];
t15 += v * b0;
t16 += v * b1;
t17 += v * b2;
t18 += v * b3;
t19 += v * b4;
t20 += v * b5;
t21 += v * b6;
t22 += v * b7;
t23 += v * b8;
t24 += v * b9;
t25 += v * b10;
t26 += v * b11;
t27 += v * b12;
t28 += v * b13;
t29 += v * b14;
t30 += v * b15;
t0 += 38 * t16;
t1 += 38 * t17;
t2 += 38 * t18;
t3 += 38 * t19;
t4 += 38 * t20;
t5 += 38 * t21;
t6 += 38 * t22;
t7 += 38 * t23;
t8 += 38 * t24;
t9 += 38 * t25;
t10 += 38 * t26;
t11 += 38 * t27;
t12 += 38 * t28;
t13 += 38 * t29;
t14 += 38 * t30;
// t15 left as is
// first car
c = 1;
v = t0 + c + 65535;
c = Math.floor(v / 65536);
t0 = v - c * 65536;
v = t1 + c + 65535;
c = Math.floor(v / 65536);
t1 = v - c * 65536;
v = t2 + c + 65535;
c = Math.floor(v / 65536);
t2 = v - c * 65536;
v = t3 + c + 65535;
c = Math.floor(v / 65536);
t3 = v - c * 65536;
v = t4 + c + 65535;
c = Math.floor(v / 65536);
t4 = v - c * 65536;
v = t5 + c + 65535;
c = Math.floor(v / 65536);
t5 = v - c * 65536;
v = t6 + c + 65535;
c = Math.floor(v / 65536);
t6 = v - c * 65536;
v = t7 + c + 65535;
c = Math.floor(v / 65536);
t7 = v - c * 65536;
v = t8 + c + 65535;
c = Math.floor(v / 65536);
t8 = v - c * 65536;
v = t9 + c + 65535;
c = Math.floor(v / 65536);
t9 = v - c * 65536;
v = t10 + c + 65535;
c = Math.floor(v / 65536);
t10 = v - c * 65536;
v = t11 + c + 65535;
c = Math.floor(v / 65536);
t11 = v - c * 65536;
v = t12 + c + 65535;
c = Math.floor(v / 65536);
t12 = v - c * 65536;
v = t13 + c + 65535;
c = Math.floor(v / 65536);
t13 = v - c * 65536;
v = t14 + c + 65535;
c = Math.floor(v / 65536);
t14 = v - c * 65536;
v = t15 + c + 65535;
c = Math.floor(v / 65536);
t15 = v - c * 65536;
t0 += c - 1 + 37 * (c - 1);
// second car
c = 1;
v = t0 + c + 65535;
c = Math.floor(v / 65536);
t0 = v - c * 65536;
v = t1 + c + 65535;
c = Math.floor(v / 65536);
t1 = v - c * 65536;
v = t2 + c + 65535;
c = Math.floor(v / 65536);
t2 = v - c * 65536;
v = t3 + c + 65535;
c = Math.floor(v / 65536);
t3 = v - c * 65536;
v = t4 + c + 65535;
c = Math.floor(v / 65536);
t4 = v - c * 65536;
v = t5 + c + 65535;
c = Math.floor(v / 65536);
t5 = v - c * 65536;
v = t6 + c + 65535;
c = Math.floor(v / 65536);
t6 = v - c * 65536;
v = t7 + c + 65535;
c = Math.floor(v / 65536);
t7 = v - c * 65536;
v = t8 + c + 65535;
c = Math.floor(v / 65536);
t8 = v - c * 65536;
v = t9 + c + 65535;
c = Math.floor(v / 65536);
t9 = v - c * 65536;
v = t10 + c + 65535;
c = Math.floor(v / 65536);
t10 = v - c * 65536;
v = t11 + c + 65535;
c = Math.floor(v / 65536);
t11 = v - c * 65536;
v = t12 + c + 65535;
c = Math.floor(v / 65536);
t12 = v - c * 65536;
v = t13 + c + 65535;
c = Math.floor(v / 65536);
t13 = v - c * 65536;
v = t14 + c + 65535;
c = Math.floor(v / 65536);
t14 = v - c * 65536;
v = t15 + c + 65535;
c = Math.floor(v / 65536);
t15 = v - c * 65536;
t0 += c - 1 + 37 * (c - 1);
o[0] = t0;
o[1] = t1;
o[2] = t2;
o[3] = t3;
o[4] = t4;
o[5] = t5;
o[6] = t6;
o[7] = t7;
o[8] = t8;
o[9] = t9;
o[10] = t10;
o[11] = t11;
o[12] = t12;
o[13] = t13;
o[14] = t14;
o[15] = t15;
}
function scalarmult(p, q, s) {
let b, i;
set25519(p[0], gf0);
set25519(p[1], gf1);
set25519(p[2], gf1);
set25519(p[3], gf0);
for (i = 255; i >= 0; --i) {
b = (s[(i / 8) | 0] >> (i & 7)) & 1;
cswap(p, q, b);
add(q, p);
add(p, p);
cswap(p, q, b);
}
}
function pack(r, p) {
const tx = gf(),
ty = gf(),
zi = gf();
inv25519(zi, p[2]);
M(tx, p[0], zi);
M(ty, p[1], zi);
pack25519(r, ty);
r[31] ^= par25519(tx) << 7;
}
function inv25519(o, i) {
const c = gf();
let a;
for (a = 0; a < 16; a++) c[a] = i[a];
for (a = 253; a >= 0; a--) {
S(c, c);
if (a !== 2 && a !== 4) M(c, c, i);
}
for (a = 0; a < 16; a++) o[a] = c[a];
}
function S(o, a) {
M(o, a, a);
}
function par25519(a) {
const d = new Uint8Array(32);
pack25519(d, a);
return d[0] & 1;
}
function car25519(o) {
let i,
v,
c = 1;
for (i = 0; i < 16; i++) {
v = o[i] + c + 65535;
c = Math.floor(v / 65536);
o[i] = v - c * 65536;
}
o[0] += c - 1 + 37 * (c - 1);
}
function pack25519(o, n) {
let i, j, b;
const m = gf(),
t = gf();
for (i = 0; i < 16; i++) t[i] = n[i];
car25519(t);
car25519(t);
car25519(t);
for (j = 0; j < 2; j++) {
m[0] = t[0] - 0xffed;
for (i = 1; i < 15; i++) {
m[i] = t[i] - 0xffff - ((m[i - 1] >> 16) & 1);
m[i - 1] &= 0xffff;
}
m[15] = t[15] - 0x7fff - ((m[14] >> 16) & 1);
b = (m[15] >> 16) & 1;
m[14] &= 0xffff;
sel25519(t, m, 1 - b);
}
for (i = 0; i < 16; i++) {
o[2 * i] = t[i] & 0xff;
o[2 * i + 1] = t[i] >> 8;
}
}
function cswap(p, q, b) {
for (let i = 0; i < 4; i++) {
sel25519(p[i], q[i], b);
}
}
function A(o, a, b) {
for (let i = 0; i < 16; i++) o[i] = a[i] + b[i];
}
function Z(o, a, b) {
for (let i = 0; i < 16; i++) o[i] = a[i] - b[i];
}
function add(p, q) {
const a = gf(),
b = gf(),
c = gf(),
d = gf(),
e = gf(),
f = gf(),
g = gf(),
h = gf(),
t = gf();
Z(a, p[1], p[0]);
Z(t, q[1], q[0]);
M(a, a, t);
A(b, p[0], p[1]);
A(t, q[0], q[1]);
M(b, b, t);
M(c, p[3], q[3]);
M(c, c, D2);
M(d, p[2], q[2]);
A(d, d, d);
Z(e, b, a);
Z(f, d, c);
A(g, d, c);
A(h, b, a);
M(p[0], e, f);
M(p[1], h, g);
M(p[2], g, f);
M(p[3], e, h);
}
function sel25519(p, q, b) {
const c = ~(b - 1);
let t;
for (let i = 0; i < 16; i++) {
t = c & (p[i] ^ q[i]);
p[i] ^= t;
q[i] ^= t;
}
}
module.exports = Ed25519PasswordAuth;

55
node_modules/mariadb/lib/cmd/handshake/auth/native-password-auth.js generated vendored Normal file
View File

@@ -0,0 +1,55 @@
'use strict';
const PluginAuth = require('./plugin-auth');
const Crypto = require('crypto');
/**
* Standard authentication plugin
*/
class NativePasswordAuth extends PluginAuth {
constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
super(resolve, reject, multiAuthResolver);
this.pluginData = pluginData;
this.sequenceNo = packSeq;
this.compressSequenceNo = compressPackSeq;
}
start(out, opts, info) {
//seed is ended with a null byte value.
const data = this.pluginData.slice(0, 20);
let authToken = NativePasswordAuth.encryptPassword(opts.password, data, 'sha1');
out.startPacket(this);
if (authToken.length > 0) {
out.writeBuffer(authToken, 0, authToken.length);
out.flushBuffer(true);
} else {
out.writeEmptyPacket(true);
}
this.emit('send_end');
this.onPacketReceive = this.successSend;
}
static encryptPassword(password, seed, algorithm) {
if (!password) return Buffer.alloc(0);
let hash = Crypto.createHash(algorithm);
let stage1 = hash.update(password, 'utf8').digest();
hash = Crypto.createHash(algorithm);
let stage2 = hash.update(stage1).digest();
hash = Crypto.createHash(algorithm);
hash.update(seed);
hash.update(stage2);
let digest = hash.digest();
let returnBytes = Buffer.allocUnsafe(digest.length);
for (let i = 0; i < digest.length; i++) {
returnBytes[i] = stage1[i] ^ digest[i];
}
return returnBytes;
}
}
module.exports = NativePasswordAuth;

58
node_modules/mariadb/lib/cmd/handshake/auth/pam-password-auth.js generated vendored Normal file
View File

@@ -0,0 +1,58 @@
const PluginAuth = require('./plugin-auth');
/**
* Use PAM authentication
*/
class PamPasswordAuth extends PluginAuth {
constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
super(resolve, reject, multiAuthResolver);
this.pluginData = pluginData;
this.sequenceNo = packSeq;
this.counter = 0;
}
start(out, opts, info) {
this.exchange(this.pluginData, out, opts, info);
this.onPacketReceive = this.response;
}
exchange(buffer, out, opts, info) {
//conversation is :
// - first byte is information tell if question is a password (4) or clear text (2).
// - other bytes are the question to user
out.startPacket(this);
let pwd;
if (Array.isArray(opts.password)) {
pwd = opts.password[this.counter];
this.counter++;
} else {
pwd = opts.password;
}
if (pwd) out.writeString(pwd);
out.writeInt8(0);
out.flushBuffer(true);
}
response(packet, out, opts, info) {
const marker = packet.peek();
switch (marker) {
//*********************************************************************************************************
//* OK_Packet and Err_Packet ending packet
//*********************************************************************************************************
case 0x00:
case 0xff:
this.emit('send_end');
return this.successSend(packet, out, opts, info);
default:
let promptData = packet.readBuffer();
this.exchange(promptData, out, opts, info);
this.onPacketReceive = this.response;
}
}
}
module.exports = PamPasswordAuth;

19
node_modules/mariadb/lib/cmd/handshake/auth/plugin-auth.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
'use strict';
const Command = require('../../command');
/**
* Base authentication plugin
*/
class PluginAuth extends Command {
constructor(resolve, reject, multiAuthResolver) {
super(resolve, reject);
this.multiAuthResolver = multiAuthResolver;
}
successSend(packet, out, opts, info) {
this.multiAuthResolver(packet, out, opts, info);
}
}
module.exports = PluginAuth;

142
node_modules/mariadb/lib/cmd/handshake/auth/sha256-password-auth.js generated vendored Normal file
View File

@@ -0,0 +1,142 @@
const PluginAuth = require('./plugin-auth');
const fs = require('fs');
const crypto = require('crypto');
const Errors = require('../../../misc/errors');
/**
* Use Sha256 authentication
*/
class Sha256PasswordAuth extends PluginAuth {
constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
super(resolve, reject, multiAuthResolver);
this.pluginData = pluginData;
this.sequenceNo = packSeq;
this.counter = 0;
this.initialState = true;
}
start(out, opts, info) {
this.exchange(this.pluginData, out, opts, info);
this.onPacketReceive = this.response;
}
exchange(buffer, out, opts, info) {
if (this.initialState) {
if (!opts.password) {
out.startPacket(this);
out.writeEmptyPacket(true);
return;
} else if (opts.ssl) {
// using SSL, so sending password in clear
out.startPacket(this);
if (opts.password) {
out.writeString(opts.password);
}
out.writeInt8(0);
out.flushBuffer(true);
return;
} else {
// retrieve public key from configuration or from server
if (opts.rsaPublicKey) {
try {
let key = opts.rsaPublicKey;
if (!key.includes('-----BEGIN')) {
// rsaPublicKey contain path
key = fs.readFileSync(key, 'utf8');
}
this.publicKey = Sha256PasswordAuth.retreivePublicKey(key);
} catch (err) {
return this.throwError(err, info);
}
} else {
if (!opts.allowPublicKeyRetrieval) {
return this.throwError(
Errors.createError(
'RSA public key is not available client side. Either set option `rsaPublicKey` to indicate' +
' public key path, or allow public key retrieval with option `allowPublicKeyRetrieval`',
true,
info,
'08S01',
Errors.ER_CANNOT_RETRIEVE_RSA_KEY
),
info
);
}
this.initialState = false;
// ask public Key Retrieval
out.startPacket(this);
out.writeInt8(0x01);
out.flushBuffer(true);
return;
}
}
// send Sha256Password Packet
Sha256PasswordAuth.sendSha256PwdPacket(
this,
this.pluginData,
this.publicKey,
opts.password,
out
);
} else {
// has request public key
this.publicKey = Sha256PasswordAuth.retreivePublicKey(buffer.toString('utf8', 1));
Sha256PasswordAuth.sendSha256PwdPacket(
this,
this.pluginData,
this.publicKey,
opts.password,
out
);
}
}
static retreivePublicKey(key) {
return key.replace('(-+BEGIN PUBLIC KEY-+\\r?\\n|\\n?-+END PUBLIC KEY-+\\r?\\n?)', '');
}
static sendSha256PwdPacket(cmd, pluginData, publicKey, password, out) {
const truncatedSeed = pluginData.slice(0, pluginData.length - 1);
out.startPacket(cmd);
const enc = Sha256PasswordAuth.encrypt(truncatedSeed, password, publicKey);
out.writeBuffer(enc, 0, enc.length);
out.flushBuffer(cmd);
}
// encrypt password with public key
static encrypt(seed, password, publicKey) {
const nullFinishedPwd = Buffer.from(password + '\0');
const xorBytes = Buffer.allocUnsafe(nullFinishedPwd.length);
const seedLength = seed.length;
for (let i = 0; i < xorBytes.length; i++) {
xorBytes[i] = nullFinishedPwd[i] ^ seed[i % seedLength];
}
return crypto.publicEncrypt(
{ key: publicKey, padding: crypto.constants.RSA_PKCS1_OAEP_PADDING },
xorBytes
);
}
response(packet, out, opts, info) {
const marker = packet.peek();
switch (marker) {
//*********************************************************************************************************
//* OK_Packet and Err_Packet ending packet
//*********************************************************************************************************
case 0x00:
case 0xff:
this.emit('send_end');
return this.successSend(packet, out, opts, info);
default:
let promptData = packet.readBufferRemaining();
this.exchange(promptData, out, opts, info);
this.onPacketReceive = this.response;
}
}
}
module.exports = Sha256PasswordAuth;

74
node_modules/mariadb/lib/cmd/handshake/client-capabilities.js generated vendored Normal file
View File

@@ -0,0 +1,74 @@
'use strict';
const Capabilities = require('../../const/capabilities');
/**
* Initialize client capabilities according to options and server capabilities
*
* @param opts options
* @param info information
*/
module.exports.init = function (opts, info) {
let capabilities =
Capabilities.IGNORE_SPACE |
Capabilities.PROTOCOL_41 |
Capabilities.TRANSACTIONS |
Capabilities.SECURE_CONNECTION |
Capabilities.MULTI_RESULTS |
Capabilities.PS_MULTI_RESULTS |
Capabilities.SESSION_TRACK |
Capabilities.PLUGIN_AUTH_LENENC_CLIENT_DATA;
if ((info.serverCapabilities & Capabilities.MYSQL) === BigInt(0)) {
capabilities |= Capabilities.MARIADB_CLIENT_EXTENDED_TYPE_INFO;
}
if (info.serverCapabilities & Capabilities.PLUGIN_AUTH) {
capabilities |= Capabilities.PLUGIN_AUTH;
}
if (opts.connectAttributes && info.serverCapabilities & Capabilities.CONNECT_ATTRS) {
capabilities |= Capabilities.CONNECT_ATTRS;
}
if (opts.foundRows) {
capabilities |= Capabilities.FOUND_ROWS;
}
if (opts.permitLocalInfile) {
capabilities |= Capabilities.LOCAL_FILES;
}
if (opts.multipleStatements) {
capabilities |= Capabilities.MULTI_STATEMENTS;
}
info.eofDeprecated = (info.serverCapabilities & Capabilities.DEPRECATE_EOF) > 0;
if (info.eofDeprecated) {
capabilities |= Capabilities.DEPRECATE_EOF;
}
if (opts.database && info.serverCapabilities & Capabilities.CONNECT_WITH_DB) {
capabilities |= Capabilities.CONNECT_WITH_DB;
}
// use compression only if requested by client and supported by server
if (opts.compress) {
if (info.serverCapabilities & Capabilities.COMPRESS) {
capabilities |= Capabilities.COMPRESS;
} else {
opts.compress = false;
}
}
if (opts.bulk) {
if (info.serverCapabilities & Capabilities.MARIADB_CLIENT_STMT_BULK_OPERATIONS) {
capabilities |= Capabilities.MARIADB_CLIENT_STMT_BULK_OPERATIONS;
}
}
if (opts.permitConnectionWhenExpired) {
capabilities |= Capabilities.CAN_HANDLE_EXPIRED_PASSWORDS;
}
info.clientCapabilities = capabilities;
};

126
node_modules/mariadb/lib/cmd/handshake/client-handshake-response.js generated vendored Normal file
View File

@@ -0,0 +1,126 @@
'use strict';
const Capabilities = require('../../const/capabilities');
const Iconv = require('iconv-lite');
const NativePasswordAuth = require('./auth/native-password-auth');
const Ed25519PasswordAuth = require('./auth/ed25519-password-auth');
const driverVersion = require('../../../package.json').version;
const os = require('os');
/**
* Send Handshake response packet
* see https://mariadb.com/kb/en/library/1-connecting-connecting/#handshake-response-packet
*
* @param cmd current handshake command
* @param out output writer
* @param opts connection options
* @param pluginName plugin name
* @param info connection information
*/
module.exports.send = function send(cmd, out, opts, pluginName, info) {
out.startPacket(cmd);
info.defaultPluginName = pluginName;
const pwd = Array.isArray(opts.password) ? opts.password[0] : opts.password;
let authToken;
let authPlugin;
switch (pluginName) {
case 'client_ed25519':
authToken = Ed25519PasswordAuth.encryptPassword(pwd, info.seed);
authPlugin = 'client_ed25519';
break;
case 'mysql_clear_password':
authToken = Buffer.from(pwd);
authPlugin = 'mysql_clear_password';
break;
default:
authToken = NativePasswordAuth.encryptPassword(pwd, info.seed, 'sha1');
authPlugin = 'mysql_native_password';
break;
}
out.writeInt32(Number(info.clientCapabilities & BigInt(0xffffffff)));
out.writeInt32(1024 * 1024 * 1024); // max packet size
out.writeInt8(opts.collation.index);
for (let i = 0; i < 19; i++) {
out.writeInt8(0);
}
out.writeInt32(Number(info.clientCapabilities >> BigInt(32)));
//null encoded user
out.writeString(opts.user || '');
out.writeInt8(0);
if (info.serverCapabilities & Capabilities.PLUGIN_AUTH_LENENC_CLIENT_DATA) {
out.writeLengthCoded(authToken.length);
out.writeBuffer(authToken, 0, authToken.length);
} else if (info.serverCapabilities & Capabilities.SECURE_CONNECTION) {
out.writeInt8(authToken.length);
out.writeBuffer(authToken, 0, authToken.length);
} else {
out.writeBuffer(authToken, 0, authToken.length);
out.writeInt8(0);
}
if (info.clientCapabilities & Capabilities.CONNECT_WITH_DB) {
out.writeString(opts.database);
out.writeInt8(0);
info.database = opts.database;
}
if (info.clientCapabilities & Capabilities.PLUGIN_AUTH) {
out.writeString(authPlugin);
out.writeInt8(0);
}
if (info.clientCapabilities & Capabilities.CONNECT_ATTRS) {
out.writeInt8(0xfc);
let initPos = out.pos; //save position, assuming connection attributes length will be less than 2 bytes length
out.writeInt16(0);
const encoding = opts.collation.charset;
writeParam(out, '_client_name', encoding);
writeParam(out, 'MariaDB connector/Node', encoding);
writeParam(out, '_client_version', encoding);
writeParam(out, driverVersion, encoding);
const address = cmd.getSocket().address().address;
if (address) {
writeParam(out, '_server_host', encoding);
writeParam(out, address, encoding);
}
writeParam(out, '_os', encoding);
writeParam(out, process.platform, encoding);
writeParam(out, '_client_host', encoding);
writeParam(out, os.hostname(), encoding);
writeParam(out, '_node_version', encoding);
writeParam(out, process.versions.node, encoding);
if (opts.connectAttributes !== true) {
let attrNames = Object.keys(opts.connectAttributes);
for (let k = 0; k < attrNames.length; ++k) {
writeParam(out, attrNames[k], encoding);
writeParam(out, opts.connectAttributes[attrNames[k]], encoding);
}
}
//write end size
out.writeInt16AtPos(initPos);
}
out.flushBuffer(true);
};
function writeParam(out, val, encoding) {
let param = Buffer.isEncoding(encoding)
? Buffer.from(val, encoding)
: Iconv.encode(val, encoding);
out.writeLengthCoded(param.length);
out.writeBuffer(param, 0, param.length);
}

287
node_modules/mariadb/lib/cmd/handshake/handshake.js generated vendored Normal file
View File

@@ -0,0 +1,287 @@
'use strict';
const Command = require('../command');
const InitialHandshake = require('./initial-handshake');
const ClientHandshakeResponse = require('./client-handshake-response');
const SslRequest = require('./ssl-request');
const ClientCapabilities = require('./client-capabilities');
const Errors = require('../../misc/errors');
const Capabilities = require('../../const/capabilities');
const process = require('process');
/**
* Handle handshake.
* see https://mariadb.com/kb/en/library/1-connecting-connecting/
*/
class Handshake extends Command {
constructor(resolve, reject, _createSecureContext, _addCommand, getSocket) {
super(resolve, reject);
this._createSecureContext = _createSecureContext;
this._addCommand = _addCommand;
this.getSocket = getSocket;
this.onPacketReceive = this.parseHandshakeInit;
this.plugin = this;
}
ensureOptionCompatibility(opts, info) {
if (
opts.multipleStatements &&
(info.serverCapabilities & Capabilities.MULTI_STATEMENTS) === 0
) {
return this.throwNewError(
"Option `multipleStatements` enable, but server doesn'permits multi-statment",
true,
info,
'08S01',
Errors.ER_CLIENT_OPTION_INCOMPATIBILITY
);
}
if (opts.permitLocalInfile && (info.serverCapabilities & Capabilities.LOCAL_FILES) === 0) {
return this.throwNewError(
"Option `permitLocalInfile` enable, but server doesn'permits using local file",
true,
info,
'08S01',
Errors.ER_CLIENT_OPTION_INCOMPATIBILITY
);
}
}
parseHandshakeInit(packet, out, opts, info) {
if (packet.peek() === 0xff) {
//in case that some host is not permit to connect server
const authErr = packet.readError(info);
authErr.fatal = true;
return this.throwError(authErr, info);
}
let handshake = new InitialHandshake(packet, info);
this.ensureOptionCompatibility(opts, info);
ClientCapabilities.init(opts, info);
if (opts.ssl) {
if (info.serverCapabilities & Capabilities.SSL) {
info.clientCapabilities |= Capabilities.SSL;
SslRequest.send(this, out, info, opts);
this._createSecureContext(
function () {
ClientHandshakeResponse.send(this, out, opts, handshake.pluginName, info);
}.bind(this)
);
} else {
return this.throwNewError(
'Trying to connect with ssl, but ssl not enabled in the server',
true,
info,
'08S01',
Errors.ER_SERVER_SSL_DISABLED
);
}
} else {
ClientHandshakeResponse.send(this, out, opts, handshake.pluginName, info);
}
this.onPacketReceive = this.handshakeResult;
}
/**
* Fast-path handshake results :
* - if plugin was the one expected by server, server will send OK_Packet / ERR_Packet.
* - if not, server send an AuthSwitchRequest packet, indicating the specific PLUGIN to use with this user.
* dispatching to plugin handler then.
*
* @param packet current packet
* @param out output buffer
* @param opts options
* @param info connection info
* @returns {*} return null if authentication succeed, depending on plugin conversation if not finished
*/
handshakeResult(packet, out, opts, info) {
const marker = packet.peek();
switch (marker) {
//*********************************************************************************************************
//* AuthSwitchRequest packet
//*********************************************************************************************************
case 0xfe:
this.plugin.onPacketReceive = null;
this.plugin.emit('send_end');
this.plugin.emit('end');
this.dispatchAuthSwitchRequest(packet, out, opts, info);
return;
//*********************************************************************************************************
//* OK_Packet - authentication succeeded
//*********************************************************************************************************
case 0x00:
packet.skip(1); //skip header
packet.skipLengthCodedNumber(); //skip affected rows
packet.skipLengthCodedNumber(); //skip last insert id
info.status = packet.readUInt16();
this.plugin.emit('send_end');
return this.plugin.successEnd();
//*********************************************************************************************************
//* ERR_Packet
//*********************************************************************************************************
case 0xff:
const authErr = packet.readError(info, this.displaySql());
authErr.fatal = true;
return this.plugin.throwError(authErr, info);
//*********************************************************************************************************
//* unexpected
//*********************************************************************************************************
default:
this.throwNewError(
'Unexpected type of packet during handshake phase : ' + marker,
true,
info,
'42000',
Errors.ER_AUTHENTICATION_BAD_PACKET
);
}
}
/**
* Handle authentication switch request : dispatch to plugin handler.
*
* @param packet packet
* @param out output writer
* @param opts options
* @param info connection information
*/
dispatchAuthSwitchRequest(packet, out, opts, info) {
let pluginName, pluginData;
if (info.clientCapabilities & Capabilities.PLUGIN_AUTH) {
packet.skip(1); //header
if (packet.remaining()) {
//AuthSwitchRequest packet.
pluginName = packet.readStringNullEnded();
pluginData = packet.readBufferRemaining();
} else {
//OldAuthSwitchRequest
pluginName = 'mysql_old_password';
pluginData = info.seed.slice(0, 8);
}
} else {
pluginName = packet.readStringNullEnded('cesu8');
pluginData = packet.readBufferRemaining();
}
try {
this.plugin = Handshake.pluginHandler(
pluginName,
this.plugin.sequenceNo,
this.plugin.compressSequenceNo,
pluginData,
info,
opts,
out,
this.resolve,
this.reject,
this.handshakeResult.bind(this)
);
} catch (err) {
this.reject(err);
return;
}
if (!this.plugin) {
this.reject(
Errors.createError(
"Client does not support authentication protocol '" +
pluginName +
"' requested by server. ",
true,
info,
'08004',
Errors.ER_AUTHENTICATION_PLUGIN_NOT_SUPPORTED
)
);
} else {
this._addCommand(this.plugin, false);
}
}
static pluginHandler(
pluginName,
packSeq,
compressPackSeq,
pluginData,
info,
opts,
out,
authResolve,
authReject,
multiAuthResolver
) {
let pluginAuth;
switch (pluginName) {
case 'mysql_native_password':
pluginAuth = require('./auth/native-password-auth.js');
break;
case 'mysql_clear_password':
pluginAuth = require('./auth/clear-password-auth.js');
break;
case 'client_ed25519':
pluginAuth = require('./auth/ed25519-password-auth.js');
break;
case 'dialog':
pluginAuth = require('./auth/pam-password-auth.js');
break;
case 'sha256_password':
if (!Handshake.ensureNodeVersion(11, 6, 0)) {
throw Errors.createError(
'sha256_password authentication plugin require node 11.6+',
true,
info,
'08004',
Errors.ER_MINIMUM_NODE_VERSION_REQUIRED
);
}
pluginAuth = require('./auth/sha256-password-auth.js');
break;
case 'caching_sha2_password':
if (!Handshake.ensureNodeVersion(11, 6, 0)) {
throw Errors.createError(
'caching_sha2_password authentication plugin require node 11.6+',
true,
info,
'08004',
Errors.ER_MINIMUM_NODE_VERSION_REQUIRED
);
}
pluginAuth = require('./auth/caching-sha2-password-auth.js');
break;
//TODO "auth_gssapi_client"
default:
return null;
}
return new pluginAuth(
packSeq,
compressPackSeq,
pluginData,
authResolve,
authReject,
multiAuthResolver
);
}
static ensureNodeVersion(major, minor, patch) {
const ver = process.versions.node.split('.');
return (
ver[0] > major ||
(ver[0] === major && ver[1] > minor) ||
(ver[0] === major && ver[1] === minor && ver[2] >= patch)
);
}
}
module.exports = Handshake;

74
node_modules/mariadb/lib/cmd/handshake/initial-handshake.js generated vendored Normal file
View File

@@ -0,0 +1,74 @@
'use strict';
const Capabilities = require('../../const/capabilities');
const ConnectionInformation = require('../../misc/connection-information');
/**
* Parser server initial handshake.
* see https://mariadb.com/kb/en/library/1-connecting-connecting/#initial-handshake-packet
*/
class InitialHandshake {
constructor(packet, info) {
//protocolVersion
packet.skip(1);
info.serverVersion = {};
info.serverVersion.raw = packet.readStringNullEnded();
info.threadId = packet.readUInt32();
let seed1 = packet.readBuffer(8);
packet.skip(1); //reserved byte
let serverCapabilities = BigInt(packet.readUInt16());
//skip characterSet
packet.skip(1);
info.status = packet.readUInt16();
serverCapabilities += BigInt(packet.readUInt16()) << BigInt(16);
let saltLength = 0;
if (serverCapabilities & Capabilities.PLUGIN_AUTH) {
saltLength = Math.max(12, packet.readUInt8() - 9);
} else {
packet.skip(1);
}
if (serverCapabilities & Capabilities.MYSQL) {
packet.skip(10);
} else {
packet.skip(6);
serverCapabilities += BigInt(packet.readUInt32()) << BigInt(32);
}
if (serverCapabilities & Capabilities.SECURE_CONNECTION) {
let seed2 = packet.readBuffer(saltLength);
info.seed = Buffer.concat([seed1, seed2]);
} else {
info.seed = seed1;
}
packet.skip(1);
info.serverCapabilities = serverCapabilities;
/**
* check for MariaDB 10.x replication hack , remove fake prefix if needed
* MDEV-4088: in 10.0+, the real version string maybe prefixed with "5.5.5-",
* to workaround bugs in Oracle MySQL replication
**/
if (info.serverVersion.raw.startsWith('5.5.5-')) {
info.serverVersion.mariaDb = true;
info.serverVersion.raw = info.serverVersion.raw.substring('5.5.5-'.length);
} else {
//Support for MDEV-7780 faking server version
info.serverVersion.mariaDb =
info.serverVersion.raw.includes('MariaDB') ||
(serverCapabilities & Capabilities.MYSQL) === BigInt(0);
}
if (serverCapabilities & Capabilities.PLUGIN_AUTH) {
this.pluginName = packet.readStringNullEnded();
} else {
this.pluginName = '';
}
ConnectionInformation.parseVersionString(info);
}
}
module.exports = InitialHandshake;

29
node_modules/mariadb/lib/cmd/handshake/ssl-request.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
'use strict';
const Capabilities = require('../../const/capabilities');
/**
* Send SSL Request packet.
* see : https://mariadb.com/kb/en/library/1-connecting-connecting/#sslrequest-packet
*
* @param cmd current command
* @param out output writer
* @param info client information
* @param opts connection options
*/
module.exports.send = function sendSSLRequest(cmd, out, info, opts) {
out.startPacket(cmd);
out.writeInt32(Number(info.clientCapabilities & BigInt(0xffffffff)));
out.writeInt32(1024 * 1024 * 1024); // max packet size
out.writeInt8(opts.collation.index);
for (let i = 0; i < 19; i++) {
out.writeInt8(0);
}
if (info.serverCapabilities & Capabilities.MYSQL) {
out.writeInt32(0);
} else {
out.writeInt32(Number(info.clientCapabilities >> BigInt(32)));
}
out.flushBuffer(true);
};

52
node_modules/mariadb/lib/cmd/ping.js generated vendored Normal file
View File

@@ -0,0 +1,52 @@
'use strict';
const Command = require('./command');
const Errors = require('../misc/errors');
/**
* send a COM_PING: permits sending a packet containing one byte to check that the connection is active.
* see https://mariadb.com/kb/en/library/com_ping/
*/
class Ping extends Command {
constructor(resolve, reject) {
super(resolve, reject);
}
start(out, opts, info) {
out.startPacket(this);
out.writeInt8(0x0e);
out.flushBuffer(true);
this.emit('send_end');
this.onPacketReceive = this.readPingResponsePacket;
}
/**
* Read ping response packet.
* packet can be :
* - an ERR_Packet
* - a OK_Packet
*
* @param packet query response
* @param out output writer
* @param opts connection options
* @param info connection info
*/
readPingResponsePacket(packet, out, opts, info) {
if (packet.peek() !== 0x00) {
return this.throwNewError(
'unexpected packet',
false,
info,
'42000',
Errors.ER_PING_BAD_PACKET
);
}
packet.skip(1); //skip header
packet.skipLengthCodedNumber(); //affected rows
packet.skipLengthCodedNumber(); //insert ids
info.status = packet.readUInt16();
this.successEnd(null);
}
}
module.exports = Ping;

253
node_modules/mariadb/lib/cmd/query.js generated vendored Normal file
View File

@@ -0,0 +1,253 @@
'use strict';
const CommonText = require('./common-text-cmd');
const Errors = require('../misc/errors');
const Parse = require('../misc/parse');
const QUOTE = 0x27;
/**
* Protocol COM_QUERY
* see : https://mariadb.com/kb/en/library/com_query/
*/
class Query extends CommonText {
constructor(resolve, reject, options, connOpts, sql, values) {
super(resolve, reject, options, connOpts, sql, values);
}
/**
* Send COM_QUERY
*
* @param out output writer
* @param opts connection options
* @param info connection information
*/
start(out, opts, info) {
if (!this.initialValues) {
//shortcut if no parameters
out.startPacket(this);
out.writeInt8(0x03);
if (!this.handleTimeout(out, info)) return;
out.writeString(this.sql);
out.flushBuffer(true);
this.emit('send_end');
return (this.onPacketReceive = this.readResponsePacket);
}
if (this.opts.namedPlaceholders) {
try {
const parsed = Parse.splitQueryPlaceholder(
this.sql,
info,
this.initialValues,
this.displaySql.bind(this)
);
this.queryParts = parsed.parts;
this.values = parsed.values;
} catch (err) {
this.emit('send_end');
return this.throwError(err, info);
}
} else {
this.queryParts = Parse.splitQuery(this.sql);
this.values = Array.isArray(this.initialValues) ? this.initialValues : [this.initialValues];
if (!this.validateParameters(info)) return;
}
out.startPacket(this);
out.writeInt8(0x03);
if (!this.handleTimeout(out, info)) return;
out.writeString(this.queryParts[0]);
this.onPacketReceive = this.readResponsePacket;
//********************************************
// send params
//********************************************
const len = this.queryParts.length;
for (let i = 1; i < len; i++) {
const value = this.values[i - 1];
if (
value !== null &&
typeof value === 'object' &&
typeof value.pipe === 'function' &&
typeof value.read === 'function'
) {
this.sending = true;
//********************************************
// param is stream,
// now all params will be written by event
//********************************************
this.registerStreamSendEvent(out, info);
this.currentParam = i;
out.writeInt8(QUOTE); //'
value.on('data', function (chunk) {
out.writeBufferEscape(chunk);
});
value.on(
'end',
function () {
out.writeInt8(QUOTE); //'
out.writeString(this.queryParts[this.currentParam++]);
this.paramWritten();
}.bind(this)
);
return;
} else {
//********************************************
// param isn't stream. directly write in buffer
//********************************************
this.writeParam(out, value, this.opts, info);
out.writeString(this.queryParts[i]);
}
}
out.flushBuffer(true);
this.emit('send_end');
}
/**
* If timeout is set, prepend query with SET STATEMENT max_statement_time=xx FOR, or throw an error
* @param out buffer
* @param info server information
* @returns {boolean} false if an error has been thrown
*/
handleTimeout(out, info) {
if (this.opts.timeout) {
if (info.isMariaDB()) {
if (info.hasMinVersion(10, 1, 2)) {
out.writeString('SET STATEMENT max_statement_time=' + this.opts.timeout / 1000 + ' FOR ');
return true;
} else {
const err = Errors.createError(
'Cannot use timeout for MariaDB server before 10.1.2. timeout value: ' +
this.opts.timeout,
false,
info,
'HY000',
Errors.ER_TIMEOUT_NOT_SUPPORTED
);
this.emit('send_end');
this.throwError(err, info);
return false;
}
} else {
//not available for MySQL
// max_execution time exist, but only for select, and as hint
const err = Errors.createError(
'Cannot use timeout for MySQL server. timeout value: ' + this.opts.timeout,
false,
info,
'HY000',
Errors.ER_TIMEOUT_NOT_SUPPORTED
);
this.emit('send_end');
this.throwError(err, info);
return false;
}
}
return true;
}
/**
* Validate that parameters exists and are defined.
*
* @param info connection info
* @returns {boolean} return false if any error occur.
*/
validateParameters(info) {
//validate parameter size.
if (this.queryParts.length - 1 > this.values.length) {
this.emit('send_end');
this.throwNewError(
'Parameter at position ' + (this.values.length + 1) + ' is not set\n' + this.displaySql(),
false,
info,
'HY000',
Errors.ER_MISSING_PARAMETER
);
return false;
}
//validate parameter is defined.
for (let i = 0; i < this.queryParts.length - 1; i++) {
if (this.values[i] === undefined) {
this.emit('send_end');
this.throwNewError(
'Parameter at position ' + (i + 1) + ' is undefined\n' + this.displaySql(),
false,
info,
'HY000',
Errors.ER_PARAMETER_UNDEFINED
);
return false;
}
}
return true;
}
/**
* Define params events.
* Each parameter indicate that he is written to socket,
* emitting event so next stream parameter can be written.
*/
registerStreamSendEvent(out, info) {
// note : Implementation use recursive calls, but stack won't never get near v8 max call stack size
//since event launched for stream parameter only
this.paramWritten = function () {
while (true) {
if (this.currentParam === this.queryParts.length) {
//********************************************
// all parameters are written.
// flush packet
//********************************************
out.flushBuffer(true);
this.sending = false;
this.emit('send_end');
return;
} else {
const value = this.values[this.currentParam - 1];
if (value === null) {
out.writeStringAscii('NULL');
out.writeString(this.queryParts[this.currentParam++]);
continue;
}
if (
typeof value === 'object' &&
typeof value.pipe === 'function' &&
typeof value.read === 'function'
) {
//********************************************
// param is stream,
//********************************************
out.writeInt8(QUOTE);
value.once(
'end',
function () {
out.writeInt8(QUOTE);
out.writeString(this.queryParts[this.currentParam++]);
this.paramWritten();
}.bind(this)
);
value.on('data', function (chunk) {
out.writeBufferEscape(chunk);
});
return;
}
//********************************************
// param isn't stream. directly write in buffer
//********************************************
this.writeParam(out, value, this.opts, info);
out.writeString(this.queryParts[this.currentParam++]);
}
}
}.bind(this);
}
}
module.exports = Query;

28
node_modules/mariadb/lib/cmd/quit.js generated vendored Normal file
View File

@@ -0,0 +1,28 @@
'use strict';
const Command = require('./command');
/**
* Quit (close connection)
* see https://mariadb.com/kb/en/library/com_quit/
*/
class Quit extends Command {
constructor(resolve, reject) {
super(resolve, reject);
}
start(out, opts, info) {
out.startPacket(this);
out.writeInt8(0x01);
out.flushBuffer(true);
this.emit('send_end');
this.successEnd();
this.onPacketReceive = this.skipResults;
}
skipResults(packet, out, opts, info) {
//deliberately empty, if server send answer
}
}
module.exports = Quit;

54
node_modules/mariadb/lib/cmd/reset.js generated vendored Normal file
View File

@@ -0,0 +1,54 @@
'use strict';
const Command = require('./command');
const Errors = require('../misc/errors');
/**
* send a COM_RESET_CONNECTION: permits to reset a connection without re-authentication.
* see https://mariadb.com/kb/en/library/com_reset_connection/
*/
class Reset extends Command {
constructor(resolve, reject) {
super(resolve, reject);
}
start(out, opts, info) {
out.startPacket(this);
out.writeInt8(0x1f);
out.flushBuffer(true);
this.emit('send_end');
this.onPacketReceive = this.readResetResponsePacket;
}
/**
* Read response packet.
* packet can be :
* - an ERR_Packet
* - a OK_Packet
*
* @param packet query response
* @param out output writer
* @param opts connection options
* @param info connection info
*/
readResetResponsePacket(packet, out, opts, info) {
if (packet.peek() !== 0x00) {
return this.throwNewError(
'unexpected packet',
false,
info,
'42000',
Errors.ER_RESET_BAD_PACKET
);
}
packet.skip(1); //skip header
packet.skipLengthCodedNumber(); //affected rows
packet.skipLengthCodedNumber(); //insert ids
info.status = packet.readUInt16();
this.successEnd(null);
}
}
module.exports = Reset;

605
node_modules/mariadb/lib/cmd/resultset.js generated vendored Normal file
View File

@@ -0,0 +1,605 @@
'use strict';
const Command = require('./command');
const ServerStatus = require('../const/server-status');
const ColumnDefinition = require('./column-definition');
const Errors = require('../misc/errors');
const fs = require('fs');
const Parse = require('../misc/parse');
/**
* handle COM_QUERY / COM_STMT_EXECUTE results
* see : https://mariadb.com/kb/en/library/4-server-response-packets/
*/
class ResultSet extends Command {
constructor(resolve, reject) {
super(resolve, reject);
this._responseIndex = 0;
this._rows = [];
}
/**
* Read Query response packet.
* packet can be :
* - a result-set
* - an ERR_Packet
* - a OK_Packet
* - LOCAL_INFILE Packet
*
* @param packet query response
* @param out output writer
* @param opts connection options
* @param info connection info
*/
readResponsePacket(packet, out, opts, info) {
switch (packet.peek()) {
//*********************************************************************************************************
//* OK response
//*********************************************************************************************************
case 0x00:
return this.readOKPacket(packet, out, opts, info);
//*********************************************************************************************************
//* ERROR response
//*********************************************************************************************************
case 0xff:
const err = packet.readError(info, this.displaySql(), this.stack);
//force in transaction status, since query will have created a transaction if autocommit is off
//goal is to avoid unnecessary COMMIT/ROLLBACK.
info.status |= ServerStatus.STATUS_IN_TRANS;
return this.throwError(err, info);
//*********************************************************************************************************
//* LOCAL INFILE response
//*********************************************************************************************************
case 0xfb:
return this.readLocalInfile(packet, out, opts, info);
//*********************************************************************************************************
//* ResultSet
//*********************************************************************************************************
default:
return this.readResultSet(packet);
}
}
/**
* Read result-set packets :
* see https://mariadb.com/kb/en/library/resultset/
*
* @param packet Column count packet
* @returns {ResultSet.readColumn} next packet handler
*/
readResultSet(packet) {
this._columnCount = packet.readUnsignedLength();
this._getValue = this.opts.typeCast ? this.readCastValue : this.readRowData;
this._rows.push([]);
this._columns = [];
this.onPacketReceive = this.readColumn;
}
/**
* Assign global configuration option used by result-set to current query option.
* a little faster than Object.assign() since doest copy all information
*
* @param connOpts connection global configuration
* @param cmdOpts specific command options
*/
configAssign(connOpts, cmdOpts) {
if (!cmdOpts) {
this.opts = connOpts;
return;
}
this.opts = {
timeout: cmdOpts.timeout,
autoJsonMap: connOpts.autoJsonMap,
arrayParenthesis: connOpts.arrayParenthesis,
supportBigInt:
cmdOpts.supportBigInt != undefined ? cmdOpts.supportBigInt : connOpts.supportBigInt,
checkDuplicate:
cmdOpts.checkDuplicate != undefined ? cmdOpts.checkDuplicate : connOpts.checkDuplicate,
typeCast: cmdOpts.typeCast != undefined ? cmdOpts.typeCast : connOpts.typeCast,
rowsAsArray: cmdOpts.rowsAsArray != undefined ? cmdOpts.rowsAsArray : connOpts.rowsAsArray,
nestTables: cmdOpts.nestTables != undefined ? cmdOpts.nestTables : connOpts.nestTables,
dateStrings: cmdOpts.dateStrings != undefined ? cmdOpts.dateStrings : connOpts.dateStrings,
tz: cmdOpts.tz != undefined ? cmdOpts.tz : connOpts.tz,
pipelining: connOpts.pipelining,
localTz: cmdOpts.localTz != undefined ? cmdOpts.localTz : connOpts.localTz,
namedPlaceholders:
cmdOpts.namedPlaceholders != undefined
? cmdOpts.namedPlaceholders
: connOpts.namedPlaceholders,
maxAllowedPacket:
cmdOpts.maxAllowedPacket != undefined
? cmdOpts.maxAllowedPacket
: connOpts.maxAllowedPacket,
supportBigNumbers:
cmdOpts.supportBigNumbers != undefined
? cmdOpts.supportBigNumbers
: connOpts.supportBigNumbers,
permitSetMultiParamEntries:
cmdOpts.permitSetMultiParamEntries != undefined
? cmdOpts.permitSetMultiParamEntries
: connOpts.permitSetMultiParamEntries,
bigNumberStrings:
cmdOpts.bigNumberStrings != undefined ? cmdOpts.bigNumberStrings : connOpts.bigNumberStrings
};
}
/**
* Read OK_Packet.
* see https://mariadb.com/kb/en/library/ok_packet/
*
* @param packet OK_Packet
* @param opts connection options
* @param info connection information
* @param out output writer
* @returns {*} null or {Resultset.readResponsePacket} in case of multi-result-set
*/
readOKPacket(packet, out, opts, info) {
const okPacket = Command.parseOkPacket(packet, out, opts, info);
this._rows.push(okPacket);
if (info.status & ServerStatus.MORE_RESULTS_EXISTS) {
this._responseIndex++;
return (this.onPacketReceive = this.readResponsePacket);
}
this.success(this._responseIndex === 0 ? this._rows[0] : this._rows);
}
/**
* Read COM_STMT_PREPARE response Packet.
* see https://mariadb.com/kb/en/library/com_stmt_prepare/#com_stmt_prepare-response
*
* @param packet COM_STMT_PREPARE_OK packet
* @param opts connection options
* @param info connection information
* @param out output writer
* @returns {*} null or {Resultset.readResponsePacket} in case of multi-result-set
*/
readPrepareResultPacket(packet, out, opts, info) {
switch (packet.peek()) {
//*********************************************************************************************************
//* OK response
//*********************************************************************************************************
case 0x00:
packet.skip(1); //skip header
this.statementId = packet.readInt32();
this.columnNo = packet.readUInt16();
this.parameterNo = packet.readUInt16();
if (this.columnNo > 0) return (this.onPacketReceive = this.skipColumnsPacket);
if (this.parameterNo > 0) return (this.onPacketReceive = this.skipParameterPacket);
return this.success();
//*********************************************************************************************************
//* ERROR response
//*********************************************************************************************************
case 0xff:
const err = packet.readError(info, this.displaySql(), this.stack);
//force in transaction status, since query will have created a transaction if autocommit is off
//goal is to avoid unnecessary COMMIT/ROLLBACK.
info.status |= ServerStatus.STATUS_IN_TRANS;
this.onPacketReceive = this.readResponsePacket;
return this.throwError(err, info);
//*********************************************************************************************************
//* Unexpected response
//*********************************************************************************************************
default:
info.status |= ServerStatus.STATUS_IN_TRANS;
this.onPacketReceive = this.readResponsePacket;
return this.throwError(Errors.ER_UNEXPECTED_PACKET, info);
}
}
skipColumnsPacket(packet, out, opts, info) {
this.columnNo--;
if (this.columnNo === 0) {
if (info.eofDeprecated) {
if (this.parameterNo > 0) return (this.onPacketReceive = this.skipParameterPacket);
this.success();
}
return (this.onPacketReceive = this.skipEofPacket);
}
}
skipEofPacket(packet, out, opts, info) {
if (this.parameterNo > 0) return (this.onPacketReceive = this.skipParameterPacket);
this.success();
}
skipParameterPacket(packet, out, opts, info) {
this.parameterNo--;
if (this.parameterNo === 0) {
if (info.eofDeprecated) return this.success();
return (this.onPacketReceive = this.skipEofPacket);
}
}
success(val) {
this.successEnd(val);
this._columns = null;
this._rows = null;
}
/**
* Read column information metadata
* see https://mariadb.com/kb/en/library/resultset/#column-definition-packet
*
* @param packet column definition packet
* @param out output writer
* @param opts connection options
* @param info connection information
* @returns {*}
*/
readColumn(packet, out, opts, info) {
if (this._columns.length !== this._columnCount) {
this._columns.push(new ColumnDefinition(packet, info));
}
// last column
if (this._columns.length === this._columnCount) {
if (this.opts.rowsAsArray) {
this.parseRow = this.parseRowAsArray;
} else {
this.tableHeader = new Array(this._columnCount);
if (this.opts.nestTables) {
this.parseRow = this.parseRowStd;
if (typeof this.opts.nestTables === 'string') {
for (let i = 0; i < this._columnCount; i++) {
this.tableHeader[i] =
this._columns[i].table() + this.opts.nestTables + this._columns[i].name();
}
this.checkDuplicates();
} else if (this.opts.nestTables === true) {
this.parseRow = this.parseRowNested;
for (let i = 0; i < this._columnCount; i++) {
this.tableHeader[i] = [this._columns[i].table(), this._columns[i].name()];
}
this.checkNestTablesDuplicates();
}
} else {
this.parseRow = this.parseRowStd;
for (let i = 0; i < this._columnCount; i++) {
this.tableHeader[i] = this._columns[i].name();
}
this.checkDuplicates();
}
}
this.emit('fields', this._columns);
return (this.onPacketReceive = info.eofDeprecated
? this.readResultSetRow
: this.readIntermediateEOF);
}
}
checkDuplicates() {
if (this.opts.checkDuplicate) {
for (let i = 0; i < this._columnCount; i++) {
if (this.tableHeader.indexOf(this.tableHeader[i], i + 1) > 0) {
const dupes = this.tableHeader.reduce(
(acc, v, i, arr) =>
arr.indexOf(v) !== i && acc.indexOf(v) === -1 ? acc.concat(v) : acc,
[]
);
this.throwUnexpectedError(
'Error in results, duplicate field name `' +
dupes[0] +
'`.\n' +
'(see option `checkDuplicate`)',
false,
null,
'42000',
Errors.ER_DUPLICATE_FIELD
);
}
}
}
}
checkNestTablesDuplicates() {
if (this.opts.checkDuplicate) {
for (let i = 0; i < this._columnCount; i++) {
for (let j = 0; j < i; j++) {
if (
this.tableHeader[j][0] === this.tableHeader[i][0] &&
this.tableHeader[j][1] === this.tableHeader[i][1]
) {
this.throwUnexpectedError(
'Error in results, duplicate field name `' +
this.tableHeader[i][0] +
'`.`' +
this.tableHeader[i][1] +
'`\n' +
'(see option `checkDuplicate`)',
false,
null,
'42000',
Errors.ER_DUPLICATE_FIELD
);
}
}
}
}
}
/**
* Read intermediate EOF.
* _only for server before MariaDB 10.2 / MySQL 5.7 that doesn't have CLIENT_DEPRECATE_EOF capability_
* see https://mariadb.com/kb/en/library/eof_packet/
*
* @param packet EOF Packet
* @param out output writer
* @param opts connection options
* @param info connection information
* @returns {*}
*/
readIntermediateEOF(packet, out, opts, info) {
if (packet.peek() !== 0xfe) {
return this.throwNewError(
'Error in protocol, expected EOF packet',
true,
info,
'42000',
Errors.ER_EOF_EXPECTED
);
}
//before MySQL 5.7.5, last EOF doesn't contain the good flag SERVER_MORE_RESULTS_EXISTS
//for OUT parameters. It must be checked here
//(5.7.5 does have the CLIENT_DEPRECATE_EOF capability, so this packet in not even send)
packet.skip(3);
info.status = packet.readUInt16();
this.isOutParameter = info.status & ServerStatus.PS_OUT_PARAMS;
this.onPacketReceive = this.readResultSetRow;
}
handleNewRows(row) {
this._rows[this._responseIndex].push(row);
}
/**
* Check if packet is result-set end = EOF of OK_Packet with EOF header according to CLIENT_DEPRECATE_EOF capability
* or a result-set row
*
* @param packet current packet
* @param out output writer
* @param opts connection options
* @param info connection information
* @returns {*}
*/
readResultSetRow(packet, out, opts, info) {
if (packet.peek() >= 0xfe) {
if (packet.peek() === 0xff) {
const err = packet.readError(info, this.displaySql(), this.stack);
//force in transaction status, since query will have created a transaction if autocommit is off
//goal is to avoid unnecessary COMMIT/ROLLBACK.
info.status |= ServerStatus.STATUS_IN_TRANS;
return this.throwError(err, info);
}
if (
(!info.eofDeprecated && packet.length() < 13) ||
(info.eofDeprecated && packet.length() < 0xffffff)
) {
if (!info.eofDeprecated) {
packet.skip(3);
info.status = packet.readUInt16();
} else {
packet.skip(1); //skip header
packet.skipLengthCodedNumber(); //skip update count
packet.skipLengthCodedNumber(); //skip insert id
info.status = packet.readUInt16();
}
if (opts.metaAsArray) {
//return promise object as array :
// example for SELECT 1 =>
// [
// [ {"1": 1} ], //rows
// [ColumnDefinition] //meta
// ]
if (!this._meta) {
this._meta = new Array(this._responseIndex);
}
this._meta[this._responseIndex] = this._columns;
if (info.status & ServerStatus.MORE_RESULTS_EXISTS || this.isOutParameter) {
this._responseIndex++;
return (this.onPacketReceive = this.readResponsePacket);
}
this.success(
this._responseIndex === 0 ? [this._rows[0], this._meta[0]] : [this._rows, this._meta]
);
} else {
//return promise object as rows that have meta property :
// example for SELECT 1 =>
// [
// {"1": 1},
// meta: [ColumnDefinition]
// ]
this._rows[this._responseIndex].meta = this._columns;
if (info.status & ServerStatus.MORE_RESULTS_EXISTS || this.isOutParameter) {
this._responseIndex++;
return (this.onPacketReceive = this.readResponsePacket);
}
this.success(this._responseIndex === 0 ? this._rows[0] : this._rows);
}
return;
}
}
const row = this.parseRow(this._columns, packet, opts);
this.handleNewRows(row);
}
/**
* Display current SQL with parameters (truncated if too big)
*
* @returns {string}
*/
displaySql() {
if (this.opts && this.initialValues) {
if (this.sql.length > this.opts.debugLen) {
return 'sql: ' + this.sql.substring(0, this.opts.debugLen) + '...';
}
let sqlMsg = 'sql: ' + this.sql + ' - parameters:';
return this.logParameters(sqlMsg, this.initialValues);
}
return 'sql: ' + this.sql + ' - parameters:[]';
}
logParameters(sqlMsg, values) {
if (this.opts.namedPlaceholders) {
sqlMsg += '{';
let first = true;
for (let key in values) {
if (first) {
first = false;
} else {
sqlMsg += ',';
}
sqlMsg += "'" + key + "':";
let param = values[key];
sqlMsg = ResultSet.logParam(sqlMsg, param);
if (sqlMsg.length > this.opts.debugLen) {
sqlMsg = sqlMsg.substr(0, this.opts.debugLen) + '...';
break;
}
}
sqlMsg += '}';
} else {
sqlMsg += '[';
if (Array.isArray(values)) {
for (let i = 0; i < values.length; i++) {
if (i !== 0) sqlMsg += ',';
let param = values[i];
sqlMsg = ResultSet.logParam(sqlMsg, param);
if (sqlMsg.length > this.opts.debugLen) {
sqlMsg = sqlMsg.substr(0, this.opts.debugLen) + '...';
break;
}
}
} else {
sqlMsg = ResultSet.logParam(sqlMsg, values);
if (sqlMsg.length > this.opts.debugLen) {
sqlMsg = sqlMsg.substr(0, this.opts.debugLen) + '...';
}
}
sqlMsg += ']';
}
return sqlMsg;
}
readLocalInfile(packet, out, opts, info) {
packet.skip(1); //skip header
out.startPacket(this);
const fileName = packet.readStringRemaining();
if (!Parse.validateFileName(this.sql, this.initialValues, fileName)) {
out.writeEmptyPacket();
const error = Errors.createError(
"LOCAL INFILE wrong filename. '" +
fileName +
"' doesn't correspond to query " +
this.sql +
'. Query cancelled. Check for malicious server / proxy',
false,
info,
'45034',
Errors.ER_LOCAL_INFILE_WRONG_FILENAME
);
process.nextTick(this.reject, error);
this.reject = null;
this.resolve = null;
return (this.onPacketReceive = this.readResponsePacket);
}
// this.sequenceNo = 2;
// this.compressSequenceNo = 2;
const stream = fs.createReadStream(fileName);
stream.on('error', (err) => {
out.writeEmptyPacket();
const error = Errors.createError(
'LOCAL INFILE command failed: ' + err.message,
false,
info,
'22000',
Errors.ER_LOCAL_INFILE_NOT_READABLE
);
process.nextTick(this.reject, error);
this.reject = null;
this.resolve = null;
});
stream.on('data', (chunk) => {
out.writeBuffer(chunk, 0, chunk.length);
});
stream.on('end', () => {
if (!out.isEmpty()) {
out.flushBuffer(false);
}
out.writeEmptyPacket();
});
this.onPacketReceive = this.readResponsePacket;
}
static logParam(sqlMsg, param) {
if (param === undefined || param === null) {
sqlMsg += param === undefined ? 'undefined' : 'null';
} else {
switch (param.constructor.name) {
case 'Buffer':
sqlMsg += '0x' + param.toString('hex', 0, Math.min(1024, param.length)) + '';
break;
case 'String':
sqlMsg += "'" + param + "'";
break;
case 'Date':
sqlMsg += getStringDate(param);
break;
case 'Object':
sqlMsg += JSON.stringify(param);
break;
default:
sqlMsg += param.toString();
}
}
return sqlMsg;
}
}
function getStringDate(param) {
return (
"'" +
('00' + (param.getMonth() + 1)).slice(-2) +
'/' +
('00' + param.getDate()).slice(-2) +
'/' +
param.getFullYear() +
' ' +
('00' + param.getHours()).slice(-2) +
':' +
('00' + param.getMinutes()).slice(-2) +
':' +
('00' + param.getSeconds()).slice(-2) +
'.' +
('000' + param.getMilliseconds()).slice(-3) +
"'"
);
}
module.exports = ResultSet;

45
node_modules/mariadb/lib/cmd/stream.js generated vendored Normal file
View File

@@ -0,0 +1,45 @@
'use strict';
const Query = require('./query');
const { Readable } = require('stream');
/**
* Protocol COM_QUERY with streaming events.
* see : https://mariadb.com/kb/en/library/com_query/
*/
class Stream extends Query {
constructor(cmdOpts, connOpts, sql, values, socket) {
super(
() => {},
() => {},
cmdOpts,
connOpts,
sql,
values
);
this.socket = socket;
this.inStream = new Readable({
objectMode: true,
read: () => {}
});
this.on('fields', function (meta) {
this.inStream.emit('fields', meta);
});
this.on('error', function (err) {
this.inStream.emit('error', err);
});
this.on('end', function (err) {
if (err) this.inStream.emit('error', err);
this.inStream.push(null);
});
}
handleNewRows(row) {
this.inStream.push(row);
}
}
module.exports = Stream;