def sendConnectRequest(self, sourceId, targetPort):
""" Sends the connection request from sourceId to this node. """
out = ByteStream()
out.writeByte(P_CONNECT_REQUEST)
out.writeString(sourceId)
out.writeString(targetPort)
self.send(out)
def thread():
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect(PARSER_SERVER_ADDR)
except:
prnt("Failed to connect:")
prnt(traceback.format_exc())
wx.CallAfter(failureFunc)
return
stream = ByteStream()
stream.writeByte(pkt.GET_KEY)
stream.writeString(vanityKey)
sock.send(stream.toString())
data = sock.recv(1024)
sock.close()
stream = ByteStream(data)
success = stream.readByte() == 1
if success:
key = stream.readString()
wx.CallAfter(successFunc, key)
else:
wx.CallAfter(failureFunc)
def connect(self, targetId, targetPort):
self.waitForNS()
# Prevent connecting if there is already a outbound connection.
if self.getConnection(targetId, targetPort, True):
debug("Duplicate connection to %s:%s found." % (targetId, targetPort))
# Yes, this may throw an error in the app, but they shouldn't
# be creating duplicate connections anyway, so it doesn't matter.
return None
debug("Connecting to %s" % targetId)
out = ByteStream()
out.writeByte(P_CONNECT_REQUEST)
out.writeString(targetId)
out.writeString(targetPort)
self.send(out)
conn = NodeConnection(self, targetId, targetPort, True)
conn.requestTime = time.time()
self.connections.append(conn)
while True:
# Wait till connected.
if conn.state == CS_CONNECTED or conn.state >= CS_FAILED_BASE:
if conn.state == CS_FAILED_NO_NODE:
debug("Failed to connect: no such node")
elif conn.state == CS_FAILED_REJECTED:
debug("Failed to connect: rejected")
break
time.sleep(0.1)
return conn
def thread():
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect(PARSER_SERVER_ADDR)
except:
prnt("Failed to connect:")
prnt(traceback.format_exc())
wx.CallAfter(failureFunc)
return
stream = ByteStream()
stream.writeByte(pkt.GET_KEY)
stream.writeString(vanityKey)
sock.send(stream.toString())
data = sock.recv(1024)
sock.close()
stream = ByteStream(data)
success = stream.readByte() == 1
if success:
key = stream.readString()
wx.CallAfter(successFunc, key)
else:
wx.CallAfter(failureFunc)
def connect(self, targetId, targetPort):
self.waitForNS()
# Prevent connecting if there is already a outbound connection.
if self.getConnection(targetId, targetPort, True):
debug("Duplicate connection to %s:%s found."%(targetId, targetPort))
# Yes, this may throw an error in the app, but they shouldn't
# be creating duplicate connections anyway, so it doesn't matter.
return None
debug("Connecting to %s"%targetId)
out = ByteStream()
out.writeByte(P_CONNECT_REQUEST)
out.writeString(targetId)
out.writeString(targetPort)
self.send(out)
conn = NodeConnection(self, targetId, targetPort, True)
conn.requestTime = time.time()
self.connections.append(conn)
while True:
# Wait till connected.
if conn.state == CS_CONNECTED or conn.state >= CS_FAILED_BASE:
if conn.state == CS_FAILED_NO_NODE:
debug("Failed to connect: no such node")
elif conn.state == CS_FAILED_REJECTED:
debug("Failed to connect: rejected")
break
time.sleep(0.1)
return conn
def run(self):
global PUBLIC_IP_UPDATE_LAST
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind(('', REFLECTION_SERVER_PORT))
debug("Reflection Server listening on %d"%REFLECTION_SERVER_PORT)
refreshPublicIP()
PUBLIC_IP_UPDATE_LAST = time.time()
while True:
r, w, e = select([self.sock], [self.sock], [], 0)
if r:
data, addr = self.sock.recvfrom(1024)
ip = addr[0]
port = addr[1]
if ip == SERVER_GATEWAY_IP:
ip = SERVER_PUBLIC_IP
out = ByteStream()
out.writeString(ip)
out.writeInt(port)
self.sock.sendto(out.toString(), addr)
now = time.time()
if now - PUBLIC_IP_UPDATE_LAST > PUBLIC_IP_UPDATE_INTERVAL:
PUBLIC_IP_UPDATE_LAST = now
threading.Thread(target=refreshPublicIP).start()
time.sleep(0.01)
self.sock.close()
def sendConnectSuccess(self, targetId, targetPort):
""" Sends the connection success packet back to node. """
out = ByteStream()
out.writeByte(P_CONNECT_RESPONSE)
out.writeString(targetId)
out.writeString(targetPort)
out.writeByte(ERR_NO_ERROR)
self.send(out)
def sendConnectFailed(self, targetId, targetPort, errorCode):
""" Sends the connection failed packet back to node. """
out = ByteStream()
out.writeByte(P_CONNECT_RESPONSE)
out.writeString(targetId)
out.writeString(targetPort)
out.writeByte(errorCode)
self.send(out)
def send(self, data):
if isinstance(data, ByteStream):
data = data.toString()
packet = ByteStream()
packet.writeByte(P_DATA)
packet.writeString(data)
data = packet.toString()
self._send(data)
self.lastPacketSent = time.time()
def send(self, data):
if isinstance(data, ByteStream):
data = data.toString()
packet = ByteStream()
packet.writeByte(P_DATA)
packet.writeString(data)
data = packet.toString()
self._send(data)
self.lastPacketSent = time.time()
def thread():
global currentKey, raidServer, raidClient
net.node.waitForNS()
# Connect to server...
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(5)
try:
sock.connect(PARSER_SERVER_ADDR)
except:
prnt("Failed to connect:")
prnt(traceback.format_exc())
wx.CallAfter(failureFunc, "connect_failed")
return
# Write data
stream = ByteStream()
stream.writeByte(pkt.JOIN_RAID)
stream.writeByte(VERSION_INT)
stream.writeString(key)
stream.writeString(net.node.getId())
sock.send(stream.toString())
# Read data
data = sock.recv(1024)
stream = ByteStream(data)
# Process data
success = stream.readBoolean()
if success:
currentKey = key
isHost = stream.readBoolean()
serverNode = net.node.getId()
if isHost:
prnt("Raid: Joined raid, became host")
raidServer = RaidServer(sock)
raidServer.start()
else:
prnt("Raid: Joined raid, didn't become host")
serverNode = stream.readString()
sock.close()
raidClient = RaidClient(serverNode, failureFunc, successFunc)
raidClient.start()
else:
reason = stream.readString()
wx.CallAfter(failureFunc, reason)
sock.close()
def thread():
global currentKey, raidServer, raidClient
net.node.waitForNS()
# Connect to server...
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(5)
try:
sock.connect(PARSER_SERVER_ADDR)
except:
prnt("Failed to connect:")
prnt(traceback.format_exc())
wx.CallAfter(failureFunc, "connect_failed")
return
# Write data
stream = ByteStream()
stream.writeByte(pkt.JOIN_RAID)
stream.writeByte(VERSION_INT)
stream.writeString(key)
stream.writeString(net.node.getId())
sock.send(stream.toString())
# Read data
data = sock.recv(1024)
stream = ByteStream(data)
# Process data
success = stream.readBoolean()
if success:
currentKey = key
isHost = stream.readBoolean()
serverNode = net.node.getId()
if isHost:
prnt("Raid: Joined raid, became host")
raidServer = RaidServer(sock)
raidServer.start()
else:
prnt("Raid: Joined raid, didn't become host")
serverNode = stream.readString()
sock.close()
raidClient = RaidClient(serverNode, failureFunc, successFunc)
raidClient.start()
else:
reason = stream.readString()
wx.CallAfter(failureFunc, reason)
sock.close()
def sendTunnelInfo(self, targetId, targetPort, privIp, privPort, pubIp, pubPort):
out = ByteStream()
out.writeByte(P_TUNNEL_INFO)
out.writeString(targetId)
out.writeString(targetPort)
out.writeString(privIp)
out.writeInt(privPort)
out.writeString(pubIp)
out.writeInt(pubPort)
self.send(out)
def sendTunnelInfo(self, targetId, targetPort, privIp, privPort, pubIp, pubPort):
out = ByteStream()
out.writeByte(P_TUNNEL_INFO)
out.writeString(targetId)
out.writeString(targetPort)
out.writeString(privIp)
out.writeInt(privPort)
out.writeString(pubIp)
out.writeInt(pubPort)
self.send(out)
def getNewServerNode():
global currentKey, raidServer
# Connect to server...
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect(PARSER_SERVER_ADDR)
except:
prnt("Failed to connect:")
prnt(traceback.format_exc())
return
# Write data
stream = ByteStream()
stream.writeByte(pkt.JOIN_RAID)
stream.writeByte(VERSION_INT)
stream.writeString(currentKey)
stream.writeString(net.node.getId())
sock.send(stream.toString())
# Read data
data = sock.recv(1024)
stream = ByteStream(data)
# Process data
success = stream.readBoolean()
if success:
isHost = stream.readBoolean()
serverNode = net.node.getId()
if isHost:
prnt("Raid: Became host")
raidServer = RaidServer(sock)
raidServer.start()
else:
prnt("Raid: Didn't become host")
serverNode = stream.readString()
sock.close()
return serverNode
return None
def getNewServerNode():
global currentKey, raidServer
# Connect to server...
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect(PARSER_SERVER_ADDR)
except:
prnt("Failed to connect:")
prnt(traceback.format_exc())
return
# Write data
stream = ByteStream()
stream.writeByte(pkt.JOIN_RAID)
stream.writeByte(VERSION_INT)
stream.writeString(currentKey)
stream.writeString(net.node.getId())
sock.send(stream.toString())
# Read data
data = sock.recv(1024)
stream = ByteStream(data)
# Process data
success = stream.readBoolean()
if success:
isHost = stream.readBoolean()
serverNode = net.node.getId()
if isHost:
prnt("Raid: Became host")
raidServer = RaidServer(sock)
raidServer.start()
else:
prnt("Raid: Didn't become host")
serverNode = stream.readString()
sock.close()
return serverNode
return None
def handlePacket(self, data):
packet = data.readByte()
if packet == P_REGISTER:
self.id = self.ns.pushNode(self)
out = ByteStream()
out.writeByte(P_REGISTER)
out.writeString(self.id)
self.send(out)
elif packet == P_CONNECT_REQUEST:
# from source node
targetId = data.readString()
targetPort = data.readString()
debug("%s: requesting connect to %s"%(self.id, targetId))
self.ns.sendConnectRequest(self, targetId, targetPort)
elif packet == P_CONNECT_RESPONSE:
# from target nodef
targetId = data.readString()
targetPort = data.readString()
accepted = data.readBoolean()
debug("%s: response for %s=%s"%(self.id, targetId, repr(accepted)))
if accepted:
self.ns.sendConnectSuccess(self, targetId, targetPort)
else:
self.ns.sendConnectRejected(self, targetId, targetPort)
elif packet == P_TUNNEL_INFO:
targetId = data.readString()
targetPort = data.readString()
privIp = data.readString()
privPort = data.readInt()
pubIp = data.readString()
pubPort = data.readInt()
debug("%s: sending tunnel info to %s"%(self.id, targetId))
self.ns.sendTunnelInfo(self, targetId, targetPort, privIp, privPort, pubIp, pubPort)
elif packet == P_RELAY_PACKET:
targetId = data.readString()
targetPort = data.readString()
data = data.readString()
self.ns.sendRelayPacket(self, targetId, targetPort, data)
def sendRelayPacket(self, targetId, targetPort, data):
""" Sends tunnel info to a node. """
out = ByteStream()
out.writeByte(P_RELAY_PACKET)
out.writeString(targetId)
out.writeString(targetPort)
out.writeString(data)
self.send(out)
def sendRelay(self, targetId, targetPort, data, fromOutbound):
# Loopback
if self.id == targetId:
# Send it to the opposite connection.
conn = self.getConnection(targetId, targetPort, not fromOutbound)
if conn:
conn.injectRelayRead(data)
else:
debug("sendRelay: Loopback endpoint not found.")
return
if self.nodeState != NS_REGISTERED:
debug("sendRelay: Node not registered. State is %d"%self.nodeState)
return
out = ByteStream()
out.writeByte(P_RELAY_PACKET)
out.writeString(targetId)
out.writeString(targetPort)
out.writeString(data)
self.send(out)
def sendRelay(self, targetId, targetPort, data, fromOutbound):
# Loopback
if self.id == targetId:
# Send it to the opposite connection.
conn = self.getConnection(targetId, targetPort, not fromOutbound)
if conn:
conn.injectRelayRead(data)
else:
debug("sendRelay: Loopback endpoint not found.")
return
if self.nodeState != NS_REGISTERED:
debug("sendRelay: Node not registered. State is %d" % self.nodeState)
return
out = ByteStream()
out.writeByte(P_RELAY_PACKET)
out.writeString(targetId)
out.writeString(targetPort)
out.writeString(data)
self.send(out)
def updateNotConnected(self):
if self.state == CS_TUNNELING:
debug("Tunneling")
self.tunnelTicks += 1
# 0.2 x 20 = 4s for tunnel establishment
if self.tunnelTicks == 21:
# Switch to relay for now :(
debug("Fallback to relay.")
self.state = CS_CONNECTED
self.relay = True
if not self.outbound:
self.pushToPort()
return
mySyn = ByteStream()
mySyn.writeByte(P_TUNNEL_SYN)
mySyn.writeString(self.node.id)
mySyn.writeString(self.targetPort)
mySyn = mySyn.toString()
myAck = ByteStream()
myAck.writeByte(P_TUNNEL_ACK)
myAck.writeString(self.node.id)
myAck.writeString(self.targetPort)
myAck = myAck.toString()
theirSyn = ByteStream()
theirSyn.writeByte(P_TUNNEL_SYN)
theirSyn.writeString(self.targetId)
theirSyn.writeString(self.targetPort)
theirSyn = theirSyn.toString()
theirAck = ByteStream()
theirAck.writeByte(P_TUNNEL_ACK)
theirAck.writeString(self.targetId)
theirAck.writeString(self.targetPort)
theirAck = theirAck.toString()
while True:
r, w, e = select([self.sock], [self.sock], [], 0)
if r:
try:
data, addr = self.sock.recvfrom(4096)
except socket.error as e:
if e.errno == 10054:
# UDP returns a ECONNRESET for IMCP failures, ignore them
data = None
if data == theirSyn and not self.tunnelGotSyn:
self.tunnelGotSyn = True
debug("Got syn for tunnel.")
elif data == theirAck and self.tunnelGotSyn:
self.state = CS_CONNECTED
# Lock in the address
self.addr = addr
self.sock.connect(addr)
if not self.outbound:
self.pushToPort()
debug("Got ack. Tunnel established.")
break
else:
break
packetToSend = mySyn
if self.tunnelGotSyn:
self.sock.sendto(myAck, self.tunnelPrivAddr)
self.sock.sendto(myAck, self.tunnelPubAddr)
debug("Sending ack...")
self.sock.sendto(mySyn, self.tunnelPrivAddr)
self.sock.sendto(mySyn, self.tunnelPubAddr)
debug("Sending syn...")
if self.state != CS_CONNECTED and time.time() - self.acceptTime > 5:
debug("Connect timed out. current=%d, accept=%d" % (time.time(), self.acceptTime))
self.state = CS_FAILED_TIMED_OUT
self.threadStopped.set()
self.node.connectionDied(self)
def gotDataFromNodeServer(self, b):
p = b.readByte()
if p == P_REGISTER:
with self.stateLock:
self.id = b.readString()
debug("Registered with node server, id is", self.id)
self.updateNodeState(NS_REGISTERED)
elif p == P_CONNECT_REQUEST:
targetId = b.readString()
targetPort = b.readString()
port = self.getPort(targetPort)
if port == None:
debug("Rejecting unsilicited connection request from %s at port %s"%(targetId, targetPort))
out = ByteStream()
out.writeByte(P_CONNECT_RESPONSE)
out.writeString(targetId)
out.writeString(targetPort)
out.writeBoolean(False)
self.send(out)
else:
debug("Connection request from %s at port %s"%(targetId, targetPort))
out = ByteStream()
out.writeByte(P_CONNECT_RESPONSE)
out.writeString(targetId)
out.writeString(targetPort)
out.writeBoolean(True)
self.send(out)
conn = NodeConnection(self, targetId, targetPort, False)
conn.state = CS_ACCEPTED
conn.start()
self.connections.append(conn)
elif p == P_CONNECT_RESPONSE:
targetId = b.readString()
targetPort = b.readString()
errorCode = b.readByte()
state = CS_ACCEPTED
if errorCode == ERR_NO_NODE:
state = CS_FAILED_NO_NODE
elif errorCode == ERR_REJECTED:
state = CS_FAILED_REJECTED
self.updateConnectionState(targetId, targetPort, state, True)
if state == CS_ACCEPTED:
self.startConnection(targetId, targetPort, True)
else:
self.removeConnection(targetId, targetPort, True)
elif p == P_TUNNEL_INFO:
targetId = b.readString()
targetPort = b.readString()
privIp = b.readString()
privPort = b.readInt()
pubIp = b.readString()
pubPort = b.readInt()
conn = self.getConnection(targetId, targetPort)
if conn != None:
conn.gotTunnelInfo(privIp, privPort, pubIp, pubPort)
else:
debug("Got connection info for non existant connection to %s:%s"%(targetId, targetPort))
elif p == P_RELAY_PACKET:
targetId = b.readString()
targetPort = b.readString()
data = b.readString()
conn = self.getConnection(targetId, targetPort)
if conn:
conn.injectRelayRead(data)
def updateNotConnected(self):
if self.state == CS_TUNNELING:
debug("Tunneling")
self.tunnelTicks += 1
# 0.2 x 20 = 4s for tunnel establishment
if self.tunnelTicks == 21:
# Switch to relay for now :(
debug("Fallback to relay.")
self.state = CS_CONNECTED
self.relay = True
if not self.outbound:
self.pushToPort()
return
mySyn = ByteStream()
mySyn.writeByte(P_TUNNEL_SYN)
mySyn.writeString(self.node.id)
mySyn.writeString(self.targetPort)
mySyn = mySyn.toString()
myAck = ByteStream()
myAck.writeByte(P_TUNNEL_ACK)
myAck.writeString(self.node.id)
myAck.writeString(self.targetPort)
myAck = myAck.toString()
theirSyn = ByteStream()
theirSyn.writeByte(P_TUNNEL_SYN)
theirSyn.writeString(self.targetId)
theirSyn.writeString(self.targetPort)
theirSyn = theirSyn.toString()
theirAck = ByteStream()
theirAck.writeByte(P_TUNNEL_ACK)
theirAck.writeString(self.targetId)
theirAck.writeString(self.targetPort)
theirAck = theirAck.toString()
while True:
r, w, e = select([self.sock], [self.sock], [], 0)
if r:
try:
data, addr = self.sock.recvfrom(4096)
except socket.error as e:
if e.errno == 10054:
# UDP returns a ECONNRESET for IMCP failures, ignore them
data = None
if data == theirSyn and not self.tunnelGotSyn:
self.tunnelGotSyn = True
debug("Got syn for tunnel.")
elif data == theirAck and self.tunnelGotSyn:
self.state = CS_CONNECTED
# Lock in the address
self.addr = addr
self.sock.connect(addr)
if not self.outbound:
self.pushToPort()
debug("Got ack. Tunnel established.")
break
else:
break
packetToSend = mySyn
if self.tunnelGotSyn:
self.sock.sendto(myAck, self.tunnelPrivAddr)
self.sock.sendto(myAck, self.tunnelPubAddr)
debug("Sending ack...")
self.sock.sendto(mySyn, self.tunnelPrivAddr)
self.sock.sendto(mySyn, self.tunnelPubAddr)
debug("Sending syn...")
if self.state != CS_CONNECTED and time.time() - self.acceptTime > 5:
debug("Connect timed out. current=%d, accept=%d"%(time.time(), self.acceptTime))
self.state = CS_FAILED_TIMED_OUT
self.threadStopped.set()
self.node.connectionDied(self)
def gotDataFromNodeServer(self, b):
p = b.readByte()
if p == P_REGISTER:
with self.stateLock:
self.id = b.readString()
debug("Registered with node server, id is", self.id)
self.updateNodeState(NS_REGISTERED)
elif p == P_CONNECT_REQUEST:
targetId = b.readString()
targetPort = b.readString()
port = self.getPort(targetPort)
if port == None:
debug("Rejecting unsilicited connection request from %s at port %s" % (targetId, targetPort))
out = ByteStream()
out.writeByte(P_CONNECT_RESPONSE)
out.writeString(targetId)
out.writeString(targetPort)
out.writeBoolean(False)
self.send(out)
else:
debug("Connection request from %s at port %s" % (targetId, targetPort))
out = ByteStream()
out.writeByte(P_CONNECT_RESPONSE)
out.writeString(targetId)
out.writeString(targetPort)
out.writeBoolean(True)
self.send(out)
conn = NodeConnection(self, targetId, targetPort, False)
conn.state = CS_ACCEPTED
conn.start()
self.connections.append(conn)
elif p == P_CONNECT_RESPONSE:
targetId = b.readString()
targetPort = b.readString()
errorCode = b.readByte()
state = CS_ACCEPTED
if errorCode == ERR_NO_NODE:
state = CS_FAILED_NO_NODE
elif errorCode == ERR_REJECTED:
state = CS_FAILED_REJECTED
self.updateConnectionState(targetId, targetPort, state, True)
if state == CS_ACCEPTED:
self.startConnection(targetId, targetPort, True)
else:
self.removeConnection(targetId, targetPort, True)
elif p == P_TUNNEL_INFO:
targetId = b.readString()
targetPort = b.readString()
privIp = b.readString()
privPort = b.readInt()
pubIp = b.readString()
pubPort = b.readInt()
conn = self.getConnection(targetId, targetPort)
if conn != None:
conn.gotTunnelInfo(privIp, privPort, pubIp, pubPort)
else:
debug("Got connection info for non existant connection to %s:%s" % (targetId, targetPort))
elif p == P_RELAY_PACKET:
targetId = b.readString()
targetPort = b.readString()
data = b.readString()
conn = self.getConnection(targetId, targetPort)
if conn:
conn.injectRelayRead(data)
