refactor: create raw sockets where they are used

tcp_syni.nim

@@ -94,13 +94,13 @@ proc injectTcpPacket(rawFd: AsyncFD, ipPacket: IpPacket) {.async.} =
   except OSError as e:
     raise newException(PunchHoleError, e.msg)
 
-proc captureSeqNumbers(attempt: ConnectAttempt, rawFd: AsyncFD,
-                       cb: PunchProgressCb) {.async.} =
+proc captureSeqNumbers(attempt: ConnectAttempt, cb: PunchProgressCb) {.async.} =
   # FIXME: timeout?
-  # FIXME: create raw socket here
+  let iface = fromIpAddress(attempt.srcIp)
+  let captureFd = setupEthernetCapturingSocket(iface)
   var seqNums = newSeq[uint32]()
   while seqNums.len < attempt.dstPorts.len:
-    let packet = await rawFd.recv(4000)
+    let packet = await captureFd.recv(4000)
     if packet == "":
       break
     let parsed = parseEthernetPacket(packet)
@@ -113,12 +113,13 @@ proc captureSeqNumbers(attempt: ConnectAttempt, rawFd: AsyncFD,
         if parsed.tcpPortDst.int == port.int:
           seqNums.add(parsed.tcpSeqNumber)
           break
-  closeSocket(rawFd)
+  closeSocket(captureFd)
   await cb(seqNums)
 
-proc captureAndResendAck(attempt: ConnectAttempt, captureFd: AsyncFD,
-                         injectFd: AsyncFD) {.async.} =
-  # FIXME: create raw socket here
+proc captureAndResendAck(attempt: ConnectAttempt) {.async.} =
+  let iface = fromIpAddress(attempt.srcIp)
+  let captureFd = setupEthernetCapturingSocket(iface)
+  let injectFd = setupTcpInjectingSocket()
   block loops:
     while true:
       let packet = await captureFd.recv(4000)
@@ -208,12 +209,8 @@ proc connect*(puncher: TcpSyniPuncher, srcPort: Port, dstIp: IpAddress,
                                dstPorts: predictPortRange(dstPorts))
   puncher.connectAttempts.add(attempt)
   await attempt.addFirewallRules()
-  let iface = fromIpAddress(attempt.srcIp)
-  let captureSeqFd = setupEthernetCapturingSocket(iface)
-  let captureAckFd = setupEthernetCapturingSocket(iface)
-  let injectAckFd = setupTcpInjectingSocket()
-  asyncCheck attempt.captureSeqNumbers(captureSeqFd, progressCb)
-  asyncCheck attempt.captureAndResendAck(captureAckFd, injectAckFd)
+  asyncCheck attempt.captureSeqNumbers(progressCb)
+  asyncCheck attempt.captureAndResendAck()
   try:
     let connectFuture = newFuture[AsyncSocket]("connect")
     for dstPort in attempt.dstPorts:
@@ -256,27 +253,8 @@ proc doAccept(puncher: TcpSyniPuncher, srcIp: IpAddress,
       break
   sock.close()
 
-proc accept*(puncher: TcpSyniPuncher, srcPort: Port, dstIp: IpAddress,
-             dstPorts: seq[Port],
-             seqNums: seq[uint32]): Future[AsyncSocket] {.async.} =
-  let localIp = getPrimaryIPAddr(dstIp)
-  let existingAttempts = puncher.findAcceptAttemptsByLocalAddr(localIp, srcPort)
-  if existingAttempts.len() == 0:
-    echo &"accepting connections from {dstIp}:{dstPorts[0].int}"
-    asyncCheck puncher.doAccept(localIp, srcPort)
-  else:
-    for a in existingAttempts:
-      if a.dstIp == dstIp and
-         a.dstPorts.any(proc (p: Port): bool = p in dstPorts):
-        raise newException(PunchHoleError, "hole punching for given parameters already active")
-  try:
+proc injectSynPackets(attempt: AcceptAttempt) {.async.} =
   let rawFd = setupTcpInjectingSocket()
-    let attempt = AcceptAttempt(srcIp: localIp, srcPort: srcPort, dstIp: dstIp,
-                                dstPorts: predictPortRange(dstPorts),
-                                seqNums: seqNums,
-                                future: newFuture[AsyncSocket]("accept"))
-    puncher.acceptAttempts.add(attempt)
-    await attempt.addFirewallRules()
   for dstPort in attempt.dstPorts:
     let synOut = IpPacket(protocol: tcp, ipAddrSrc: attempt.srcIp,
                           ipAddrDst: attempt.dstIp, ipTTL: 2,
@@ -295,6 +273,28 @@ proc accept*(puncher: TcpSyniPuncher, srcPort: Port, dstIp: IpAddress,
       echo &"[{synIn.ipAddrSrc}:{synIn.tcpPortSrc} -> {synIn.ipAddrDst}:{synIn.tcpPortDst}, SEQ {synIn.tcpSeqNumber}] injecting incoming SYN"
       await rawFd.injectTcpPacket(synIn)
   closeSocket(rawFd)
+
+proc accept*(puncher: TcpSyniPuncher, srcPort: Port, dstIp: IpAddress,
+             dstPorts: seq[Port],
+             seqNums: seq[uint32]): Future[AsyncSocket] {.async.} =
+  let localIp = getPrimaryIPAddr(dstIp)
+  let existingAttempts = puncher.findAcceptAttemptsByLocalAddr(localIp, srcPort)
+  if existingAttempts.len() == 0:
+    echo &"accepting connections from {dstIp}:{dstPorts[0].int}"
+    asyncCheck puncher.doAccept(localIp, srcPort)
+  else:
+    for a in existingAttempts:
+      if a.dstIp == dstIp and
+         a.dstPorts.any(proc (p: Port): bool = p in dstPorts):
+        raise newException(PunchHoleError, "hole punching for given parameters already active")
+  try:
+    let attempt = AcceptAttempt(srcIp: localIp, srcPort: srcPort, dstIp: dstIp,
+                                dstPorts: predictPortRange(dstPorts),
+                                seqNums: seqNums,
+                                future: newFuture[AsyncSocket]("accept"))
+    puncher.acceptAttempts.add(attempt)
+    await attempt.addFirewallRules()
+    await attempt.injectSynPackets()
     await attempt.future or sleepAsync(Timeout)
     await attempt.deleteFirewallRules()
     puncher.acceptAttempts.del(puncher.acceptAttempts.find(attempt))