1277 lines
40 KiB
JavaScript
1277 lines
40 KiB
JavaScript
/**
|
|
* Cryptonote Node.JS Pool
|
|
* https://github.com/dvandal/cryptonote-nodejs-pool
|
|
*
|
|
* Pool TCP daemon
|
|
**/
|
|
|
|
// Load required modules
|
|
let fs = require('fs');
|
|
let net = require('net');
|
|
let tls = require('tls');
|
|
let async = require('async');
|
|
|
|
let apiInterfaces = require('./apiInterfaces.js')(config.daemon, config.wallet, config.api);
|
|
let notifications = require('./notifications.js');
|
|
let utils = require('./utils.js');
|
|
let miningBackends = require('./miningBackends.js');
|
|
|
|
config.hashingUtil = config.hashingUtil || false;
|
|
let cnHashing = require('cryptonight-hashing');
|
|
if (config.hashingUtil) {
|
|
cnHashing = require('turtlecoin-crypto');
|
|
}
|
|
// Set nonce pattern - must exactly be 8 hex chars
|
|
let noncePattern = new RegExp("^[0-9A-Fa-f]{8}$");
|
|
|
|
// Set redis database cleanup interval
|
|
let cleanupInterval = config.redis.cleanupInterval && config.redis.cleanupInterval > 0 ? config.redis.cleanupInterval : 15;
|
|
|
|
// Initialize log system
|
|
let logSystem = 'pool';
|
|
require('./exceptionWriter.js')(logSystem);
|
|
|
|
let threadId = '(Thread ' + process.env.forkId + ') ';
|
|
let log = function (severity, system, text, data) {
|
|
global.log(severity, system, threadId + text, data);
|
|
};
|
|
|
|
function getMiningParams() {
|
|
return miningBackends.getActiveMiningParams();
|
|
}
|
|
|
|
// Set cryptonight algorithm
|
|
let cnAlgorithm = getMiningParams().cnAlgorithm || "cryptonight";
|
|
let cnVariant = getMiningParams().cnVariant || 0;
|
|
let cnBlobType = getMiningParams().cnBlobType || 0;
|
|
|
|
let cryptoNight;
|
|
if (!cnHashing || !cnHashing[cnAlgorithm]) {
|
|
log('error', logSystem, 'Invalid cryptonight algorithm: %s', [cnAlgorithm]);
|
|
} else {
|
|
cryptoNight = cnHashing[cnAlgorithm];
|
|
}
|
|
|
|
// Set instance id
|
|
let instanceId = utils.instanceId();
|
|
|
|
// Pool variables
|
|
let poolStarted = false;
|
|
let connectedMiners = {};
|
|
let POOL_NONCE_SIZE = 16 + 1; // +1 for old XMR/new TRTL bugs
|
|
let EXTRA_NONCE_TEMPLATE = "02" + POOL_NONCE_SIZE.toString(16) + "00".repeat(POOL_NONCE_SIZE);
|
|
|
|
function randomIntFromInterval (min, max) {
|
|
return Math.floor(Math.random() * (max - min + 1) + min);
|
|
}
|
|
|
|
// Pool settings
|
|
let shareTrustEnabled = config.poolServer.shareTrust && config.poolServer.shareTrust.enabled;
|
|
let shareTrustStepFloat = shareTrustEnabled ? config.poolServer.shareTrust.stepDown / 100 : 0;
|
|
let shareTrustMinFloat = shareTrustEnabled ? config.poolServer.shareTrust.min / 100 : 0;
|
|
|
|
let banningEnabled = config.poolServer.banning && config.poolServer.banning.enabled;
|
|
let bannedIPs = {};
|
|
let perIPStats = {};
|
|
|
|
let slushMiningEnabled = config.poolServer.slushMining && config.poolServer.slushMining.enabled;
|
|
|
|
if (!config.poolServer.paymentId) {
|
|
config.poolServer.paymentId = {};
|
|
}
|
|
if (!config.poolServer.paymentId.addressSeparator) {
|
|
config.poolServer.paymentId.addressSeparator = "+";
|
|
}
|
|
|
|
if (config.poolServer.paymentId.validation == null) {
|
|
config.poolServer.paymentId.validation = true;
|
|
}
|
|
if (config.poolServer.paymentId.ban == null) {
|
|
config.poolServer.paymentId.ban = false;
|
|
}
|
|
if (config.poolServer.paymentId.validations == null) {
|
|
config.poolServer.paymentId.validations = [];
|
|
config.poolServer.paymentId.validation = false;
|
|
}
|
|
|
|
let previousOffset = config.previousOffset || 7;
|
|
let offset = config.offset || 2;
|
|
config.daemonType = config.daemonType || 'default';
|
|
if (config.daemonType === 'bytecoin') {
|
|
previousOffset = config.previousOffset || 3;
|
|
offset = config.offset || 3;
|
|
}
|
|
|
|
function Create2DArray (rows) {
|
|
let arr = [];
|
|
for (let i = 0; i < rows; i++) {
|
|
arr[i] = [];
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
// Block templates
|
|
let validBlockTemplates = Create2DArray(1);
|
|
let currentBlockTemplate = [];
|
|
|
|
|
|
// Difficulty buffer
|
|
const DIFF1 = (1n << 256n) - 1n;
|
|
|
|
function bigintToBuffer (value) {
|
|
if (value === 0n) return Buffer.from([0]);
|
|
let hex = value.toString(16);
|
|
if (hex.length % 2 !== 0) hex = '0' + hex;
|
|
return Buffer.from(hex, 'hex');
|
|
}
|
|
|
|
function bufferToBigInt (buffer) {
|
|
let hex = Buffer.from(buffer).toString('hex');
|
|
if (!hex) return 0n;
|
|
return BigInt('0x' + hex);
|
|
}
|
|
|
|
function calculateDifficultyBigInt (hashBuffer) {
|
|
let hashNum = bufferToBigInt(hashBuffer);
|
|
if (hashNum === 0n) return DIFF1;
|
|
return DIFF1 / hashNum;
|
|
}
|
|
|
|
/**
|
|
* Convert buffer to byte array
|
|
**/
|
|
Buffer.prototype.toByteArray = function () {
|
|
return Array.prototype.slice.call(this, 0);
|
|
};
|
|
|
|
/**
|
|
* Periodical updaters
|
|
**/
|
|
|
|
// Variable difficulty retarget
|
|
setInterval(function () {
|
|
let now = Date.now() / 1000 | 0;
|
|
for (let minerId in connectedMiners) {
|
|
let miner = connectedMiners[minerId];
|
|
if (!miner.noRetarget) {
|
|
miner.retarget(now);
|
|
}
|
|
}
|
|
}, config.poolServer.varDiff.retargetTime * 1000);
|
|
|
|
// Every 30 seconds clear out timed-out miners and old bans
|
|
setInterval(function () {
|
|
let now = Date.now();
|
|
let timeout = config.poolServer.minerTimeout * 1000;
|
|
for (let minerId in connectedMiners) {
|
|
let miner = connectedMiners[minerId];
|
|
if (now - miner.lastBeat > timeout) {
|
|
log('warn', logSystem, 'Miner timed out and disconnected %s@%s', [miner.login, miner.ip]);
|
|
delete connectedMiners[minerId];
|
|
removeConnectedWorker(miner, 'timeout');
|
|
}
|
|
}
|
|
|
|
if (banningEnabled) {
|
|
for (ip in bannedIPs) {
|
|
let banTime = bannedIPs[ip];
|
|
if (now - banTime > config.poolServer.banning.time * 1000) {
|
|
delete bannedIPs[ip];
|
|
delete perIPStats[ip];
|
|
log('info', logSystem, 'Ban dropped for %s', [ip]);
|
|
}
|
|
}
|
|
}
|
|
|
|
}, 30000);
|
|
|
|
/**
|
|
* Handle multi-thread messages
|
|
**/
|
|
process.on('message', function (message) {
|
|
switch (message.type) {
|
|
case 'banIP':
|
|
bannedIPs[message.ip] = Date.now();
|
|
break;
|
|
case 'BlockTemplate':
|
|
let buffer = Buffer.from(message.block.blocktemplate_blob, 'hex');
|
|
let new_hash = Buffer.alloc(32);
|
|
buffer.copy(new_hash, 0, previousOffset, 39);
|
|
try {
|
|
if (!currentBlockTemplate[0] || new_hash.toString('hex') !== currentBlockTemplate[0].prev_hash.toString('hex') || (currentBlockTemplate[0].num_transactions == 0 && message.block.num_transactions > 0)) {
|
|
log('info', logSystem, 'New %s block to mine at height %d w/ difficulty of %d (%d transactions)', [miningBackends.getActiveMiningBackend().coin, message.block.height, message.block.difficulty, (message.block.num_transactions || 0)]);
|
|
processBlockTemplate(message.block);
|
|
return;
|
|
} else {
|
|
return;
|
|
}
|
|
} catch (e) {
|
|
log('error', logSystem, `BlockTemplate ${e}`);
|
|
}
|
|
break;
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Block template
|
|
**/
|
|
function BlockTemplate (template) {
|
|
this.difficulty = template.difficulty;
|
|
this.height;
|
|
try {
|
|
this.height = template.height;
|
|
} catch (e) {
|
|
console.log(`BlockTemplate ${e}`);
|
|
}
|
|
this.num_transactions = template.num_transactions || 0;
|
|
this.blocktemplate_blob = template.blocktemplate_blob;
|
|
let blob = this.blocktemplate_blob;
|
|
this.buffer = Buffer.from(blob, 'hex');
|
|
this.isRandomX = getMiningParams().isRandomX;
|
|
if (this.isRandomX) {
|
|
this.seed_hash = template.seed_hash;
|
|
this.next_seed_hash = template.next_seed_hash;
|
|
}
|
|
var found_template_at = blob.indexOf(EXTRA_NONCE_TEMPLATE);
|
|
if (found_template_at !== -1) {
|
|
this.reserveOffset = offset + (found_template_at >> 1);
|
|
if (this.reserveOffset != template.reserved_offset) {
|
|
log('error', logSystem, "INTERNAL ERROR: found reserve offset in unexpected place (found at %d, expected at %d)",
|
|
[this.reserveOffset, template.reserved_offset]);
|
|
}
|
|
} else {
|
|
log('error', logSystem, "INTERNAL ERROR: Couldn't find extra nonce data in blob!");
|
|
this.reserveOffset = template.reserveOffset || template.reserved_offset;
|
|
}
|
|
// Copy the Instance ID to the reserve offset + 4 bytes deeper. Copy in 4 bytes.
|
|
instanceId.copy(this.buffer, this.reserveOffset + 4, 0, 4);
|
|
|
|
// Reset nonce - this is the per-miner/pool nonce
|
|
this.extraNonce = 0;
|
|
// The clientNonceLocation is the location at which the client pools should set the nonces for each of their clients.
|
|
this.clientNonceLocation = this.reserveOffset + 12;
|
|
|
|
this.prev_hash = Buffer.alloc(32);
|
|
this.buffer.copy(this.prev_hash, 0, previousOffset, 39);
|
|
}
|
|
BlockTemplate.prototype = {
|
|
nextBlob: function () {
|
|
this.buffer.writeUInt32BE(++this.extraNonce, this.reserveOffset);
|
|
return utils.cnUtil.convert_blob(this.buffer, getMiningParams().cnBlobType).toString('hex');
|
|
},
|
|
nextBlobWithChildNonce: function () {
|
|
// Write a 32 bit integer, big-endian style to the 0 byte of the reserve offset.
|
|
this.buffer.writeUInt32BE(++this.extraNonce, this.reserveOffset);
|
|
// Don't convert the blob to something hashable. You bad.
|
|
return this.buffer.toString('hex');
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Process block template
|
|
**/
|
|
function processBlockTemplate (template) {
|
|
let block_template = new BlockTemplate(template);
|
|
|
|
if (currentBlockTemplate[0]) {
|
|
validBlockTemplates[0].push(currentBlockTemplate[0]);
|
|
}
|
|
|
|
while (validBlockTemplates[0].length > 3) {
|
|
validBlockTemplates[0].shift();
|
|
}
|
|
|
|
currentBlockTemplate[0] = block_template;
|
|
notifyConnectedMiners();
|
|
}
|
|
|
|
function notifyConnectedMiners () {
|
|
for (let minerId in connectedMiners) {
|
|
let miner = connectedMiners[minerId];
|
|
miner.pushMessage('job', miner.getJob());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Variable difficulty
|
|
**/
|
|
let VarDiff = (function () {
|
|
let variance = config.poolServer.varDiff.variancePercent / 100 * config.poolServer.varDiff.targetTime;
|
|
return {
|
|
variance: variance,
|
|
bufferSize: config.poolServer.varDiff.retargetTime / config.poolServer.varDiff.targetTime * 4,
|
|
tMin: config.poolServer.varDiff.targetTime - variance,
|
|
tMax: config.poolServer.varDiff.targetTime + variance,
|
|
maxJump: config.poolServer.varDiff.maxJump
|
|
};
|
|
})();
|
|
|
|
function GetRewardTypeAsKey (rewardType) {
|
|
switch (rewardType) {
|
|
case 'solo':
|
|
return ':solo'
|
|
case 'prop':
|
|
return ''
|
|
default:
|
|
return ''
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Miner
|
|
**/
|
|
function Miner (rewardType, id, login, pass, ip, port, agent, startingDiff, noRetarget, pushMessage) {
|
|
this.rewardType = rewardType;
|
|
this.rewardTypeAsKey = GetRewardTypeAsKey(rewardType);
|
|
this.id = id;
|
|
this.login = login;
|
|
this.pass = pass;
|
|
this.ip = ip;
|
|
this.port = port;
|
|
this.proxy = false;
|
|
if (agent && agent.includes('xmr-node-proxy')) {
|
|
this.proxy = true;
|
|
}
|
|
this.workerName = 'undefined';
|
|
if (pass.lastIndexOf('@') >= 0 && pass.lastIndexOf('@') < pass.length) {
|
|
passDelimiterPos = pass.lastIndexOf('@') + 1;
|
|
this.workerName = pass.substr(passDelimiterPos, pass.length)
|
|
.trim();
|
|
}
|
|
this.pushMessage = pushMessage;
|
|
this.heartbeat();
|
|
this.noRetarget = noRetarget;
|
|
this.difficulty = startingDiff;
|
|
this.validJobs = [];
|
|
this.workerName = pass;
|
|
|
|
// Vardiff related variables
|
|
this.shareTimeRing = utils.ringBuffer(16);
|
|
this.lastShareTime = Date.now() / 1000 | 0;
|
|
|
|
if (shareTrustEnabled) {
|
|
this.trust = {
|
|
threshold: config.poolServer.shareTrust.threshold,
|
|
probability: 1,
|
|
penalty: 0
|
|
};
|
|
}
|
|
}
|
|
Miner.prototype = {
|
|
retarget: function (now) {
|
|
|
|
let options = config.poolServer.varDiff;
|
|
let sinceLast = now - this.lastShareTime;
|
|
let decreaser = sinceLast > VarDiff.tMax;
|
|
let avg = this.shareTimeRing.avg(decreaser ? sinceLast : null);
|
|
let newDiff;
|
|
let direction;
|
|
|
|
if (avg > VarDiff.tMax && this.difficulty > options.minDiff) {
|
|
newDiff = options.targetTime / avg * this.difficulty;
|
|
newDiff = newDiff > options.minDiff ? newDiff : options.minDiff;
|
|
direction = -1;
|
|
} else if (avg < VarDiff.tMin && this.difficulty < options.maxDiff) {
|
|
newDiff = options.targetTime / avg * this.difficulty;
|
|
newDiff = newDiff < options.maxDiff ? newDiff : options.maxDiff;
|
|
direction = 1;
|
|
} else {
|
|
return;
|
|
}
|
|
if (Math.abs(newDiff - this.difficulty) / this.difficulty * 100 > options.maxJump) {
|
|
let change = options.maxJump / 100 * this.difficulty * direction;
|
|
newDiff = this.difficulty + change;
|
|
}
|
|
this.setNewDiff(newDiff);
|
|
this.shareTimeRing.clear();
|
|
if (decreaser) this.lastShareTime = now;
|
|
},
|
|
setNewDiff: function (newDiff) {
|
|
newDiff = Math.round(newDiff);
|
|
if (this.difficulty === newDiff) {
|
|
return;
|
|
}
|
|
log('info', logSystem, 'Retargetting difficulty %d to %d for %s', [this.difficulty, newDiff, this.login]);
|
|
this.pendingDifficulty = newDiff;
|
|
this.pushMessage('job', this.getJob());
|
|
},
|
|
heartbeat: function () {
|
|
this.lastBeat = Date.now();
|
|
},
|
|
getTargetHex: function () {
|
|
if (this.pendingDifficulty) {
|
|
this.lastDifficulty = this.difficulty;
|
|
this.difficulty = this.pendingDifficulty;
|
|
this.pendingDifficulty = null;
|
|
}
|
|
let padded = Buffer.alloc(32);
|
|
padded.fill(0);
|
|
let diffBuff = bigintToBuffer(DIFF1 / BigInt(this.difficulty));
|
|
diffBuff.copy(padded, 32 - diffBuff.length);
|
|
let buff = padded.slice(0, 4);
|
|
let buffArray = buff.toByteArray().reverse();
|
|
let buffReversed = Buffer.from(buffArray);
|
|
this.target = buffReversed.readUInt32BE(0);
|
|
let hex = buffReversed.toString('hex');
|
|
return hex;
|
|
},
|
|
getJob: function () {
|
|
let blockTemplate = currentBlockTemplate[0];
|
|
if (!blockTemplate) {
|
|
return null;
|
|
}
|
|
let newJob = {
|
|
id: utils.uid(),
|
|
height: blockTemplate.height,
|
|
submissions: []
|
|
};
|
|
if (this.lastBlockHeight === blockTemplate.height && !this.pendingDifficulty && this.cachedJob !== null && !miningBackends.getActiveMiningBackend().alwaysPoll) {
|
|
return this.cachedJob;
|
|
}
|
|
let blob = this.proxy ? blockTemplate.nextBlobWithChildNonce() : blockTemplate.nextBlob();
|
|
this.lastBlockHeight = blockTemplate.height;
|
|
let target = this.getTargetHex();
|
|
|
|
newJob.difficulty = this.difficulty;
|
|
newJob.diffHex = this.diffHex;
|
|
newJob.extraNonce = blockTemplate.extraNonce;
|
|
|
|
if (blockTemplate.isRandomX) {
|
|
newJob.seed_hash = blockTemplate.seed_hash;
|
|
newJob.next_seed_hash = blockTemplate.next_seed_hash;
|
|
}
|
|
|
|
this.validJobs.push(newJob);
|
|
|
|
while (this.validJobs.length > 4)
|
|
this.validJobs.shift();
|
|
|
|
this.cachedJob = {
|
|
job_id: newJob.id,
|
|
id: this.id
|
|
};
|
|
|
|
if (this.proxy) {
|
|
newJob.clientPoolLocation = blockTemplate.clientPoolLocation
|
|
newJob.clientNonceLocation = blockTemplate.clientNonceLocation
|
|
|
|
this.cachedJob.blocktemplate_blob = blob;
|
|
this.cachedJob.difficulty = blockTemplate.difficulty;
|
|
this.cachedJob.height = blockTemplate.height;
|
|
this.cachedJob.reserved_offset = blockTemplate.reserveOffset;
|
|
this.cachedJob.client_nonce_offset = blockTemplate.clientNonceLocation;
|
|
this.cachedJob.client_pool_offset = blockTemplate.clientPoolLocation;
|
|
this.cachedJob.target_diff = this.difficulty;
|
|
this.cachedJob.target_diff_hex = this.diffHex;
|
|
|
|
} else {
|
|
this.cachedJob.blob = blob;
|
|
this.cachedJob.target = target;
|
|
}
|
|
|
|
if (typeof config.includeAlgo !== "undefined" && config.includeAlgo) {
|
|
this.cachedJob.algo = config.includeAlgo
|
|
}
|
|
if (getMiningParams().includeHeight) {
|
|
this.cachedJob.height = blockTemplate.height
|
|
}
|
|
|
|
if (newJob.seed_hash) {
|
|
this.cachedJob.seed_hash = newJob.seed_hash;
|
|
this.cachedJob.next_seed_hash = newJob.next_seed_hash;
|
|
}
|
|
return this.cachedJob;
|
|
},
|
|
checkBan: function (validShare) {
|
|
if (!banningEnabled) return;
|
|
// Init global per-ip shares stats
|
|
if (!perIPStats[this.ip]) {
|
|
perIPStats[this.ip] = {
|
|
validShares: 0,
|
|
invalidShares: 0
|
|
};
|
|
}
|
|
|
|
let stats = perIPStats[this.ip];
|
|
validShare ? stats.validShares++ : stats.invalidShares++;
|
|
|
|
if (stats.validShares + stats.invalidShares >= config.poolServer.banning.checkThreshold) {
|
|
if (stats.invalidShares / stats.validShares >= config.poolServer.banning.invalidPercent / 100) {
|
|
validShare ? this.validShares++ : this.invalidShares++;
|
|
log('warn', logSystem, 'Banned %s@%s', [this.login, this.ip]);
|
|
bannedIPs[this.ip] = Date.now();
|
|
delete connectedMiners[this.id];
|
|
process.send({
|
|
type: 'banIP',
|
|
ip: this.ip
|
|
});
|
|
removeConnectedWorker(this, 'banned');
|
|
} else {
|
|
stats.invalidShares = 0;
|
|
stats.validShares = 0;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
validateMinerPaymentId_difficulty = (address, ip, poolServerConfig, coin, sendReply) => {
|
|
if (utils.characterCount(address, '\\+') > 1) {
|
|
let message = `Invalid paymentId specified for ${coin}login, ${ip}`;
|
|
if (poolServerConfig.paymentId.validation) {
|
|
process.send({
|
|
type: 'banIP',
|
|
ip: ip
|
|
});
|
|
message += ` banned for ${poolServerConfig.banning.time / 60} minutes`
|
|
}
|
|
sendReply(message);
|
|
log('warn', logSystem, message);
|
|
return false;
|
|
}
|
|
|
|
if (utils.characterCount(address, '\\.') > 1) {
|
|
log('warn', logSystem, `Invalid difficulty specified for ${coin}login`);
|
|
sendReply(`Invalid difficulty specified for ${coin}login, ${ip}`);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Handle miner method
|
|
**/
|
|
function handleMinerMethod (method, params, ip, portData, sendReply, pushMessage) {
|
|
let miner = connectedMiners[params.id];
|
|
|
|
// Check for ban here, so preconnected attackers can't continue to screw you
|
|
if (IsBannedIp(ip)) {
|
|
sendReply('Your IP is banned');
|
|
return;
|
|
}
|
|
|
|
switch (method) {
|
|
case 'login':
|
|
let login = params.login;
|
|
if (!login) {
|
|
sendReply('Missing login');
|
|
return;
|
|
}
|
|
|
|
if (!validateMinerPaymentId_difficulty(login, ip, config.poolServer, 'parent ', sendReply))
|
|
{
|
|
return;
|
|
}
|
|
|
|
let calculated = utils.determineRewardData(login);
|
|
login = calculated.address;
|
|
let rewardType = calculated.rewardType;
|
|
|
|
let address = '';
|
|
let paymentid = null;
|
|
let port = portData.port;
|
|
let pass = params.pass;
|
|
|
|
|
|
let difficulty = portData.difficulty;
|
|
let noRetarget = false;
|
|
if (config.poolServer.fixedDiff.enabled) {
|
|
let fixedDiffCharPos = login.lastIndexOf(config.poolServer.fixedDiff.addressSeparator);
|
|
if (fixedDiffCharPos !== -1 && (login.length - fixedDiffCharPos < 32)) {
|
|
diffValue = login.substr(fixedDiffCharPos + 1);
|
|
difficulty = parseInt(diffValue);
|
|
login = login.substr(0, fixedDiffCharPos);
|
|
if (!difficulty || difficulty != diffValue) {
|
|
log('warn', logSystem, 'Invalid difficulty value "%s" for login: %s', [diffValue, login]);
|
|
difficulty = portData.difficulty;
|
|
} else {
|
|
noRetarget = true;
|
|
if (difficulty < config.poolServer.varDiff.minDiff) {
|
|
difficulty = config.poolServer.varDiff.minDiff;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
addr = login.split(config.poolServer.paymentId.addressSeparator);
|
|
address = addr[0] || null;
|
|
paymentId = addr[1] || null;
|
|
if (!address) {
|
|
log('warn', logSystem, 'No address specified for login');
|
|
sendReply('Invalid address used for login');
|
|
return
|
|
}
|
|
|
|
if (paymentId && paymentId.match('^([a-zA-Z0-9]){0,15}$')) {
|
|
if (config.poolServer.paymentId.validation) {
|
|
process.send({
|
|
type: 'banIP',
|
|
ip: ip
|
|
});
|
|
log('warn', logSystem, 'Invalid paymentId specified for login');
|
|
} else {
|
|
log('warn', logSystem, 'Invalid paymentId specified for login');
|
|
}
|
|
sendReply(`Invalid paymentId specified for login, ${portData.ip} banned for ${config.poolServer.banning.time / 60} minutes`);
|
|
return;
|
|
}
|
|
|
|
if (!utils.validateMinerAddress(address)) {
|
|
let addressPrefix = utils.getAddressPrefix(address);
|
|
if (!addressPrefix) addressPrefix = 'N/A';
|
|
|
|
log('warn', logSystem, 'Invalid address used for login (prefix: %s): %s', [addressPrefix, address]);
|
|
sendReply('Invalid address used for login');
|
|
return;
|
|
}
|
|
|
|
let minerId = utils.uid();
|
|
miner = new Miner(rewardType, minerId, login, pass, ip, port, params.agent, difficulty, noRetarget, pushMessage);
|
|
connectedMiners[minerId] = miner;
|
|
let minerJob = miner.getJob();
|
|
if (!minerJob) {
|
|
delete connectedMiners[minerId];
|
|
sendReply('No active block template yet');
|
|
return;
|
|
}
|
|
|
|
sendReply(null, {
|
|
id: minerId,
|
|
job: minerJob,
|
|
status: 'OK'
|
|
});
|
|
|
|
newConnectedWorker(miner);
|
|
break;
|
|
case 'getjob':
|
|
if (!miner) {
|
|
sendReply('Unauthenticated');
|
|
return;
|
|
}
|
|
miner.heartbeat();
|
|
let jobReply = miner.getJob();
|
|
if (!jobReply) {
|
|
sendReply('No active block template yet');
|
|
return;
|
|
}
|
|
sendReply(null, jobReply);
|
|
break;
|
|
case 'submit':
|
|
if (!miner) {
|
|
sendReply('Unauthenticated');
|
|
return;
|
|
}
|
|
miner.heartbeat();
|
|
|
|
let job = miner.validJobs.filter(function (job) {
|
|
return job.id === params.job_id;
|
|
})[0];
|
|
|
|
if (!job) {
|
|
sendReply('Invalid job id');
|
|
return;
|
|
}
|
|
|
|
if (!params.nonce || !params.result) {
|
|
sendReply('Attack detected');
|
|
let minerText = miner ? (' ' + miner.login + '@' + miner.ip) : '';
|
|
log('warn', logSystem, 'Malformed miner share: ' + JSON.stringify(params) + ' from ' + minerText);
|
|
return;
|
|
}
|
|
|
|
if (!noncePattern.test(params.nonce)) {
|
|
let minerText = miner ? (' ' + miner.login + '@' + miner.ip) : '';
|
|
log('warn', logSystem, 'Malformed nonce: ' + JSON.stringify(params) + ' from ' + minerText);
|
|
perIPStats[miner.ip] = {
|
|
validShares: 0,
|
|
invalidShares: 999999
|
|
};
|
|
miner.checkBan(false);
|
|
sendReply('Duplicate share1');
|
|
return;
|
|
}
|
|
|
|
// Force lowercase for further comparison
|
|
params.nonce = params.nonce.toLowerCase();
|
|
|
|
if (!miner.proxy) {
|
|
if (job.submissions.indexOf(params.nonce) !== -1) {
|
|
let minerText = miner ? (' ' + miner.login + '@' + miner.ip) : '';
|
|
log('warn', logSystem, 'Duplicate share: ' + JSON.stringify(params) + ' from ' + minerText);
|
|
perIPStats[miner.ip] = {
|
|
validShares: 0,
|
|
invalidShares: 999999
|
|
};
|
|
miner.checkBan(false);
|
|
sendReply('Duplicate share2');
|
|
return;
|
|
}
|
|
|
|
job.submissions.push(params.nonce);
|
|
} else {
|
|
if (!Number.isInteger(params.poolNonce) || !Number.isInteger(params.workerNonce)) {
|
|
let minerText = miner ? (' ' + miner.login + '@' + miner.ip) : '';
|
|
log('warn', logSystem, 'Malformed nonce: ' + JSON.stringify(params) + ' from ' + minerText);
|
|
perIPStats[miner.ip] = {
|
|
validShares: 0,
|
|
invalidShares: 999999
|
|
};
|
|
miner.checkBan(false);
|
|
sendReply('Duplicate share3');
|
|
return;
|
|
}
|
|
let nonce_test = `${params.nonce}_${params.poolNonce}_${params.workerNonce}`;
|
|
if (job.submissions.indexOf(nonce_test) !== -1) {
|
|
let minerText = miner ? (' ' + miner.login + '@' + miner.ip) : '';
|
|
log('warn', logSystem, 'Duplicate share: ' + JSON.stringify(params) + ' from ' + minerText);
|
|
perIPStats[miner.ip] = {
|
|
validShares: 0,
|
|
invalidShares: 999999
|
|
};
|
|
miner.checkBan(false);
|
|
sendReply('Duplicate share4');
|
|
return;
|
|
}
|
|
job.submissions.push(nonce_test);
|
|
|
|
}
|
|
|
|
let isJobBlock = function (b) {
|
|
return b.height === job.height;
|
|
};
|
|
|
|
let blockTemplate = isJobBlock(currentBlockTemplate[0]) ? currentBlockTemplate[0] : validBlockTemplates[0].filter(isJobBlock)[0];
|
|
if (!blockTemplate) {
|
|
sendReply('Block expired');
|
|
return;
|
|
}
|
|
|
|
let shareAccepted = processShare(miner, job, blockTemplate, params);
|
|
miner.checkBan(shareAccepted);
|
|
|
|
if (shareTrustEnabled) {
|
|
if (shareAccepted) {
|
|
miner.trust.probability -= shareTrustStepFloat;
|
|
if (miner.trust.probability < shareTrustMinFloat)
|
|
miner.trust.probability = shareTrustMinFloat;
|
|
miner.trust.penalty--;
|
|
miner.trust.threshold--;
|
|
} else {
|
|
log('warn', logSystem, 'Share trust broken by %s@%s', [miner.login, miner.ip]);
|
|
miner.trust.probability = 1;
|
|
miner.trust.penalty = config.poolServer.shareTrust.penalty;
|
|
}
|
|
}
|
|
|
|
if (!shareAccepted) {
|
|
sendReply('Rejected share: invalid result');
|
|
return;
|
|
}
|
|
|
|
let now = Date.now() / 1000 | 0;
|
|
miner.shareTimeRing.append(now - miner.lastShareTime);
|
|
miner.lastShareTime = now;
|
|
|
|
sendReply(null, {
|
|
status: 'OK'
|
|
});
|
|
break;
|
|
case 'keepalived':
|
|
if (!miner) {
|
|
sendReply('Unauthenticated');
|
|
return;
|
|
}
|
|
miner.heartbeat();
|
|
sendReply(null, {
|
|
status: 'KEEPALIVED'
|
|
});
|
|
break;
|
|
default:
|
|
sendReply('Invalid method');
|
|
let minerText = miner ? (' ' + miner.login + '@' + miner.ip) : '';
|
|
log('warn', logSystem, 'Invalid method: %s (%j) from %s', [method, params, minerText]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* New connected worker
|
|
**/
|
|
function newConnectedWorker (miner) {
|
|
log('info', logSystem, 'Miner connected %s@%s on port', [miner.login, miner.ip, miner.port]);
|
|
if (miner.workerName !== 'undefined') log('info', logSystem, 'Worker Name: %s', [miner.workerName]);
|
|
if (miner.difficulty) log('info', logSystem, 'Miner difficulty fixed to %s', [miner.difficulty]);
|
|
|
|
redisClient.sadd(`${config.coin}:workers_ip:${miner.login}`, miner.ip);
|
|
redisClient.hincrby(`${config.coin}:ports:${miner.port}`, 'users', 1);
|
|
|
|
redisClient.hincrby(`${config.coin}:active_connections${miner.rewardTypeAsKey}`, `${miner.login}~${miner.workerName}`, 1, function (error, connectedWorkers) {
|
|
if (connectedWorkers === 1) {
|
|
notifications.sendToMiner(miner.login, 'workerConnected', {
|
|
'LOGIN': miner.login,
|
|
'MINER': `${miner.login.substring(0,7)}...${miner.login.substring(miner.login.length-7)}`,
|
|
'IP': miner.ip.replace('::ffff:', ''),
|
|
'PORT': miner.port,
|
|
'WORKER_NAME': miner.workerName !== 'undefined' ? miner.workerName : ''
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Remove connected worker
|
|
**/
|
|
function removeConnectedWorker (miner, reason) {
|
|
redisClient.hincrby(`${config.coin}:ports:${miner.port}`, 'users', '-1');
|
|
|
|
redisClient.hincrby(`${config.coin}:active_connections${miner.rewardTypeAsKey}`, `${miner.login}~${miner.workerName}`, -1, function (error, connectedWorkers) {
|
|
if (reason === 'banned') {
|
|
notifications.sendToMiner(miner.login, 'workerBanned', {
|
|
'LOGIN': miner.login,
|
|
'MINER': `${miner.login.substring(0,7)}...${miner.login.substring(miner.login.length-7)}`,
|
|
'IP': miner.ip.replace('::ffff:', ''),
|
|
'PORT': miner.port,
|
|
'WORKER_NAME': miner.workerName !== 'undefined' ? miner.workerName : ''
|
|
});
|
|
} else if (!connectedWorkers || connectedWorkers <= 0) {
|
|
notifications.sendToMiner(miner.login, 'workerTimeout', {
|
|
'LOGIN': miner.login,
|
|
'MINER': `${miner.login.substring(0,7)}...${miner.login.substring(miner.login.length-7)}`,
|
|
'IP': miner.ip.replace('::ffff:', ''),
|
|
'PORT': miner.port,
|
|
'WORKER_NAME': miner.workerName !== 'undefined' ? miner.workerName : '',
|
|
'LAST_HASH': utils.dateFormat(new Date(miner.lastBeat), 'yyyy-mm-dd HH:MM:ss Z')
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Return if IP has been banned
|
|
**/
|
|
function IsBannedIp (ip) {
|
|
if (!banningEnabled || !bannedIPs[ip]) return false;
|
|
|
|
let bannedTime = bannedIPs[ip];
|
|
let bannedTimeAgo = Date.now() - bannedTime;
|
|
let timeLeft = config.poolServer.banning.time * 1000 - bannedTimeAgo;
|
|
if (timeLeft > 0) {
|
|
return true;
|
|
} else {
|
|
delete bannedIPs[ip];
|
|
log('info', logSystem, 'Ban dropped for %s', [ip]);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function recordShareData (miner, job, shareDiff, blockCandidate, hashHex, shareType, blockTemplate) {
|
|
let dateNow = Date.now();
|
|
let dateNowSeconds = dateNow / 1000 | 0;
|
|
let coin = config.coin;
|
|
let login = miner.login;
|
|
let job_height = job.height;
|
|
let workerName = miner.workerName;
|
|
let rewardType = miner.rewardType;
|
|
let updateScore;
|
|
// Weighting older shares lower than newer ones to prevent pool hopping
|
|
if (slushMiningEnabled) {
|
|
// We need to do this via an eval script because we need fetching the last block time and
|
|
// calculating the score to run in a single transaction (otherwise we could have a race
|
|
// condition where a block gets discovered between the time we look up lastBlockFound and
|
|
// insert the score, which would give the miner an erroneously huge proportion on the new block)
|
|
updateScore = ['eval', `
|
|
local age = (ARGV[3] - redis.call('hget', KEYS[2], 'lastBlockFound')) / 1000
|
|
local score = string.format('%.17g', ARGV[2] * math.exp(age / ARGV[4]))
|
|
redis.call('hincrbyfloat', KEYS[1], ARGV[1], score)
|
|
return {score, tostring(age)}
|
|
`,
|
|
2 /*keys*/ , coin + ':scores:roundCurrent', coin + ':stats',
|
|
/* args */
|
|
login, job.difficulty, Date.now(), config.poolServer.slushMining.weight
|
|
];
|
|
} else {
|
|
job.score = job.difficulty;
|
|
updateScore = ['hincrbyfloat', `${coin}:scores:${rewardType}:roundCurrent`, login, job.score]
|
|
}
|
|
|
|
let redisCommands = [
|
|
updateScore,
|
|
['hincrby', `${coin}:shares_actual:${rewardType}:roundCurrent`, login, job.difficulty],
|
|
['zadd', `${coin}:hashrate`, dateNowSeconds, [job.difficulty, login, dateNow, rewardType].join(':')],
|
|
['hincrby', `${coin}:workers:${login}`, 'hashes', job.difficulty],
|
|
['hset', `${coin}:workers:${login}`, 'lastShare', dateNowSeconds],
|
|
['expire', `${coin}:workers:${login}`, (86400 * cleanupInterval)],
|
|
['expire', `${coin}:payments:${login}`, (86400 * cleanupInterval)]
|
|
];
|
|
|
|
if (workerName) {
|
|
redisCommands.push(['zadd', `${coin}:hashrate`, dateNowSeconds, [job.difficulty, login + '~' + workerName, dateNow, rewardType].join(':')]);
|
|
redisCommands.push(['hincrby', `${coin}:unique_workers:${login}~${workerName}`, 'hashes', job.difficulty]);
|
|
redisCommands.push(['hset', `${coin}:unique_workers:${login}~${workerName}`, 'lastShare', dateNowSeconds]);
|
|
redisCommands.push(['expire', `${coin}:unique_workers:${login}~${workerName}`, (86400 * cleanupInterval)]);
|
|
}
|
|
|
|
if (blockCandidate) {
|
|
redisCommands.push(['hset', `${coin}:stats`, `lastBlockFound${rewardType}`, Date.now()]);
|
|
redisCommands.push(['rename', `${coin}:scores:prop:roundCurrent`, coin + ':scores:prop:round' + job_height]);
|
|
redisCommands.push(['rename', `${coin}:scores:solo:roundCurrent`, coin + ':scores:solo:round' + job_height]);
|
|
redisCommands.push(['rename', `${coin}:shares_actual:prop:roundCurrent`, `${coin}:shares_actual:prop:round${job_height}`]);
|
|
redisCommands.push(['rename', `${coin}:shares_actual:solo:roundCurrent`, `${coin}:shares_actual:solo:round${job_height}`]);
|
|
if (rewardType === 'prop') {
|
|
redisCommands.push(['hgetall', `${coin}:scores:prop:round${job_height}`]);
|
|
redisCommands.push(['hgetall', `${coin}:shares_actual:prop:round${job_height}`]);
|
|
}
|
|
if (rewardType === 'solo') {
|
|
redisCommands.push(['hget', `${coin}:scores:solo:round${job_height}`, login]);
|
|
redisCommands.push(['hget', `${coin}:shares_actual:solo:round${job_height}`, login]);
|
|
}
|
|
|
|
}
|
|
|
|
redisClient.multi(redisCommands)
|
|
.exec(function (err, replies) {
|
|
if (err) {
|
|
log('error', logSystem, 'Failed to insert share data into redis %j \n %j', [err, redisCommands]);
|
|
return;
|
|
}
|
|
|
|
if (slushMiningEnabled) {
|
|
job.score = parseFloat(replies[0][0]);
|
|
let age = parseFloat(replies[0][1]);
|
|
log('info', logSystem, 'Submitted score ' + job.score + ' for difficulty ' + job.difficulty + ' and round age ' + age + 's');
|
|
}
|
|
|
|
if (blockCandidate) {
|
|
let workerScores = replies[replies.length - 2];
|
|
let workerShares = replies[replies.length - 1];
|
|
let totalScore = 0;
|
|
let totalShares = 0;
|
|
if (rewardType === 'solo') {
|
|
totalScore = workerScores
|
|
totalShares = workerShares
|
|
}
|
|
if (rewardType === 'prop') {
|
|
totalScore = Object.keys(workerScores)
|
|
.reduce(function (p, c) {
|
|
return p + parseFloat(workerScores[c])
|
|
}, 0);
|
|
totalShares = Object.keys(workerShares)
|
|
.reduce(function (p, c) {
|
|
return p + parseInt(workerShares[c])
|
|
}, 0);
|
|
}
|
|
redisClient.zadd(coin + ':blocks:candidates', job_height, [
|
|
rewardType,
|
|
login,
|
|
hashHex,
|
|
Date.now() / 1000 | 0,
|
|
blockTemplate.difficulty,
|
|
totalShares,
|
|
totalScore
|
|
].join(':'), function (err, result) {
|
|
if (err) {
|
|
log('error', logSystem, 'Failed inserting block candidate %s \n %j', [hashHex, err]);
|
|
}
|
|
});
|
|
|
|
notifications.sendToAll('blockFound', {
|
|
'HEIGHT': job_height,
|
|
'HASH': hashHex,
|
|
'DIFFICULTY': blockTemplate.difficulty,
|
|
'SHARES': totalShares,
|
|
'MINER': login.substring(0, 7) + '...' + login.substring(login.length - 7)
|
|
});
|
|
}
|
|
|
|
});
|
|
|
|
log('info', logSystem, 'Accepted %s share at difficulty %d/%d from %s@%s', [shareType, job.difficulty, shareDiff, login, miner.ip]);
|
|
}
|
|
|
|
function getShareBuffer (miner, job, blockTemplate, params) {
|
|
let nonce = params.nonce;
|
|
let resultHash = params.result;
|
|
let template = Buffer.alloc(blockTemplate.buffer.length);
|
|
if (!miner.proxy) {
|
|
blockTemplate.buffer.copy(template);
|
|
template.writeUInt32BE(job.extraNonce, blockTemplate.reserveOffset);
|
|
} else {
|
|
blockTemplate.buffer.copy(template);
|
|
template.writeUInt32BE(job.extraNonce, blockTemplate.reserveOffset);
|
|
template.writeUInt32BE(params.poolNonce, job.clientPoolLocation);
|
|
template.writeUInt32BE(params.workerNonce, job.clientNonceLocation);
|
|
}
|
|
|
|
try {
|
|
let shareBuffer = utils.cnUtil.construct_block_blob(template, Buffer.from(nonce, 'hex'), getMiningParams().cnBlobType);
|
|
return shareBuffer;
|
|
} catch (e) {
|
|
log('error', logSystem, "Can't get share buffer with nonce %s from %s@%s: %s", [nonce, miner.login, miner.ip, e]);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process miner share data
|
|
**/
|
|
function processShare (miner, job, blockTemplate, params) {
|
|
let shareBuffer = getShareBuffer(miner, job, blockTemplate, params)
|
|
if (!shareBuffer) {
|
|
return false
|
|
}
|
|
let resultHash = params.result
|
|
let hash;
|
|
let shareType;
|
|
|
|
if (shareTrustEnabled && miner.trust.threshold <= 0 && miner.trust.penalty <= 0 && Math.random() > miner.trust.probability) {
|
|
hash = Buffer.from(resultHash, 'hex');
|
|
shareType = 'trusted';
|
|
} else {
|
|
let miningParams = getMiningParams();
|
|
let convertedBlob = utils.cnUtil.convert_blob(shareBuffer, miningParams.cnBlobType);
|
|
let hard_fork_version = convertedBlob[0];
|
|
|
|
if (blockTemplate.isRandomX) {
|
|
hash = cryptoNight(convertedBlob, Buffer.from(blockTemplate.seed_hash, 'hex'), miningParams.cnVariant);
|
|
} else {
|
|
if (miningParams.includeHeight)
|
|
hash = cryptoNight(convertedBlob, miningParams.cnVariant, job.height);
|
|
else
|
|
hash = cryptoNight(convertedBlob, miningParams.cnVariant);
|
|
}
|
|
log('info', logSystem, 'Mining pool algorithm: %s variant %d, Hard fork version: %d', [miningParams.cnAlgorithm, miningParams.cnVariant, hard_fork_version]);
|
|
shareType = 'valid'
|
|
}
|
|
|
|
if (hash.toString('hex') !== resultHash) {
|
|
log('warn', logSystem, 'Bad hash from miner %s@%s', [miner.login, miner.ip]);
|
|
return false;
|
|
}
|
|
|
|
let hashArray = hash.toByteArray().reverse();
|
|
let hashDiff = calculateDifficultyBigInt(Buffer.from(hashArray));
|
|
let blockDifficulty = BigInt(blockTemplate.difficulty);
|
|
let jobDifficulty = BigInt(job.difficulty);
|
|
|
|
if (hashDiff >= blockDifficulty) {
|
|
|
|
apiInterfaces.rpcDaemon('submitblock', [shareBuffer.toString('hex')], function (error, result) {
|
|
if (error) {
|
|
log('error', logSystem, 'Error submitting block at height %d from %s@%s, share type: "%s" - %j', [job.height, miner.login, miner.ip, shareType, error]);
|
|
} else {
|
|
let blockFastHash = utils.cnUtil.get_block_id(shareBuffer, getMiningParams().cnBlobType).toString('hex');
|
|
log('info', logSystem,
|
|
'Block %s found at height %d by miner %s@%s - submit result: %j',
|
|
[blockFastHash.substr(0, 6), job.height, miner.login, miner.ip, result]
|
|
);
|
|
recordShareData(miner, job, hashDiff.toString(), true, blockFastHash, shareType, blockTemplate);
|
|
}
|
|
}, miningBackends.getMiningRpcConfig());
|
|
} else if (hashDiff < jobDifficulty) {
|
|
log('warn', logSystem, 'Rejected low difficulty share of %s from %s@%s', [hashDiff.toString(), miner.login, miner.ip]);
|
|
return false;
|
|
} else {
|
|
recordShareData(miner, job, hashDiff.toString(), false, null, shareType, null);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Start pool server on TCP ports
|
|
**/
|
|
let httpResponse = ' 200 OK\nContent-Type: text/plain\nContent-Length: 20\n\nMining server online';
|
|
|
|
function startPoolServerTcp (callback) {
|
|
log('info', logSystem, 'Clear values for connected workers in redis database.');
|
|
redisClient.del(config.coin + ':active_connections');
|
|
|
|
async.each(config.poolServer.ports, function (portData, cback) {
|
|
let handleMessage = function (socket, jsonData, pushMessage) {
|
|
if (!jsonData.id) {
|
|
log('warn', logSystem, 'Miner RPC request missing RPC id');
|
|
return;
|
|
} else if (!jsonData.method) {
|
|
log('warn', logSystem, 'Miner RPC request missing RPC method');
|
|
return;
|
|
} else if (!jsonData.params) {
|
|
log('warn', logSystem, 'Miner RPC request missing RPC params');
|
|
return;
|
|
}
|
|
|
|
let sendReply = function (error, result) {
|
|
if (!socket.writable) return;
|
|
let sendData = JSON.stringify({
|
|
id: jsonData.id,
|
|
jsonrpc: "2.0",
|
|
error: error ? {
|
|
code: -1,
|
|
message: error
|
|
} : null,
|
|
result: result
|
|
}) + "\n";
|
|
socket.write(sendData);
|
|
};
|
|
|
|
handleMinerMethod(jsonData.method, jsonData.params, socket.remoteAddress, portData, sendReply, pushMessage);
|
|
};
|
|
|
|
let socketResponder = function (socket) {
|
|
socket.setKeepAlive(true);
|
|
socket.setEncoding('utf8');
|
|
|
|
let dataBuffer = '';
|
|
|
|
let pushMessage = function (method, params) {
|
|
if (!socket.writable) return;
|
|
let sendData = JSON.stringify({
|
|
jsonrpc: "2.0",
|
|
method: method,
|
|
params: params
|
|
}) + "\n";
|
|
socket.write(sendData);
|
|
};
|
|
|
|
socket.on('data', function (d) {
|
|
dataBuffer += d;
|
|
if (Buffer.byteLength(dataBuffer, 'utf8') > 10240) { //10KB
|
|
dataBuffer = null;
|
|
log('warn', logSystem, 'Socket flooding detected and prevented from %s', [socket.remoteAddress]);
|
|
socket.destroy();
|
|
return;
|
|
}
|
|
if (dataBuffer.indexOf('\n') !== -1) {
|
|
let messages = dataBuffer.split('\n');
|
|
let incomplete = dataBuffer.slice(-1) === '\n' ? '' : messages.pop();
|
|
for (let i = 0; i < messages.length; i++) {
|
|
let message = messages[i];
|
|
if (message.trim() === '') continue;
|
|
let jsonData;
|
|
try {
|
|
jsonData = JSON.parse(message);
|
|
} catch (e) {
|
|
if (message.indexOf('GET /') === 0) {
|
|
if (message.indexOf('HTTP/1.1') !== -1) {
|
|
socket.end('HTTP/1.1' + httpResponse);
|
|
break;
|
|
} else if (message.indexOf('HTTP/1.0') !== -1) {
|
|
socket.end('HTTP/1.0' + httpResponse);
|
|
break;
|
|
}
|
|
}
|
|
|
|
log('warn', logSystem, 'Malformed message from %s: %s', [socket.remoteAddress, message]);
|
|
socket.destroy();
|
|
|
|
break;
|
|
}
|
|
try {
|
|
handleMessage(socket, jsonData, pushMessage);
|
|
} catch (e) {
|
|
log('warn', logSystem, 'Malformed message from ' + socket.remoteAddress + ' generated an exception. Message: ' + message);
|
|
if (e.message) log('warn', logSystem, 'Exception: ' + e.message);
|
|
}
|
|
}
|
|
dataBuffer = incomplete;
|
|
}
|
|
})
|
|
.on('error', function (err) {
|
|
if (err.code !== 'ECONNRESET')
|
|
log('warn', logSystem, 'Socket error from %s %j', [socket.remoteAddress, err]);
|
|
})
|
|
.on('close', function () {
|
|
pushMessage = function () {};
|
|
});
|
|
};
|
|
|
|
if (portData.ssl) {
|
|
if (!config.poolServer.sslCert) {
|
|
log('error', logSystem, 'Could not start server listening on port %d (SSL): SSL certificate not configured', [portData.port]);
|
|
cback(true);
|
|
} else if (!config.poolServer.sslKey) {
|
|
log('error', logSystem, 'Could not start server listening on port %d (SSL): SSL key not configured', [portData.port]);
|
|
cback(true);
|
|
} else if (!fs.existsSync(config.poolServer.sslCert)) {
|
|
log('error', logSystem, 'Could not start server listening on port %d (SSL): SSL certificate file not found (configuration error)', [portData.port]);
|
|
cback(true);
|
|
} else if (!fs.existsSync(config.poolServer.sslKey)) {
|
|
log('error', logSystem, 'Could not start server listening on port %d (SSL): SSL key file not found (configuration error)', [portData.port]);
|
|
cback(true);
|
|
} else {
|
|
let options = {
|
|
key: fs.readFileSync(config.poolServer.sslKey),
|
|
cert: fs.readFileSync(config.poolServer.sslCert),
|
|
};
|
|
|
|
if (config.poolServer.sslCA && fs.existsSync(config.poolServer.sslCA)) {
|
|
options.ca = fs.readFileSync(config.poolServer.sslCA)
|
|
}
|
|
|
|
tls.createServer(options, socketResponder)
|
|
.listen(portData.port, function (error, result) {
|
|
if (error) {
|
|
log('error', logSystem, 'Could not start server listening on port %d (SSL), error: $j', [portData.port, error]);
|
|
cback(true);
|
|
return;
|
|
}
|
|
|
|
log('info', logSystem, 'Clear values for SSL port %d in redis database.', [portData.port]);
|
|
redisClient.del(config.coin + ':ports:' + portData.port);
|
|
redisClient.hset(config.coin + ':ports:' + portData.port, 'port', portData.port);
|
|
|
|
log('info', logSystem, 'Started server listening on port %d (SSL)', [portData.port]);
|
|
cback();
|
|
});
|
|
}
|
|
} else {
|
|
net.createServer(socketResponder)
|
|
.listen(portData.port, function (error, result) {
|
|
if (error) {
|
|
log('error', logSystem, 'Could not start server listening on port %d, error: $j', [portData.port, error]);
|
|
cback(true);
|
|
return;
|
|
}
|
|
|
|
log('info', logSystem, 'Clear values for port %d in redis database.', [portData.port]);
|
|
redisClient.del(config.coin + ':ports:' + portData.port);
|
|
redisClient.hset(config.coin + ':ports:' + portData.port, 'port', portData.port);
|
|
|
|
log('info', logSystem, 'Started server listening on port %d', [portData.port]);
|
|
cback();
|
|
});
|
|
}
|
|
}, function (err) {
|
|
if (err) {
|
|
callback(false);
|
|
} else {
|
|
callback(true);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initialize pool server
|
|
**/
|
|
|
|
(function init (loop) {
|
|
async.waterfall([
|
|
function (callback) {
|
|
if (!poolStarted) {
|
|
startPoolServerTcp(function (successful) {
|
|
poolStarted = true
|
|
});
|
|
setTimeout(init, 1000, loop);
|
|
return;
|
|
}
|
|
callback(true)
|
|
}
|
|
],
|
|
function (err) {
|
|
if (loop === true) {
|
|
setTimeout(function () {
|
|
init(true);
|
|
}, config.poolServer.blockRefreshInterval);
|
|
}
|
|
}
|
|
);
|
|
})();
|