forked from LeenkxTeam/LNXSDK
407 lines
8.8 KiB
Haxe
407 lines
8.8 KiB
Haxe
package leenkx.network.torrent.peer;
|
|
|
|
import haxe.io.Bytes;
|
|
|
|
#if (sys || kha_krom)
|
|
class TcpPeer implements IPeerChannel {
|
|
public var onOpen:Void -> Void;
|
|
public var onData:Bytes -> Void;
|
|
public var onClose:Void -> Void;
|
|
|
|
static var peers:Array<TcpPeer> = [];
|
|
#if sys
|
|
static var peersMutex = new sys.thread.Mutex();
|
|
static var ioThread:sys.thread.Thread = null;
|
|
static var wakeRecv:sys.net.UdpSocket = null;
|
|
static var wakeAddr:sys.net.Address = null;
|
|
#elseif kha_krom
|
|
static var pumpTickRef:Void -> Void = null;
|
|
#end
|
|
|
|
var open = false;
|
|
var dead = false;
|
|
var pendingSend:Array<Bytes> = [];
|
|
#if sys
|
|
var sendMutex = new sys.thread.Mutex();
|
|
#end
|
|
var head:Bytes = null;
|
|
var readBuf:Bytes = Bytes.alloc(65536);
|
|
#if kha_krom
|
|
var connectDeadline:Float = 0;
|
|
#end
|
|
|
|
#if kha_krom
|
|
var socket:leenkx.network.krom.KromSocket;
|
|
#else
|
|
var socket:sys.net.Socket;
|
|
#end
|
|
|
|
public var isOpen(get, never):Bool;
|
|
function get_isOpen():Bool return open;
|
|
|
|
public function new(host:String, port:Int, ?acceptedSocket:Dynamic, ?headData:Bytes) {
|
|
if (acceptedSocket != null) {
|
|
socket = acceptedSocket;
|
|
head = headData;
|
|
socket.setBlocking(false);
|
|
open = true;
|
|
startPump();
|
|
var self = this;
|
|
leenkx.network.torrent.TorrentClient.postMain(function() {
|
|
if (self.onOpen != null) self.onOpen();
|
|
});
|
|
return;
|
|
}
|
|
#if kha_krom
|
|
socket = new leenkx.network.krom.KromSocket();
|
|
socket.setBlocking(false);
|
|
var connectFailed = false;
|
|
try {
|
|
socket.connect(
|
|
new leenkx.network.krom.KromSocket.KromHost(host), port);
|
|
} catch(e:Dynamic) {
|
|
connectFailed = true;
|
|
}
|
|
if (connectFailed) {
|
|
dead = true;
|
|
return;
|
|
}
|
|
if (socket.isConnected()) {
|
|
open = true;
|
|
startPump();
|
|
if (onOpen != null) onOpen();
|
|
} else {
|
|
connectDeadline = haxe.Timer.stamp() + 10;
|
|
startPump();
|
|
}
|
|
#else
|
|
var self = this;
|
|
sys.thread.Thread.create(function() {
|
|
var s = new sys.net.Socket();
|
|
var err:Dynamic = null;
|
|
try {
|
|
s.connect(new sys.net.Host(host), port);
|
|
s.setBlocking(false);
|
|
} catch(e:Dynamic) {
|
|
err = e;
|
|
}
|
|
leenkx.network.torrent.TorrentClient.postMain(function() {
|
|
if (self.dead) {
|
|
try s.close() catch(e:Dynamic) {}
|
|
return;
|
|
}
|
|
if (err != null) {
|
|
self.dead = true;
|
|
if (self.onClose != null) self.onClose();
|
|
return;
|
|
}
|
|
self.socket = s;
|
|
self.open = true;
|
|
self.startPump();
|
|
if (self.onOpen != null) self.onOpen();
|
|
});
|
|
});
|
|
#end
|
|
}
|
|
|
|
function fail():Void {
|
|
dead = true;
|
|
open = false;
|
|
stopPump();
|
|
if (onClose != null) onClose();
|
|
}
|
|
|
|
function deliverHead():Void {
|
|
if (head == null || onData == null) return;
|
|
var d = head;
|
|
head = null;
|
|
onData(d);
|
|
}
|
|
|
|
#if sys
|
|
function startPump():Void register(this);
|
|
function stopPump():Void unregister(this);
|
|
|
|
static function register(p:TcpPeer):Void {
|
|
peersMutex.acquire();
|
|
if (!peers.contains(p)) peers.push(p);
|
|
if (ioThread == null) {
|
|
wakeRecv = new sys.net.UdpSocket();
|
|
wakeRecv.bind(new sys.net.Host("127.0.0.1"), 0);
|
|
wakeRecv.setBlocking(false);
|
|
var h = wakeRecv.host();
|
|
wakeAddr = new sys.net.Address();
|
|
wakeAddr.host = h.host.ip;
|
|
wakeAddr.port = h.port;
|
|
ioThread = sys.thread.Thread.create(ioLoop);
|
|
}
|
|
peersMutex.release();
|
|
ioWake();
|
|
}
|
|
|
|
static function unregister(p:TcpPeer):Void {
|
|
peersMutex.acquire();
|
|
peers.remove(p);
|
|
peersMutex.release();
|
|
ioWake();
|
|
}
|
|
|
|
static function ioWake():Void {
|
|
if (wakeAddr == null) return;
|
|
try {
|
|
wakeRecv.sendTo(Bytes.alloc(1), 0, 1, wakeAddr);
|
|
} catch(e:Dynamic) {}
|
|
}
|
|
|
|
static function ioLoop():Void {
|
|
var wakeBuf = Bytes.alloc(64);
|
|
while (true) {
|
|
peersMutex.acquire();
|
|
var snapshot = peers.copy();
|
|
peersMutex.release();
|
|
for (p in snapshot) {
|
|
try {
|
|
p.deliverHead();
|
|
} catch(e:Dynamic) {
|
|
trace("[TcpPeer.ioLoop] deliverHead threw: " + e);
|
|
}
|
|
}
|
|
var reads:Array<sys.net.Socket> = [wakeRecv];
|
|
var writes:Array<sys.net.Socket> = [];
|
|
for (p in snapshot) {
|
|
if (p.dead || p.socket == null) continue;
|
|
reads.push(p.socket);
|
|
p.sendMutex.acquire();
|
|
var hasPending = p.pendingSend.length > 0;
|
|
p.sendMutex.release();
|
|
if (hasPending) writes.push(p.socket);
|
|
}
|
|
var res = try {
|
|
sys.net.Socket.select(reads, writes, null, 0.1);
|
|
} catch(e:Dynamic) {
|
|
null;
|
|
}
|
|
if (res == null) continue;
|
|
if (res.read.contains(wakeRecv)) {
|
|
try {
|
|
while (wakeRecv.readFrom(wakeBuf, 0, 64,
|
|
new sys.net.Address()) > 0) {}
|
|
} catch(e:Dynamic) {}
|
|
}
|
|
for (s in res.read) {
|
|
if (s == wakeRecv) continue;
|
|
for (p in snapshot) {
|
|
if (p.socket == s && !p.dead) {
|
|
try {
|
|
p.ioRead();
|
|
} catch(e:Dynamic) {
|
|
trace("[TcpPeer.ioLoop] ioRead threw: "
|
|
+ e);
|
|
p.fail();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (s in res.write) {
|
|
for (p in snapshot) {
|
|
if (p.socket == s && !p.dead) {
|
|
try {
|
|
p.ioWrite();
|
|
} catch(e:Dynamic) {
|
|
trace("[TcpPeer.ioLoop] ioWrite threw: "
|
|
+ e);
|
|
p.fail();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
peersMutex.acquire();
|
|
var i = peers.length;
|
|
while (i-- > 0) {
|
|
if (peers[i].dead) peers.splice(i, 1);
|
|
}
|
|
peersMutex.release();
|
|
}
|
|
}
|
|
|
|
function ioRead():Void {
|
|
try {
|
|
while (true) {
|
|
var read = socket.input.readBytes(readBuf, 0,
|
|
readBuf.length);
|
|
if (read <= 0) {
|
|
fail();
|
|
return;
|
|
}
|
|
if (onData != null) onData(readBuf.sub(0, read));
|
|
}
|
|
} catch(e:Dynamic) {
|
|
if (isBlocked(e)) return;
|
|
fail();
|
|
}
|
|
}
|
|
|
|
function ioWrite():Void {
|
|
flushPending();
|
|
}
|
|
#elseif kha_krom
|
|
function startPump():Void {
|
|
if (pumpTickRef == null) {
|
|
pumpTickRef = pumpAll;
|
|
leenkx.network.krom.KromSocket.KromPump.add(pumpTickRef);
|
|
}
|
|
peers.push(this);
|
|
}
|
|
|
|
function stopPump():Void {
|
|
peers.remove(this);
|
|
if (peers.length == 0 && pumpTickRef != null) {
|
|
leenkx.network.krom.KromSocket.KromPump.remove(pumpTickRef);
|
|
pumpTickRef = null;
|
|
}
|
|
}
|
|
|
|
static function pumpAll():Void {
|
|
var i = peers.length;
|
|
while (i-- > 0) {
|
|
if (peers[i].dead) peers.splice(i, 1);
|
|
}
|
|
var snapshot = peers.copy();
|
|
for (p in snapshot) {
|
|
if (!p.dead) p.pumpTick();
|
|
}
|
|
if (peers.length == 0 && pumpTickRef != null) {
|
|
leenkx.network.krom.KromSocket.KromPump.remove(pumpTickRef);
|
|
pumpTickRef = null;
|
|
}
|
|
}
|
|
|
|
function pumpTick():Void {
|
|
if (dead) return;
|
|
if (connectDeadline > 0) {
|
|
if (socket.isConnected()) {
|
|
connectDeadline = 0;
|
|
open = true;
|
|
var queued = pendingSend;
|
|
pendingSend = [];
|
|
for (d in queued) send(d);
|
|
if (onOpen != null) onOpen();
|
|
} else if (haxe.Timer.stamp() > connectDeadline) {
|
|
connectDeadline = 0;
|
|
fail();
|
|
}
|
|
return;
|
|
}
|
|
deliverHead();
|
|
flushPending();
|
|
if (dead) return;
|
|
try {
|
|
while (true) {
|
|
var data = socket.recvRaw(readBuf.length);
|
|
if (data == null || data.length == 0) break;
|
|
if (onData != null) onData(data);
|
|
}
|
|
} catch(e:Dynamic) {
|
|
if (isBlocked(e)) return;
|
|
fail();
|
|
}
|
|
}
|
|
#end
|
|
|
|
#if sys
|
|
public function send(data:Bytes):Void {
|
|
if (dead) return;
|
|
sendMutex.acquire();
|
|
pendingSend.push(data);
|
|
sendMutex.release();
|
|
ioWake();
|
|
}
|
|
#else
|
|
public function send(data:Bytes):Void {
|
|
if (dead) return;
|
|
if (!open || pendingSend.length > 0) {
|
|
pendingSend.push(data);
|
|
return;
|
|
}
|
|
try {
|
|
var written = socket.sendRaw(data);
|
|
if (written < data.length) {
|
|
pendingSend.push(data.sub(written, data.length - written));
|
|
}
|
|
} catch(e:Dynamic) {
|
|
if (isBlocked(e)) {
|
|
pendingSend.push(data);
|
|
return;
|
|
}
|
|
dead = true;
|
|
open = false;
|
|
stopPump();
|
|
if (onClose != null) onClose();
|
|
}
|
|
}
|
|
#end
|
|
|
|
public static function isBlocked(e:Dynamic):Bool {
|
|
var msg = Std.string(e);
|
|
if (msg == "Blocking" || msg == "Blocked") return true;
|
|
if (Std.isOfType(e, haxe.io.Error)
|
|
&& (e:haxe.io.Error).match(haxe.io.Error.Blocked)) return true;
|
|
if (msg.indexOf("Unix_error(37") == 0) return true;
|
|
return false;
|
|
}
|
|
|
|
#if sys
|
|
function flushPending():Void {
|
|
while (open && !dead) {
|
|
sendMutex.acquire();
|
|
var empty = pendingSend.length == 0;
|
|
var d = empty ? null : pendingSend[0];
|
|
sendMutex.release();
|
|
if (empty) return;
|
|
try {
|
|
var written = socket.output.writeBytes(d, 0, d.length);
|
|
socket.output.flush();
|
|
sendMutex.acquire();
|
|
if (written < d.length) {
|
|
pendingSend[0] = d.sub(written, d.length - written);
|
|
} else {
|
|
pendingSend.shift();
|
|
}
|
|
sendMutex.release();
|
|
if (written < d.length) return;
|
|
} catch(e:Dynamic) {
|
|
if (isBlocked(e)) return;
|
|
fail();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
function flushPending():Void {
|
|
while (open && !dead && pendingSend.length > 0) {
|
|
var d = pendingSend[0];
|
|
try {
|
|
var written = socket.sendRaw(d);
|
|
if (written < d.length) {
|
|
pendingSend[0] = d.sub(written, d.length - written);
|
|
break;
|
|
}
|
|
pendingSend.shift();
|
|
} catch(e:Dynamic) {
|
|
if (isBlocked(e)) break;
|
|
fail();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#end
|
|
|
|
public function close():Void {
|
|
open = false;
|
|
dead = true;
|
|
stopPump();
|
|
try socket.close() catch(e:Dynamic) {}
|
|
}
|
|
}
|
|
#end
|