mirror of
https://github.com/taobataoma/meanTorrent.git
synced 2026-01-15 03:42:23 +01:00
1481 lines
46 KiB
JavaScript
1481 lines
46 KiB
JavaScript
'use strict';
|
|
|
|
/**
|
|
* Module dependencies
|
|
*/
|
|
var path = require('path'),
|
|
config = require(path.resolve('./config/config')),
|
|
common = require(path.resolve('./config/lib/common')),
|
|
dataLog = require(path.resolve('./config/lib/data-log')),
|
|
mongoose = require('mongoose'),
|
|
User = mongoose.model('User'),
|
|
Torrent = mongoose.model('Torrent'),
|
|
Peer = mongoose.model('Peer'),
|
|
Complete = mongoose.model('Complete'),
|
|
Finished = mongoose.model('Finished'),
|
|
bcode = require(path.resolve('./config/lib/bencode')),
|
|
benc = require('bncode'),
|
|
ipRegex = require('ip-regex'),
|
|
moment = require('moment'),
|
|
async = require('async'),
|
|
sprintf = require('sprintf-js').sprintf,
|
|
traceLogCreate = require(path.resolve('./config/lib/tracelog')).create,
|
|
scoreUpdate = require(path.resolve('./config/lib/score')).update;
|
|
|
|
var traceConfig = config.meanTorrentConfig.trace;
|
|
var scoreConfig = config.meanTorrentConfig.score;
|
|
var hnrConfig = config.meanTorrentConfig.hitAndRun;
|
|
var announceConfig = config.meanTorrentConfig.announce;
|
|
var globalSalesConfig = config.meanTorrentConfig.torrentGlobalSales;
|
|
|
|
var appConfig = config.meanTorrentConfig.app;
|
|
|
|
var mtDebug = require(path.resolve('./config/lib/debug'));
|
|
|
|
const FAILURE_REASONS = {
|
|
100: 'Invalid request type: client request was not a HTTP GET',
|
|
101: 'Missing info_hash',
|
|
102: 'Missing peer_id',
|
|
103: 'Missing port',
|
|
104: 'Missing passkey',
|
|
|
|
150: 'Invalid infohash: infohash is not 20 bytes long',
|
|
151: 'Invalid peerid: peerid is not 20 bytes long',
|
|
152: 'Invalid numwant. Client requested more peers than allowed by tracker',
|
|
153: 'Passkey length error (length=32)',
|
|
154: 'Invalid passkey, if you changed you passkey, please redownload the torrent file from ' + appConfig.domain,
|
|
|
|
160: 'Invalid torrent info_hash',
|
|
161: 'No torrent with that info_hash has been found',
|
|
|
|
170: 'your account status is banned',
|
|
171: 'your account status is inactive',
|
|
172: 'your client is not allowed, here is the blacklist: ' + appConfig.domain + announceConfig.clientBlackListUrl,
|
|
173: 'this torrent status is not reviewed by administrators, try again later',
|
|
174: 'this torrent is only for VIP members',
|
|
175: 'your account status is idle',
|
|
176: 'you can not seeding an un-download finished torrent',
|
|
|
|
180: 'You can not open more than 1 downloading processes on the same torrent',
|
|
181: 'You can not open more than 3 seeding processes on the same torrent',
|
|
182: 'save peer failed',
|
|
183: 'save torrent failed',
|
|
184: 'save passkeyuser failed',
|
|
185: 'get H&R completeTorrent failed',
|
|
186: 'create H&R completeTorrent failed',
|
|
187: 'Illegal completed event',
|
|
|
|
190: 'You have more H&R warning, can not download any torrent now!',
|
|
191: 'not find this torrent H&R complete data',
|
|
|
|
200: 'Your total ratio is less than %.2f, can not download anything',
|
|
|
|
600: 'This tracker only supports compact mode',
|
|
900: 'Generic error'
|
|
};
|
|
|
|
const EVENT_NONE = 0;
|
|
const EVENT_COMPLETED = 1;
|
|
const EVENT_STARTED = 2;
|
|
const EVENT_STOPPED = 3;
|
|
|
|
const WANT_DEFAULT = 50;
|
|
|
|
const PEERSTATE_SEEDER = 'seeder';
|
|
const PEERSTATE_LEECHER = 'leecher';
|
|
|
|
const PEER_COMPACT_SIZE = 6;
|
|
const ANNOUNCE_INTERVAL = Math.floor(announceConfig.announceInterval / 1000);
|
|
|
|
const PARAMS_INTEGER = [
|
|
'port', 'uploaded', 'downloaded', 'left', 'compact', 'numwant', 'no_peer_id'
|
|
];
|
|
|
|
const PARAMS_STRING = [
|
|
'event',
|
|
'ipv4',
|
|
'ipv6'
|
|
];
|
|
|
|
var isGlobalSaleValid = false;
|
|
|
|
/**
|
|
* event
|
|
* @param e
|
|
* @returns {number}
|
|
*/
|
|
function event(e) {
|
|
switch (e) {
|
|
case 'completed':
|
|
return EVENT_COMPLETED;
|
|
case 'started':
|
|
return EVENT_STARTED;
|
|
case 'stopped':
|
|
return EVENT_STOPPED;
|
|
}
|
|
return EVENT_NONE;
|
|
}
|
|
|
|
/**
|
|
* eventString
|
|
* @param e
|
|
* @returns {number}
|
|
*/
|
|
function eventString(e) {
|
|
switch (e) {
|
|
case 'completed':
|
|
return 'EVENT_COMPLETED';
|
|
case 'started':
|
|
return 'EVENT_STARTED';
|
|
case 'stopped':
|
|
return 'EVENT_STOPPED';
|
|
}
|
|
return 'EVENT_NONE';
|
|
}
|
|
|
|
/**
|
|
* Failure
|
|
* @param code
|
|
* @param reason
|
|
* @constructor
|
|
*/
|
|
function Failure(code, reason) {
|
|
this.code = code;
|
|
this.reason = reason;
|
|
if (reason === undefined && typeof FAILURE_REASONS[this.code] !== 'undefined')
|
|
this.reason = FAILURE_REASONS[this.code];
|
|
else if (this.code == null)
|
|
this.code = 900;
|
|
}
|
|
|
|
/**
|
|
* Failure.prototype
|
|
* @type {{bencode: Function}}
|
|
*/
|
|
Failure.prototype = {
|
|
bencode: function () {
|
|
return 'd14:failure reason' + this.reason.length + ':' + this.reason + '12:failure codei' + this.code + 'ee';
|
|
}
|
|
};
|
|
|
|
/**
|
|
* info api
|
|
* @param req
|
|
* @param res
|
|
*/
|
|
exports.announce = function (req, res) {
|
|
req.torrent = undefined;
|
|
req.currentPeer = undefined;
|
|
req.completeTorrent = undefined;
|
|
req.selfpeer = [];
|
|
req.seeder = false;
|
|
|
|
mtDebug.debugGreen('\n\n', 'ANNOUNCE', true, req.passkeyuser);
|
|
mtDebug.debugGreen('================================================================================', 'ANNOUNCE', true, req.passkeyuser);
|
|
mtDebug.debugGreen(' ANNOUNCE REQUEST ', 'ANNOUNCE', true, req.passkeyuser);
|
|
mtDebug.debugGreen('================================================================================', 'ANNOUNCE', true, req.passkeyuser);
|
|
mtDebug.debugBlue(req.url, 'ANNOUNCE', true, req.passkeyuser);
|
|
|
|
var s = req.url.split('?');
|
|
var query = common.querystringParse(s[1]);
|
|
var passkey = req.params.passkey || query.passkey || undefined;
|
|
|
|
async.waterfall([
|
|
/*---------------------------------------------------------------
|
|
validateQueryCheck
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
var i = 0;
|
|
var p;
|
|
|
|
if (req.method !== 'GET') {
|
|
done(100);
|
|
} else if (typeof query.info_hash === 'undefined') {
|
|
done(101);
|
|
} else if (typeof query.peer_id === 'undefined') {
|
|
done(102);
|
|
} else if (typeof query.port === 'undefined') {
|
|
done(103);
|
|
} else if (query.info_hash.length !== 20) {
|
|
done(150);
|
|
} else if (query.peer_id.length !== 20) {
|
|
done(151);
|
|
} else if (typeof query.compact === 'undefined' || query.compact !== '1') {
|
|
query.compact = 0;
|
|
} else {
|
|
for (i = 0; i < PARAMS_INTEGER.length; i++) {
|
|
p = PARAMS_INTEGER[i];
|
|
if (typeof query[p] !== 'undefined') {
|
|
query[p] = parseInt(query[p].toString(), 10);
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < PARAMS_STRING.length; i++) {
|
|
p = PARAMS_STRING[i];
|
|
if (typeof query[p] !== 'undefined') {
|
|
query[p] = query[p].toString();
|
|
}
|
|
}
|
|
|
|
if (query.ipv4 === undefined) {
|
|
query.ipv4 = '';
|
|
}
|
|
if (query.ipv6 === undefined) {
|
|
query.ipv6 = '';
|
|
}
|
|
if (query.ipv6.toLowerCase().startsWith('fe80')) {
|
|
query.ipv6 = '';
|
|
}
|
|
|
|
//write ip v4 v6
|
|
query.ip = req.cf_ip;
|
|
if (ipRegex.v6({exact: true}).test(query.ip)) {
|
|
query.ipv6 = query.ip;
|
|
} else {
|
|
query.ipv4 = query.ip;
|
|
}
|
|
|
|
query.info_hash = common.binaryToHex(query.info_hash);
|
|
req.seeder = (query.left === 0) ? true : false;
|
|
|
|
// console.log(query);
|
|
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
validatePasskeyCheck
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
if (typeof passkey === 'undefined') {
|
|
done(104);
|
|
} else if (passkey.length !== 32) {
|
|
done(153);
|
|
} else if (req.passkeyuser === undefined) {
|
|
done(154);
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
validateUserCheck
|
|
check normal, banned, idle, inactive
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
switch (req.passkeyuser.status) {
|
|
case 'banned':
|
|
done(170);
|
|
break;
|
|
case 'idle':
|
|
done(175);
|
|
break;
|
|
case 'inactive':
|
|
done(171);
|
|
break;
|
|
default:
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
validateClientCheck
|
|
check client blacklist
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
var ua = req.get('User-Agent');
|
|
var inlist = false;
|
|
if (ua) {
|
|
config.meanTorrentConfig.clientBlackList.forEach(function (client) {
|
|
if (ua.toUpperCase().indexOf(client.name.toUpperCase()) >= 0) {
|
|
inlist = true;
|
|
}
|
|
});
|
|
}
|
|
if (inlist) {
|
|
done(172);
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
getTorrentItemData
|
|
torrent data include peers
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
mtDebug.debugRed('req.passkeyuser._id = ' + req.passkeyuser._id.toString(), 'ANNOUNCE', true, req.passkeyuser);
|
|
mtDebug.debugRed('req.torrent.info_hash = ' + query.info_hash, 'ANNOUNCE', true, req.passkeyuser);
|
|
Torrent.findOne({
|
|
info_hash: query.info_hash
|
|
})
|
|
.populate('user')
|
|
.populate({
|
|
path: '_peers'
|
|
})
|
|
.exec(function (err, t) {
|
|
if (err) {
|
|
done(160);
|
|
} else if (!t) {
|
|
done(161);
|
|
} else if (t.torrent_status === 'new' && !req.seeder) {
|
|
done(173);
|
|
} else {
|
|
req.torrent = t;
|
|
done(null);
|
|
}
|
|
});
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
refresh user`s vip status and ratio
|
|
update torrent isSaling status
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
req.passkeyuser.globalUpdateMethod(function (u) {
|
|
req.passkeyuser = u;
|
|
|
|
if (req.torrent.isSaling) {
|
|
req.torrent.globalUpdateMethod(function (t) {
|
|
req.torrent = t;
|
|
done(null);
|
|
});
|
|
} else {
|
|
done(null);
|
|
}
|
|
});
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
check torrent_vip and user_vip status
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
if (!req.seeder && req.torrent.torrent_vip && !req.passkeyuser.isVip) {
|
|
done(174);
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
check whether can seeding
|
|
if torrent is not exist in user`s finished list
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
mtDebug.debugGreen('---------------' + eventString(query.event) + '----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
if (req.seeder && event(query.event) !== EVENT_COMPLETED && event(query.event) !== EVENT_STOPPED) {
|
|
if (announceConfig.seedingInFinishedCheck) {
|
|
if (!req.passkeyuser._id.equals(req.torrent.user._id)) {
|
|
Finished.findOne({
|
|
user: req.passkeyuser._id,
|
|
torrent: req.torrent._id
|
|
}).exec(function (err, fini) {
|
|
if (!fini) {
|
|
done(176);
|
|
} else {
|
|
done(null);
|
|
}
|
|
});
|
|
} else {
|
|
done(null);
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
find complete torrent data
|
|
if not find and torrent is h&r and user isn`t vip, then create complete record
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
if (hnrConfig.enable && req.torrent.torrent_hnr && !req.passkeyuser.isVip) {
|
|
Complete.findOne({
|
|
torrent: req.torrent._id,
|
|
user: req.passkeyuser._id
|
|
})
|
|
.populate('user')
|
|
.populate('torrent')
|
|
.exec(function (err, t) {
|
|
if (err) {
|
|
done(185);
|
|
} else {
|
|
if (!t) {
|
|
var comp = new Complete();
|
|
comp.torrent = req.torrent;
|
|
comp.user = req.passkeyuser;
|
|
comp.complete = req.seeder ? true : false;
|
|
|
|
comp.save(function (err) {
|
|
if (err) {
|
|
done(186);
|
|
} else {
|
|
req.completeTorrent = comp;
|
|
done(null);
|
|
}
|
|
});
|
|
} else {
|
|
req.completeTorrent = t;
|
|
done(null);
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
some time, when user close download client directly, maybe some ghost peer stay in peers table and not in torrent._peers
|
|
delete them on start event of any user
|
|
----------------------------------------------------------------*/
|
|
function (done) {
|
|
if (event(query.event) === EVENT_STARTED) {
|
|
Peer.remove({
|
|
torrent: req.torrent._id,
|
|
_id: {$nin: req.torrent._peers}
|
|
}, function (err, removed) {
|
|
if (removed.n > 0) {
|
|
mtDebug.debugRed('Removed ' + removed + ' peers not in torrent._peers: ' + req.torrent._id, 'ANNOUNCE', true, req.passkeyuser);
|
|
}
|
|
done(null);
|
|
});
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
check N&R can download
|
|
if user has too more H&R warning numbers, can not download any torrent
|
|
but can continue download the warning status torrent
|
|
vip user not checked
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
if (!req.seeder && !req.passkeyuser.isVip && event(query.event) === EVENT_STARTED) {
|
|
if (hnrConfig.enable) {
|
|
if (req.passkeyuser.hnr_warning >= hnrConfig.forbiddenDownloadMinWarningNumber) {
|
|
if (!req.torrent.torrent_hnr) {
|
|
done(190);
|
|
} else {
|
|
if (!req.completeTorrent) {
|
|
done(191);
|
|
} else {
|
|
if (!req.completeTorrent.hnr_warning) {
|
|
done(190);
|
|
} else {
|
|
done(null);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
announce download check
|
|
ratio check, setting in announce.downloadCheck
|
|
vip user not checked
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
if (!req.seeder && !req.passkeyuser.isVip && !req.passkeyuser.isOper && event(query.event) === EVENT_STARTED) {
|
|
if (req.passkeyuser.ratio !== -1 && req.passkeyuser.ratio < announceConfig.downloadCheck.ratio) {
|
|
var checkTimeBegin = moment(req.passkeyuser.created).add(announceConfig.downloadCheck.checkAfterSignupDays, 'd');
|
|
if (checkTimeBegin < moment(Date.now())) {
|
|
var reason = sprintf(FAILURE_REASONS[200], announceConfig.downloadCheck.ratio);
|
|
done(200, reason);
|
|
} else {
|
|
done(null);
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
find myself peers and get current peer with same peer_id
|
|
----------------------------------------------------------------*/
|
|
function (done) {
|
|
if (req.torrent._peers.length > 0) {
|
|
for (var i = req.torrent._peers.length; i > 0; i--) {
|
|
var p = req.torrent._peers[i - 1];
|
|
if (p.user.equals(req.passkeyuser._id)) {
|
|
if (p.last_announce_at > (Date.now() - announceConfig.announceInterval - announceConfig.announceIdleTime)) { //do not add inactive peer
|
|
req.selfpeer.push(p);
|
|
} else if (p.peer_id === query.peer_id) {
|
|
req.selfpeer.push(p);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
getCurrentPeer(function () {
|
|
mtDebug.debugRed('req.currentPeer.isNewCreated = ' + req.currentPeer.isNewCreated, 'ANNOUNCE', true, req.passkeyuser);
|
|
mtDebug.debugRed('req.currentPeer._id = ' + req.currentPeer._id.toString(), 'ANNOUNCE', true, req.passkeyuser);
|
|
mtDebug.debugRed('req.currentPeer.torrent._id = ' + req.currentPeer.torrent._id, 'ANNOUNCE', true, req.passkeyuser);
|
|
done(null);
|
|
});
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
onEventStarted
|
|
if downloading, check download peer num only 1
|
|
if seeding, check seed peer num can not more than 3
|
|
numbers is in setting announceConfig.announceCheck
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
mtDebug.debugGreen('---------------CHECK USER SEED/LEECH COUNT----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
var lcount = getSelfLeecherCount();
|
|
var scount = getSelfSeederCount();
|
|
|
|
if (lcount > announceConfig.announceCheck.maxLeechNumberPerUserPerTorrent && !req.seeder) {
|
|
mtDebug.debugRed('getSelfLeecherCount = ' + lcount, 'ANNOUNCE', true, req.passkeyuser);
|
|
removeCurrPeer();
|
|
done(180);
|
|
} else if (scount > announceConfig.announceCheck.maxSeedNumberPerUserPerTorrent && req.seeder) {
|
|
mtDebug.debugRed('getSelfSeederCount = ' + scount, 'ANNOUNCE', true, req.passkeyuser);
|
|
removeCurrPeer();
|
|
done(181);
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
writeUpDownData
|
|
uploaded,downloaded
|
|
update complete data if completeTorrent is exist
|
|
if has upload and download data size, write data size,
|
|
write time of seed(complete) whether or not u/d is 0
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
mtDebug.debugGreen('---------------WRITE_UP_DOWN_DATA----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
|
|
var curru = 0;
|
|
var currd = 0;
|
|
|
|
if (!req.currentPeer.isNewCreated) {
|
|
var udr = getUDRatio();
|
|
|
|
curru = query.uploaded - req.currentPeer.peer_uploaded;
|
|
currd = query.downloaded - req.currentPeer.peer_downloaded;
|
|
|
|
if (curru > 0 || currd > 0) {
|
|
var u = Math.round(curru * udr.ur);
|
|
var d = Math.round(currd * udr.dr);
|
|
|
|
//check if is vip
|
|
if (req.passkeyuser.isVip) {
|
|
u = u * globalSalesConfig.vip.value.Ur;
|
|
d = d * globalSalesConfig.vip.value.Dr;
|
|
}
|
|
|
|
//check if is torrent uploader
|
|
if (req.passkeyuser._id.equals(req.torrent.user._id)) {
|
|
u = u * globalSalesConfig.uploader.value.Ur;
|
|
d = d * globalSalesConfig.uploader.value.Dr;
|
|
}
|
|
|
|
//write user uploaded and downloaded
|
|
var up_d = {
|
|
uploaded: u,
|
|
downloaded: d,
|
|
true_uploaded: curru,
|
|
true_downloaded: currd
|
|
};
|
|
mtDebug.debugRed(JSON.stringify(up_d), 'ANNOUNCE', true, req.passkeyuser);
|
|
|
|
if (common.examinationIsValid(req.passkeyuser)) {
|
|
up_d['examinationData.uploaded'] = u;
|
|
up_d['examinationData.downloaded'] = d;
|
|
mtDebug.debugGreen('---------------WRITE EXAMINATION DATA----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
mtDebug.debugRed('examinationData.uploaded: ' + u + ', examinationData.downloaded: ' + d, 'ANNOUNCE', true, req.passkeyuser);
|
|
}
|
|
|
|
req.passkeyuser.update({
|
|
$inc: up_d
|
|
}).exec();
|
|
|
|
//write peer speed
|
|
var sp = {};
|
|
if (curru > 0) {
|
|
sp.peer_uspeed = Math.round(curru / (Date.now() - req.currentPeer.last_announce_at) * 1000);
|
|
sp.peer_cuspeed = Math.round(curru / (Date.now() - req.currentPeer.last_announce_at) * 1000);
|
|
} else {
|
|
sp.peer_cuspeed = 0;
|
|
}
|
|
if (currd > 0) {
|
|
sp.peer_dspeed = Math.round(currd / (Date.now() - req.currentPeer.last_announce_at) * 1000);
|
|
sp.peer_cdspeed = Math.round(currd / (Date.now() - req.currentPeer.last_announce_at) * 1000);
|
|
} else {
|
|
sp.peer_cdspeed = 0;
|
|
}
|
|
req.currentPeer.update({
|
|
$set: sp
|
|
}).exec();
|
|
|
|
//update score
|
|
//upload score and download score
|
|
var totalScore = 0;
|
|
var upUnitScore = 1;
|
|
var downUnitScore = 1;
|
|
var seederUnit = 1;
|
|
var lifeUnit = 1;
|
|
|
|
var action = scoreConfig.action.seedUpDownload;
|
|
var slAction = scoreConfig.action.seedSeederAndLife;
|
|
|
|
if (action.enable) {
|
|
var uploadScore = 0;
|
|
var downloadScore = 0;
|
|
|
|
if (curru > 0 && action.uploadEnable) {
|
|
if (req.torrent.torrent_size > action.additionSize) {
|
|
upUnitScore = Math.sqrt(req.torrent.torrent_size / action.additionSize);
|
|
}
|
|
var upScore = curru / action.perlSize;
|
|
uploadScore = upUnitScore * action.uploadValue * upScore;
|
|
//uploader addition
|
|
if (req.passkeyuser._id.equals(req.torrent.user._id)) {
|
|
uploadScore = uploadScore * action.uploaderRatio;
|
|
}
|
|
}
|
|
|
|
if (currd > 0 && action.downloadEnable) {
|
|
if (req.torrent.torrent_size > action.additionSize) {
|
|
downUnitScore = Math.sqrt(req.torrent.torrent_size / action.additionSize);
|
|
}
|
|
var downScore = currd / action.perlSize;
|
|
downloadScore = downUnitScore * action.downloadValue * downScore;
|
|
}
|
|
|
|
totalScore = uploadScore + downloadScore;
|
|
if (totalScore > 0) {
|
|
//vip addition
|
|
if (action.vipRatio && req.passkeyuser.isVip) {
|
|
totalScore = totalScore * action.vipRatio;
|
|
}
|
|
|
|
if (slAction.enable) {
|
|
//torrent seeders count addition
|
|
if (req.torrent.torrent_seeds <= slAction.seederCount) {
|
|
seederUnit = slAction.seederBasicRatio + slAction.seederCoefficient * (slAction.seederCount - req.torrent.torrent_seeds + 1);
|
|
totalScore = totalScore * seederUnit;
|
|
}
|
|
|
|
//torrent life addition
|
|
var life = moment(Date.now()) - moment(req.torrent.createdat);
|
|
var days = life / (60 * 60 * 1000 * 24);
|
|
lifeUnit = slAction.lifeBasicRatio + slAction.lifeCoefficientOfDay * days;
|
|
|
|
lifeUnit = lifeUnit > slAction.lifeMaxRatio ? slAction.lifeMaxRatio : lifeUnit;
|
|
totalScore = totalScore * lifeUnit;
|
|
}
|
|
totalScore = Math.round(totalScore * 100) / 100;
|
|
|
|
action.params = {
|
|
tid: req.torrent._id
|
|
};
|
|
scoreUpdate(req, req.passkeyuser, action, totalScore, false);
|
|
mtDebug.debugRed('announce score: ' + totalScore, 'ANNOUNCE', true, req.passkeyuser);
|
|
}
|
|
}
|
|
|
|
//write logs data into db
|
|
var logData = {
|
|
query_uploaded: query.uploaded,
|
|
query_downloaded: query.downloaded,
|
|
currentPeer_uploaded: req.currentPeer.peer_uploaded,
|
|
currentPeer_downloaded: req.currentPeer.peer_downloaded,
|
|
|
|
curr_uploaded: curru,
|
|
curr_downloaded: currd,
|
|
write_uploaded: u,
|
|
write_downloaded: d,
|
|
write_score: totalScore,
|
|
|
|
isVip: req.passkeyuser.isVip,
|
|
isUploader: req.passkeyuser._id.equals(req.torrent.user._id),
|
|
|
|
salesSettingValue: {
|
|
torrentSalesValue: req.torrent.torrent_sale_status,
|
|
globalSalesValue: isGlobalSaleValid ? globalSalesConfig.global.value : undefined,
|
|
vipSalesValue: globalSalesConfig.vip.value,
|
|
uploaderSalesValue: globalSalesConfig.uploader.value
|
|
},
|
|
scoreSettingValue: {
|
|
upUnitScore: upUnitScore,
|
|
downUnitScore: downUnitScore,
|
|
seederUnit: seederUnit,
|
|
lifeUnit: lifeUnit
|
|
},
|
|
info: {
|
|
agent: req.get('User-Agent'),
|
|
ip: req.cf_ip,
|
|
port: query.port
|
|
}
|
|
};
|
|
dataLog.announceLog(req.passkeyuser, req.torrent, logData);
|
|
} else {
|
|
req.currentPeer.update({
|
|
$set: {
|
|
peer_cuspeed: 0,
|
|
peer_cdspeed: 0
|
|
}
|
|
}).exec();
|
|
}
|
|
}
|
|
|
|
//write peer data
|
|
req.currentPeer.update({
|
|
$set: {
|
|
peer_uploaded: query.uploaded,
|
|
peer_downloaded: query.downloaded,
|
|
peer_left: query.left
|
|
}
|
|
}).exec();
|
|
|
|
done(null, curru, currd);
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
write complete data to completeTorrent and refresh completed ratio
|
|
---------------------------------------------------------------*/
|
|
function (curru, currd, done) {
|
|
if (curru > 0 || currd > 0) {
|
|
if (hnrConfig.enable && req.completeTorrent) {
|
|
mtDebug.debugGreen('---------------WRITE COMPLETE DATA----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
req.completeTorrent.update({
|
|
$inc: {
|
|
total_uploaded: curru,
|
|
total_downloaded: currd
|
|
}
|
|
}, function () {
|
|
done(null);
|
|
});
|
|
} else {
|
|
done(null);
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
update H&R completeTorrent.total_seed_time
|
|
update H&R ratio in save
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
if (!req.currentPeer.isNewCreated) {
|
|
if (hnrConfig.enable && req.completeTorrent && req.completeTorrent.complete && event(query.event) !== EVENT_COMPLETED) {
|
|
mtDebug.debugGreen('---------------UPDATE H&R COMPLETE TOTAL_SEED_TIME----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
req.completeTorrent.update({
|
|
$inc: {
|
|
total_seed_time: (Date.now() - req.currentPeer.last_announce_at)
|
|
}
|
|
}, function () {
|
|
done(null);
|
|
});
|
|
} else {
|
|
done(null);
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
upload user getting score through seed timed
|
|
include torrent seeders count coefficient value and life coefficient value
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
if (!req.currentPeer.isNewCreated) {
|
|
if (req.seeder && event(query.event) !== EVENT_COMPLETED && event(query.event) !== EVENT_STARTED) {
|
|
mtDebug.debugGreen('---------------UPLOAD SCORE THROUGH SEED TIMED----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
|
|
if (req.torrent.torrent_status === 'reviewed') {
|
|
var action = scoreConfig.action.seedTimed;
|
|
var slAction = scoreConfig.action.seedSeederAndLife;
|
|
|
|
if (action.enable) {
|
|
var timed = Date.now() - req.currentPeer.last_announce_at;
|
|
var seedUnit = timed / action.additionTime;
|
|
var seedScore = seedUnit * action.timedValue;
|
|
|
|
if (seedScore > 0) {
|
|
//vip addition
|
|
if (action.vipRatio && req.passkeyuser.isVip) {
|
|
seedScore = seedScore * action.vipRatio;
|
|
}
|
|
|
|
if (slAction.enable) {
|
|
//torrent seeders count addition
|
|
if (req.torrent.torrent_seeds <= slAction.seederCount) {
|
|
var seederUnit = slAction.seederBasicRatio + slAction.seederCoefficient * (slAction.seederCount - req.torrent.torrent_seeds + 1);
|
|
seedScore = seedScore * seederUnit;
|
|
}
|
|
|
|
//torrent life addition
|
|
var life = moment(Date.now()) - moment(req.torrent.createdat);
|
|
var days = life / (60 * 60 * 1000 * 24);
|
|
var lifeUnit = slAction.lifeBasicRatio + slAction.lifeCoefficientOfDay * days;
|
|
|
|
lifeUnit = lifeUnit > slAction.lifeMaxRatio ? slAction.lifeMaxRatio : lifeUnit;
|
|
seedScore = seedScore * lifeUnit;
|
|
}
|
|
seedScore = Math.round(seedScore * 100) / 100;
|
|
|
|
action.params = {
|
|
tid: req.torrent._id
|
|
};
|
|
scoreUpdate(req, req.passkeyuser, action, seedScore);
|
|
mtDebug.debugRed('seed timed score: ' + seedScore, 'ANNOUNCE', true, req.passkeyuser);
|
|
|
|
done(null);
|
|
} else {
|
|
done(null);
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
update currentPeer.last_announce_at
|
|
update complateTorrent refreshat
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
mtDebug.debugGreen('---------------UPDATE LAST_ANNOUNCE_AT----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
|
|
if (!req.currentPeer.isNewCreated) {
|
|
req.currentPeer.update({
|
|
$set: {
|
|
last_announce_at: Date.now()
|
|
}
|
|
}).exec();
|
|
}
|
|
|
|
done(null);
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
onEventCompleted
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
if (event(query.event) === EVENT_COMPLETED) {
|
|
mtDebug.debugGreen('---------------EVENT_COMPLETED----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
|
|
if (req.currentPeer.peer_downloaded > 0 || query.downloaded > 0) {
|
|
doCompleteEvent(function () {
|
|
done(null);
|
|
});
|
|
} else {
|
|
done(187);
|
|
mtDebug.debugRed('Illegal completed event', 'ANNOUNCE', true, req.passkeyuser);
|
|
}
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
count H&R warning for user on normal up/down process
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
if (!req.currentPeer.isNewCreated) {
|
|
if (hnrConfig.enable && req.completeTorrent && event(query.event) !== EVENT_COMPLETED) {
|
|
mtDebug.debugGreen('---------------COUNT H&R WARNING FOR USER----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
req.completeTorrent.countHnRWarning(false, true);
|
|
}
|
|
}
|
|
done(null);
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
onEventStopped
|
|
count H&R warning for user when EVENT_STOPPED
|
|
delete peers
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
if (event(query.event) === EVENT_STOPPED) {
|
|
mtDebug.debugGreen('---------------EVENT_STOPPED----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
|
|
if (hnrConfig.enable && req.completeTorrent) {
|
|
req.completeTorrent.countHnRWarning(true, false);
|
|
}
|
|
removeCurrPeer(function () {
|
|
done(null);
|
|
});
|
|
} else {
|
|
done(null);
|
|
}
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
update torrent and user seeding/leeching count numbers
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
mtDebug.debugGreen('---------------COUNT TORRENT SEEDING/LEECHING----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
req.torrent.updateSeedLeechNumbers(function (slCount) {
|
|
req.passkeyuser.updateSeedLeechNumbers();
|
|
|
|
if (slCount) {
|
|
mtDebug.debugYellow(JSON.stringify(slCount), 'ANNOUNCE', true, req.passkeyuser);
|
|
req.torrent.torrent_seeds = slCount.seedCount;
|
|
req.torrent.torrent_leechers = slCount.leechCount;
|
|
}
|
|
done(null);
|
|
});
|
|
},
|
|
|
|
/*---------------------------------------------------------------
|
|
sendPeers
|
|
compact mode
|
|
---------------------------------------------------------------*/
|
|
function (done) {
|
|
var want = WANT_DEFAULT;
|
|
if (typeof query.numwant !== 'undefined' && query.numwant > 0)
|
|
want = query.numwant;
|
|
|
|
var peers = getPeers(want, req.torrent._peers);
|
|
var hasV6ip = hasV6IP(peers);
|
|
var peersFunction = hasV6ip ? peersDictionary : (query.compact === 0 ? peersDictionary : peersBinary);
|
|
var resPeers = peersFunction(peers);
|
|
|
|
var resp = bcode.encode({
|
|
interval: ANNOUNCE_INTERVAL,
|
|
complete: req.torrent.torrent_seeds,
|
|
incomplete: req.torrent.torrent_leechers,
|
|
downloaded: req.torrent.torrent_finished,
|
|
peers: resPeers
|
|
});
|
|
|
|
mtDebug.debugGreen('---------------SEND RESPONSE TO USER----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
if (peers.length > 0) {
|
|
mtDebug.debug('ip send mode: ' + (hasV6ip ? 'IPv6' : 'IPv4'), 'ANNOUNCE', true, req.passkeyuser);
|
|
}
|
|
mtDebug.debug(benc.decode(resp, 'ascii'), 'ANNOUNCE', true, req.passkeyuser);
|
|
|
|
res.writeHead(200, {'Content-Type': 'text/plain'});
|
|
res.end(resp, 'ascii');
|
|
|
|
done(null);
|
|
},
|
|
|
|
/**
|
|
* update user, torrent, peer, complete
|
|
* @param done
|
|
*/
|
|
function (done) {
|
|
req.passkeyuser.globalUpdateMethod(true);
|
|
req.torrent.globalUpdateMethod(true);
|
|
|
|
if (req.currentPeer) {
|
|
req.currentPeer.globalUpdateMethod(true);
|
|
}
|
|
|
|
if (hnrConfig.enable && req.completeTorrent) {
|
|
req.completeTorrent.globalUpdateMethod(true);
|
|
}
|
|
|
|
done(null, 'done');
|
|
}
|
|
], function (err, reason) {
|
|
if (err) {
|
|
sendError(new Failure(err, reason));
|
|
}
|
|
});
|
|
|
|
/**
|
|
* getCurrentPeer
|
|
* @returns {boolean}
|
|
*/
|
|
function getCurrentPeer(callback) {
|
|
req.selfpeer.every(function (p) {
|
|
if (p.peer_id === query.peer_id) {
|
|
req.currentPeer = p;
|
|
req.currentPeer.torrent = req.torrent;
|
|
req.currentPeer.isNewCreated = false;
|
|
|
|
//if find peer_id, but some time some client (like qbittorrent 4.1.0) the ip or port is changed, update it
|
|
if ((req.currentPeer.peer_ip !== req.cf_ip || req.currentPeer.peer_ipv4 !== query.ipv4 || req.currentPeer.peer_ipv6 !== query.ipv6 || req.currentPeer.peer_port !== query.port) && query.port !== 0) {
|
|
req.currentPeer.peer_ip = req.cf_ip;
|
|
req.currentPeer.peer_ipv4 = query.ipv4;
|
|
req.currentPeer.peer_ipv6 = query.ipv6;
|
|
req.currentPeer.peer_port = query.port;
|
|
|
|
req.currentPeer.update({
|
|
$set: {
|
|
peer_ip: req.cf_ip,
|
|
peer_ipv4: query.ipv4,
|
|
peer_ipv6: query.ipv6,
|
|
peer_port: query.port
|
|
}
|
|
}).exec();
|
|
}
|
|
|
|
if (req.seeder && req.currentPeer.peer_status !== PEERSTATE_SEEDER && event(query.event) !== EVENT_COMPLETED) {
|
|
mtDebug.debugGreen('---------------PEER STATUS CHANGED: Seeder----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
doCompleteEvent(function () {
|
|
if (callback) return callback();
|
|
});
|
|
} else {
|
|
if (callback) return callback();
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
|
|
//if not found then create req.currentPeer
|
|
if (!req.currentPeer) {
|
|
createCurrentPeer(function () {
|
|
if (callback) return callback();
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* getCurrentPeerIpMode
|
|
* @returns {string}
|
|
*/
|
|
function getCurrentPeerIpMode() {
|
|
if (req.currentPeer) {
|
|
if (req.currentPeer.isIpV4V6()) {
|
|
return 'IPV4V6';
|
|
} else if (req.currentPeer.isIpV6()) {
|
|
return 'IPV6';
|
|
} else {
|
|
return 'IPV4';
|
|
}
|
|
} else {
|
|
return 'unknown';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* doCompleteEvent
|
|
*/
|
|
function doCompleteEvent(callback) {
|
|
//write completed torrent data into finished
|
|
var finished = new Finished();
|
|
finished.user = req.passkeyuser;
|
|
finished.torrent = req.torrent;
|
|
finished.user_ip = req.cf_ip;
|
|
finished.user_agent = req.get('User-Agent');
|
|
finished.user_port = query.port;
|
|
finished.save();
|
|
|
|
traceLogCreate(req, traceConfig.action.userAnnounceFinished, {
|
|
user: req.passkeyuser._id,
|
|
torrent: req.torrent._id,
|
|
agent: req.get('User-Agent'),
|
|
ip: req.cf_ip,
|
|
port: query.port
|
|
});
|
|
|
|
req.currentPeer.update({
|
|
$set: {
|
|
peer_status: PEERSTATE_SEEDER
|
|
}
|
|
}).exec();
|
|
|
|
req.torrent.update({
|
|
$inc: {
|
|
torrent_finished: 1
|
|
}
|
|
}).exec();
|
|
|
|
req.passkeyuser.update({
|
|
$inc: {
|
|
finished: 1
|
|
}
|
|
}).exec();
|
|
|
|
//update completeTorrent complete status
|
|
if (hnrConfig.enable && req.completeTorrent) {
|
|
req.completeTorrent.update({
|
|
$set: {
|
|
complete: true
|
|
}
|
|
}, function () {
|
|
if (callback) callback();
|
|
});
|
|
} else {
|
|
if (callback) callback();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* createCurrentPeer
|
|
*/
|
|
function createCurrentPeer(callback) {
|
|
var peer = new Peer();
|
|
|
|
peer.user = req.passkeyuser;
|
|
peer.torrent = req.torrent;
|
|
peer.peer_id = query.peer_id;
|
|
peer.peer_ip = req.cf_ip;
|
|
peer.peer_ipv4 = query.ipv4;
|
|
peer.peer_ipv6 = query.ipv6;
|
|
peer.peer_port = query.port;
|
|
peer.peer_left = query.left;
|
|
peer.peer_status = req.seeder ? PEERSTATE_SEEDER : PEERSTATE_LEECHER;
|
|
peer.user_agent = req.get('User-Agent');
|
|
peer.isNewCreated = true;
|
|
peer.last_announce_at = Date.now();
|
|
|
|
if (req.seeder) {
|
|
peer.finishedat = Date.now();
|
|
}
|
|
|
|
req.selfpeer.push(peer);
|
|
|
|
req.torrent.update({
|
|
$addToSet: {_peers: peer}
|
|
}).exec();
|
|
|
|
//save ip to user
|
|
req.passkeyuser.addLeechedIp(peer.peer_ip);
|
|
req.passkeyuser.addClientAgent(peer.user_agent);
|
|
|
|
peer.save(function () {
|
|
req.currentPeer = peer;
|
|
mtDebug.debugGreen('---------------createCurrentPeer()----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
if (callback) callback();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* removeCurrPeer
|
|
*/
|
|
function removeCurrPeer(callback) {
|
|
req.selfpeer.splice(req.selfpeer.indexOf(req.currentPeer), 1);
|
|
|
|
req.torrent._peers.forEach(function (_p) {
|
|
if (_p._id.equals(req.currentPeer._id)) {
|
|
req.torrent._peers.pull(_p);
|
|
req.torrent.save();
|
|
}
|
|
});
|
|
|
|
Peer.findById(req.currentPeer._id, function (err, _p) {
|
|
_p.remove(function (err) {
|
|
if (err) {
|
|
mtDebug.debugGreen('---------------removeCurrPeer(): Error----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
} else {
|
|
mtDebug.debugGreen('---------------removeCurrPeer()----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
}
|
|
req.currentPeer = undefined;
|
|
if (callback) callback();
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* getSelfLeecherCount
|
|
* @returns {number}
|
|
*/
|
|
function getSelfLeecherCount() {
|
|
if (req.selfpeer.length === 0) {
|
|
return 0;
|
|
} else {
|
|
var i = 0;
|
|
|
|
req.selfpeer.forEach(function (p) {
|
|
if (p.peer_status === PEERSTATE_LEECHER) {
|
|
i++;
|
|
}
|
|
});
|
|
|
|
return i;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* getSelfSeederCount
|
|
* @returns {number}
|
|
*/
|
|
function getSelfSeederCount() {
|
|
if (req.selfpeer.length === 0) {
|
|
return 0;
|
|
} else {
|
|
var i = 0;
|
|
|
|
req.selfpeer.forEach(function (p) {
|
|
if (p.peer_status === PEERSTATE_SEEDER) {
|
|
i++;
|
|
}
|
|
});
|
|
|
|
return i;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* getUDRatio
|
|
* @returns {{}}
|
|
*/
|
|
function getUDRatio() {
|
|
var udr = {};
|
|
var sale = req.torrent.torrent_sale_status;
|
|
|
|
var start = moment(globalSalesConfig.global.startAt, globalSalesConfig.global.timeFormats).valueOf();
|
|
var end = start + globalSalesConfig.global.expires;
|
|
var now = Date.now();
|
|
isGlobalSaleValid = (now > start && now < end && globalSalesConfig.global.value) ? true : false;
|
|
|
|
if (isGlobalSaleValid && globalSalesConfig.global.value) {
|
|
sale = globalSalesConfig.global.value;
|
|
mtDebug.debugRed('isGlobalSaleValid = ' + isGlobalSaleValid, 'ANNOUNCE', true, req.passkeyuser);
|
|
mtDebug.debugRed('global sale value = ' + sale, 'ANNOUNCE', true, req.passkeyuser);
|
|
}
|
|
|
|
switch (sale) {
|
|
case 'U1/FREE':
|
|
udr.ur = 1;
|
|
udr.dr = 0;
|
|
break;
|
|
case 'U1/D.3':
|
|
udr.ur = 1;
|
|
udr.dr = 0.3;
|
|
break;
|
|
case 'U1/D.5':
|
|
udr.ur = 1;
|
|
udr.dr = 0.5;
|
|
break;
|
|
case 'U1/D.8':
|
|
udr.ur = 1;
|
|
udr.dr = 0.8;
|
|
break;
|
|
case 'U2/FREE':
|
|
udr.ur = 2;
|
|
udr.dr = 0;
|
|
break;
|
|
case 'U2/D.3':
|
|
udr.ur = 2;
|
|
udr.dr = 0.3;
|
|
break;
|
|
case 'U2/D.5':
|
|
udr.ur = 2;
|
|
udr.dr = 0.5;
|
|
break;
|
|
case 'U2/D.8':
|
|
udr.ur = 2;
|
|
udr.dr = 0.8;
|
|
break;
|
|
case 'U2/D1':
|
|
udr.ur = 2;
|
|
udr.dr = 1;
|
|
break;
|
|
case 'U3/FREE':
|
|
udr.ur = 3;
|
|
udr.dr = 0;
|
|
break;
|
|
case 'U3/D.5':
|
|
udr.ur = 3;
|
|
udr.dr = 0.5;
|
|
break;
|
|
case 'U3/D.8':
|
|
udr.ur = 3;
|
|
udr.dr = 0.8;
|
|
break;
|
|
case 'U3/D1':
|
|
udr.ur = 3;
|
|
udr.dr = 1;
|
|
break;
|
|
default: /* U1D1 */
|
|
udr.ur = 1;
|
|
udr.dr = 1;
|
|
}
|
|
return udr;
|
|
}
|
|
|
|
/**
|
|
* sendError
|
|
* @param failure
|
|
*/
|
|
function sendError(failure) {
|
|
var respc = failure.bencode();
|
|
mtDebug.debugRed(respc, 'ANNOUNCE', true, req.passkeyuser);
|
|
res.writeHead(200, {
|
|
'Content-Length': respc.length,
|
|
'Content-Type': 'text/plain'
|
|
});
|
|
|
|
res.end(respc);
|
|
}
|
|
|
|
/**
|
|
* getPeers
|
|
* @param count
|
|
* @param peers
|
|
* @returns []
|
|
*/
|
|
function getPeers(count, peers) {
|
|
var ps = [];
|
|
|
|
if (event(query.event) !== EVENT_STOPPED) {
|
|
mtDebug.debugGreen('---------------GET PEERS LIST----------------', 'ANNOUNCE', true, req.passkeyuser);
|
|
mtDebug.debugRed('want.count = ' + count, 'ANNOUNCE', true, req.passkeyuser);
|
|
mtDebug.debugRed('peers.length = ' + peers.length, 'ANNOUNCE', true, req.passkeyuser);
|
|
mtDebug.debugRed('user ip mode: ' + getCurrentPeerIpMode(), 'ANNOUNCE', true, req.passkeyuser);
|
|
|
|
var wantedPeers;
|
|
if (req.currentPeer.isIpV4Only()) { //ipv4
|
|
wantedPeers = peers.filter(function (p) {
|
|
return p.isIpV4();
|
|
}).sort(function () {
|
|
return 0.5 - Math.random();
|
|
}).slice(0, count);
|
|
} else { //ipv6 or v4v6
|
|
wantedPeers = peers.slice(0).sort(function () {
|
|
return 0.5 - Math.random();
|
|
}).slice(0, count);
|
|
}
|
|
|
|
wantedPeers.forEach(function (p) {
|
|
if (p !== undefined && p !== req.currentPeer) {
|
|
if (p.last_announce_at > (Date.now() - announceConfig.announceInterval - announceConfig.announceIdleTime)) { //do not send inactive peer
|
|
var tp;
|
|
if (p.user.equals(req.passkeyuser._id)) {
|
|
if (announceConfig.peersCheck.peersSendListIncludeOwnSeed) {
|
|
tp = {
|
|
id: p.peer_id,
|
|
ip: req.currentPeer.isIpV4Only() ? p.peer_ipv4 : (p.isIpV6() ? p.peer_ipv6 : p.peer_ipv4),
|
|
port: p.peer_port
|
|
};
|
|
ps.push(tp);
|
|
mtDebug.debug(p._id.toString() + ' - SELF PEER - IP:' + tp.ip + ' PORT:' + tp.port, 'ANNOUNCE', true, req.passkeyuser);
|
|
}
|
|
} else {
|
|
tp = {
|
|
id: p.peer_id,
|
|
ip: req.currentPeer.isIpV4Only() ? p.peer_ipv4 : (p.isIpV6() ? p.peer_ipv6 : p.peer_ipv4),
|
|
port: p.peer_port
|
|
};
|
|
ps.push(tp);
|
|
mtDebug.debug(p._id.toString() + ' IP:' + tp.ip + ' PORT:' + tp.port, 'ANNOUNCE', true, req.passkeyuser);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return ps;
|
|
}
|
|
|
|
/**
|
|
* hasV6IP
|
|
* @param peers
|
|
* @returns {boolean}
|
|
*/
|
|
function hasV6IP(peers) {
|
|
for (let p of peers) {
|
|
if (ipRegex.v6({exact: true}).test(p.ip)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* peersDictionary
|
|
* @param peers
|
|
*/
|
|
function peersDictionary(peers) {
|
|
return peers.map(function (peer) {
|
|
if (query.no_peer_id === 1) {
|
|
return {
|
|
'ip': peer.ip,
|
|
'port': peer.port
|
|
};
|
|
} else {
|
|
return {
|
|
'peer id': peer.id,
|
|
'ip': peer.ip,
|
|
'port': peer.port
|
|
};
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* peersBinary
|
|
* @param peers
|
|
* @returns {string}
|
|
*/
|
|
function peersBinary(peers) {
|
|
var tokens = [];
|
|
peers.forEach(function (peer) {
|
|
tokens.push(peerBinary(peer.ip, peer.port));
|
|
});
|
|
return tokens.join('');
|
|
}
|
|
|
|
/**
|
|
* peerBinary
|
|
* @param ip
|
|
* @param port
|
|
* @returns {string}
|
|
*/
|
|
function peerBinary(ip, port) {
|
|
var tokens = [];
|
|
|
|
var octets = ip.split('.');
|
|
if (octets.length !== 4) return '';
|
|
|
|
octets.forEach(function (octet) {
|
|
var val = parseInt(octet, 10);
|
|
if (!isNaN(val)) tokens.push(val);
|
|
});
|
|
if (tokens.length !== 4) return '';
|
|
|
|
tokens.push((port >> 8) & 0xff);
|
|
tokens.push(port & 0xff);
|
|
|
|
return String.fromCharCode.apply(tokens, tokens);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* userByPasskey
|
|
* @param req
|
|
* @param res
|
|
* @param next
|
|
* @param pk
|
|
* @returns {*}
|
|
*/
|
|
exports.userByPasskey = function (req, res, next, pk) {
|
|
User.findOne({passkey: pk})
|
|
.exec(function (err, u) {
|
|
if (u) {
|
|
req.passkeyuser = u;
|
|
} else {
|
|
req.passkeyuser = undefined;
|
|
}
|
|
next();
|
|
});
|
|
};
|