130 lines
4.9 KiB
Nim
130 lines
4.9 KiB
Nim
import asyncdispatch, asyncnet, net, port_prediction, strformat
|
|
|
|
from nativesockets import
|
|
SockAddr,
|
|
SockAddr_storage,
|
|
SockLen,
|
|
getSockOptInt,
|
|
setSockOptInt
|
|
from sequtils import any
|
|
|
|
type
|
|
Attempt* = object
|
|
## A hole punching attempt.
|
|
srcPorts*: seq[Port]
|
|
dstIp*: IpAddress
|
|
dstPorts*: seq[Port]
|
|
future*: Future[(AsyncSocket, Port)]
|
|
|
|
Puncher* = ref object
|
|
socks: seq[AsyncSocket]
|
|
srcPorts: seq[Port]
|
|
natProps: NatProperties
|
|
attempts: seq[Attempt]
|
|
|
|
PunchHoleError* = object of ValueError
|
|
|
|
var IPPROTO_IP {.importc: "IPPROTO_IP", header: "<netinet/in.h>".}: cint
|
|
var IP_TTL {.importc: "IP_TTL", header: "<netinet/in.h>".}: cint
|
|
|
|
const Timeout = 3000
|
|
|
|
proc `==`(a, b: Attempt): bool =
|
|
## ``==`` for hole punching attempts.
|
|
##
|
|
## Two hole punching attempts are considered equal if their ``dstIp`` is
|
|
## equal, their ``srcPorts`` overlap and their ``dstPorts`` overlap.
|
|
a.dstIp == b.dstIp and
|
|
a.srcPorts.any(proc (p: Port): bool = p in b.srcPorts) and
|
|
a.dstPorts.any(proc (p: Port): bool = p in b.dstPorts)
|
|
|
|
proc initPuncher*(socks: seq[AsyncSocket], probedSrcPorts: seq[Port]): Puncher =
|
|
assert(socks.len > 0)
|
|
var srcPorts = newSeq[Port](socks.len)
|
|
for i in 0 .. socks.len - 1:
|
|
let (_, srcPort) = socks[i].getLocalAddr()
|
|
srcPorts[i] = srcPort
|
|
let natProps = getNatProperties(srcPorts[0], probedSrcPorts)
|
|
Puncher(socks: socks, srcPorts: srcPorts, natProps: natProps)
|
|
|
|
proc punch(puncher: Puncher, peerIp: IpAddress, peerPort: Port,
|
|
peerProbedPorts: seq[Port], lowTTL: bool, msg: string):
|
|
Future[Attempt] {.async.} =
|
|
let punchFuture = newFuture[(AsyncSocket, Port)]("punch")
|
|
let natProps = getNatProperties(peerPort, peerProbedPorts)
|
|
let predictedDstPorts = predictPortRange(natProps)
|
|
result = Attempt(srcPorts: @[puncher.srcPorts[0]], dstIp: peerIp,
|
|
dstPorts: predictedDstPorts, future: punchFuture)
|
|
if puncher.natProps.natType == SymmetricRandom and puncher.srcPorts.len > 1:
|
|
# our NAT is of the evil symmetric type with random port allocation. We are
|
|
# trying to help the other peer by punching more holes using all our
|
|
# sockets.
|
|
result.srcPorts.add(puncher.srcPorts[1 .. ^1])
|
|
if puncher.attempts.contains(result):
|
|
raise newException(PunchHoleError,
|
|
"hole punching for given parameters already active")
|
|
puncher.attempts.add(result)
|
|
echo &"sending msg {msg} to {peerIp}, predicted ports: {result.dstPorts}"
|
|
var peerAddr: Sockaddr_storage
|
|
var peerSockLen: SockLen
|
|
try:
|
|
var defaultTTL: int
|
|
for i in 0 .. result.srcPorts.len - 1:
|
|
let sock = puncher.socks[i]
|
|
if lowTTL:
|
|
defaultTTL = sock.getFd.getSockOptInt(IPPROTO_IP, IP_TTL)
|
|
sock.getFd.setSockOptInt(IPPROTO_IP, IP_TTL, 2)
|
|
|
|
for dstPort in result.dstPorts:
|
|
toSockAddr(result.dstIp, dstPort, peerAddr, peerSockLen)
|
|
# TODO: replace asyncdispatch.sendTo with asyncnet.sendTo (Nim 1.4 required)
|
|
await sendTo(sock.getFd.AsyncFD, msg.cstring, msg.len,
|
|
cast[ptr SockAddr](addr peerAddr), peerSockLen)
|
|
if lowTTL:
|
|
sock.getFd.setSockOptInt(IPPROTO_IP, IP_TTL, defaultTTL)
|
|
except OSError as e:
|
|
raise newException(PunchHoleError, e.msg)
|
|
|
|
proc initiate*(puncher: Puncher, peerIp: IpAddress, peerPort: Port,
|
|
peerProbedPorts: seq[Port]): Future[Attempt] =
|
|
punch(puncher, peerIp, peerPort, peerProbedPorts, true, "SYN")
|
|
|
|
proc respond*(puncher: Puncher, peerIp: IpAddress, peerPort: Port,
|
|
peerProbedPorts: seq[Port]): Future[Attempt] =
|
|
punch(puncher, peerIp, peerPort, peerProbedPorts, false, "ACK")
|
|
|
|
proc finalize*(attempt: Attempt): Future[(AsyncSocket, Port)] {.async.} =
|
|
await attempt.future or sleepAsync(Timeout)
|
|
if attempt.future.finished:
|
|
result = attempt.future.read()
|
|
else:
|
|
raise newException(PunchHoleError, "timeout")
|
|
|
|
proc handleMsg*(puncher: Puncher, msg: string, sock: AsyncSocket,
|
|
peerIp: IpAddress, peerPort: Port) =
|
|
## Handles an incoming UDP message which may complete the Futures returned by
|
|
## ``initiate`` and ``respond``.
|
|
if msg == "SYN":
|
|
# We received a SYN packet. We ignore it because we expected it to be
|
|
# filtered by our NAT.
|
|
return
|
|
let query = Attempt(srcPorts: puncher.srcPorts, dstIp: peerIp,
|
|
dstPorts: @[peerPort])
|
|
let i = puncher.attempts.find(query)
|
|
if i != -1:
|
|
if msg == "ACK":
|
|
echo &"handling ACK message from {peerIp}:{peerPort}"
|
|
else:
|
|
echo &"handling QUIC message from {peerIp}:{peerPort}"
|
|
puncher.attempts[i].future.complete((sock, peerPort))
|
|
puncher.attempts.del(i)
|
|
else:
|
|
echo &"received unexpected packet from {peerIp}:{peerPort}"
|
|
|
|
proc handleMsg*(puncher: Puncher, msg: string, sock: AsyncSocket,
|
|
peerAddr: SockAddr | Sockaddr_storage, peerSockLen: SockLen) =
|
|
var peerIp: IpAddress
|
|
var peerPort: Port
|
|
fromSockAddr(peerAddr, peerSockLen, peerIp, peerPort)
|
|
handleMsg(puncher, msg, sock, peerIp, peerPort)
|