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 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 recv(self, raw=False): while len(self.pendingRecv) == 0 and not self.closed: time.sleep(0.1) if self.closed: return None data = self.pendingRecv.pop(0) return ByteStream(data) if not raw else data
def __init__(self,filename): if filename == None: raise(Exception("Null File Name.")) self.bs = ByteStream(filename) self._dex = dxlib.dx_parse(self.bs._bs)
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 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 connectToNodeServer(self): debug("Connecting to node server @ %s"%repr(self.nodeServer)) while True: self.updateNodeState(NS_CONNECTING) if self.sock != None: self.sock.close() self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sockQueue = net_helpers.SocketQueue(self.sock) self.sockPacker = net_helpers.Packer() try: self.sock.connect(self.nodeServer) break except: debug("Connect failed, trying again in 5s...") self.updateNodeState(NS_FAILED) time.sleep(5) self.updateNodeState(NS_CONNECTED) debug("Connected.") # Reset last packet counter so we don't time out. self.lastPacketReceived = time.time() # send register packet debug("Registering with node server...") b = ByteStream() b.writeByte(P_REGISTER) self.send(b)
def test_can_write_one_then_read_as_two(): b = ByteStream() b.write(b"hello, world") read = b.read(6) assert read.tobytes() == b"hello," read = b.read(6) assert read.tobytes() == b" world"
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 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 test_distance_only_measured_to_next_matching_byte(): b = ByteStream() b.write(b"abcabc") distance = b.until(97) assert distance == 1 distance = b.until(98) assert distance == 2 distance = b.until(99) assert distance == 3
def test_can_resume_reading_after_nothing_available(): b = ByteStream() b.write(b"hello") b.read(5) read = b.read(1) assert read is None b.write(b"world") read = b.read(5) assert read.tobytes() == b"world"
def test_can_find_bytes(): b = ByteStream() b.write(b"abc") distance = b.until(97) assert distance == 1 distance = b.until(98) assert distance == 2 distance = b.until(99) assert distance == 3
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 reflectAddress(self): sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.sendto('', self.reflectionServer) privIp, privPort = sock.getsockname() data = sock.recv(128) sock.close() response = ByteStream(data) pubIp = response.readString() pubPort = response.readInt() return (privPort, pubIp, pubPort)
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 test_can_find_bytes_several_chunks_ahead(): b = ByteStream() b.write(b"xxx") b.write(b"xxx") b.write(b"xxx") b.write(b"abc") distance = b.until(97) assert distance == 10 distance = b.until(98) assert distance == 11 distance = b.until(99) assert distance == 12
def test_can_write_several_then_read_across_boundaries(): b = ByteStream() b.write(b"aaa") b.write(b"bbb") b.write(b"ccc") b.write(b"ddd") read = b.read(4) assert read.tobytes() == b"aaab" read = b.read(4) assert read.tobytes() == b"bbcc" read = b.read(4) assert read.tobytes() == b"cddd"
def run(self): prnt("RaidServer: Booting up...") self.port = net.node.bind("swap:raid") self.centralSock.setblocking(False) while not self.stoppedEvent.isSet(): now = time() # Central server r, w, e = select([self.centralSock], [self.centralSock], [], 0) if r: data = self.centralSock.recv(1024) stream = ByteStream(data) packetType = stream.readByte() if self.port.connectionPending(): conn = self.port.accept() self.clientList.append({'conn': conn, 'playerInfo': None}) for client in self.clientList: conn = client['conn'] if conn.recvPending(): data = conn.recv() if data == None: playerName = client['playerInfo']['name'] if client[ 'playerInfo'] else "<NoInfo>" prnt("Client (%s) left raid, reason=%s" % (playerName, fuzion.formatError( conn.closedReason))) self.lastRaidUpdatePoke = time() self.clientList.remove(client) continue packetType = data.readByte() if packetType == pkt.PLAYER_UPDATE: self.processPlayerUpdate(client, data) if now - self.lastRaidUpdateSent > 2 and now - self.lastRaidUpdatePoke < 5: self.sendRaidUpdate() self.lastRaidUpdateSent = now sleep(0.1) self.port.close() for client in self.clientList: conn = client['conn'] conn.close() self.centralSock.close() prnt("RaidServer: Shutting down...")
def test_can_measure_how_much_available(): b = ByteStream() assert b.available() == 0 b.write(b"hello") assert b.available() == 5 b.read(2) assert b.available() == 3 b.read(2) assert b.available() == 1 b.read(2) assert b.available() == 1 b.read(1) assert b.available() == 0
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 setUp(self): self.HasUri = namedtuple('HasUri', ['uri']) self.bytestream = ByteStream(chunksize=3) self.port = '9876' path = os.path.dirname(__file__) server = os.path.join(path, 'dummyserver.py') self.expected = ''.join(uuid4().hex for _ in xrange(100)) devnull = open(os.devnull, 'w') self.process = subprocess.Popen( [sys.executable, server, self.port, self.expected], stdout=devnull, stderr=devnull) time.sleep(0.1)
def mainLoop(self): self.connectToNodeServer() while True: now = time.time() if now - self.lastPacketReceived > NS_KEEPALIVE_TIMEOUT: debug("Timed out.") self._disconnected() continue r, w, e = select([self.sock], [self.sock], [self.sock], 0) if r or e: try: d = self.sock.recv(2048) except socket.error as e: d = None if e.errno == 10053: debug("Connection aborted by software, maybe firewall?") else: debug("recv() error: errno=%d"%e.errno) if not d: self._disconnected() continue self.sockPacker.read(d) self.lastPacketReceived = now packet = self.sockPacker.popPacket() if packet: packet = ByteStream(packet) self.gotDataFromNodeServer(packet) if w: if now - self.lastKeepAliveSent > NS_KEEPALIVE_INTERVAL: self.lastKeepAliveSent = now self.send('') self.sockQueue.processNext() # Process stale requested connections. with self.connectionsLock: for connection in self.connections: if connection.state == CS_REQUESTED and now - connection.requestTime > 4: debug("Connection request for %s:%s timed out."%(connection.targetId, connection.targetPort)) connection.state = CS_FAILED_TIMED_OUT self.connections.remove(connection) time.sleep(0.001) self.sock.close()
def closeInternal(self, reason): with self.closedLock: if self.closed: return if reason == ERR_CLOSED_BY_SELF: packet = ByteStream() packet.writeByte(P_CLOSE) self._send(packet.toString()) self.threadStopped.set() self.node.connectionDied(self) self.closed = True self.closedReason = reason if not self.loopback and not self.relay: self.sock.close()
def test_distance_changes_after_read(): b = ByteStream() b.write(b"abcbca") distance = b.until(97) assert distance == 1 distance = b.until(98) assert distance == 2 distance = b.until(99) assert distance == 3 b.read(3) distance = b.until(97) assert distance == 3 distance = b.until(98) assert distance == 1 distance = b.until(99) assert distance == 2
def test_can_accept_chunksize_implementing_int(self): class SemanticChunksize(object): THING_SIZE_BYTES = 64 def __init__(self, n_things=10): self.n_things = n_things def __int__(self): return self.n_things * self.THING_SIZE_BYTES bs = ByteStream(chunksize=SemanticChunksize(n_things=100)) bio = BytesIO() bio.write(os.urandom(int(1e5))) bio.seek(0) chunks = list(bs._process(bio)) self.assertEqual(6400, len(chunks[0]))
def run(self): while True: now = time.time() r, w, e = select([self.sock], [self.sock], [self.sock], 0) if r or e: try: data = self.sock.recv(2048) except socket.error as e: debug("%s: .recv() died! errno=%d"%(self.id, e.errno)) break if not data: if self.id: debug("%s: closed"%self.id) else: debug("lost unknown connection") break self.sockPacker.read(data) self.lastPacketReceived = now packet = self.sockPacker.popPacket() if packet: packet = ByteStream(packet) try: self.handlePacket(packet) except: debug("handlePacket crashed.") debug(traceback.format_exc()) if now - self.lastPacketReceived > KEEPALIVE_TIMEOUT: debug("%s: timed out."%self.id) self.sock.close() break if w: if now - self.lastKeepAliveSent > KEEPALIVE_INTERVAL: self.lastKeepAliveSent = now self.send('') self.sockQueue.processNext() time.sleep(0.01) self.ns.nodeDied(self.id)
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)