def get_empty_message(player_id): message = udp_node_msgs_pb2.ServerToClient() message.f1 = 1 message.player_id = player_id message.seqno = 1 message.f5 = 1 message.f11 = 1 message.msgnum = 1 return message
def get_empty_message(player_id): message = udp_node_msgs_pb2.ServerToClient() message.server_realm = udp_node_msgs_pb2.ZofflineConstants.RealmID message.player_id = player_id message.seqno = 1 message.stc_f5 = 1 message.stc_f11 = 1 message.msgnum = 1 return message
def handle(self): self.data = self.request.recv(1024) hello = tcp_node_msgs_pb2.TCPHello() try: hello.ParseFromString(self.data[3:-4]) except: return # send packet containing UDP server (127.0.0.1) # (very little investigation done into this packet while creating # protobuf structures hence the excessive "details" usage) msg = tcp_node_msgs_pb2.TCPServerInfo() msg.player_id = hello.player_id msg.f3 = 0 servers = msg.servers.add() if self.request.getpeername( )[0] == '127.0.0.1': # to avoid needing hairpinning udp_node_ip = "127.0.0.1" elif os.path.exists(SERVER_IP_FILE): with open(SERVER_IP_FILE, 'r') as f: udp_node_ip = f.read().rstrip('\r\n') else: udp_node_ip = "127.0.0.1" details1 = servers.details.add() details1.f1 = 1 details1.f2 = 6 details1.ip = udp_node_ip details1.port = 3022 details2 = servers.details.add() details2.f1 = 0 details2.f2 = 0 details2.ip = udp_node_ip details2.port = 3022 servers.f2 = 10 servers.f3 = 30 servers.f4 = 3 other_servers = msg.other_servers.add() wdetails1 = other_servers.details_wrapper.add() wdetails1.f1 = 1 wdetails1.f2 = 6 details3 = wdetails1.details.add() details3.CopyFrom(details1) wdetails2 = other_servers.details_wrapper.add() wdetails2.f1 = 0 wdetails2.f2 = 0 details4 = wdetails2.details.add() details4.CopyFrom(details2) other_servers.port = 3022 payload = msg.SerializeToString() # Send size of payload as 2 bytes self.request.sendall(struct.pack('!h', len(payload))) self.request.sendall(payload) player_id = hello.player_id msg = tcp_node_msgs_pb2.RecurringTCPResponse() msg.player_id = player_id msg.f3 = 0 msg.f11 = 1 payload = msg.SerializeToString() last_alive_check = int(zwift_offline.get_utc_time()) while True: #Check every 5 seconds for new updates tcpthreadevent.wait(timeout=5) try: message = udp_node_msgs_pb2.ServerToClient() message.f1 = 1 message.player_id = player_id message.world_time = zwift_offline.world_time() #PlayerUpdate if player_id in player_update_queue and len( player_update_queue[player_id] ) > 0 and player_id in online: added_player_updates = list() for player_update_proto in player_update_queue[player_id]: player_update = message.updates.add() player_update.ParseFromString(player_update_proto) #Send if 10 updates has already been added and start a new message if len(message.updates) > 9: message_payload = message.SerializeToString() self.request.sendall( struct.pack('!h', len(message_payload))) self.request.sendall(message_payload) message = udp_node_msgs_pb2.ServerToClient() message.f1 = 1 message.player_id = player_id message.world_time = zwift_offline.world_time() added_player_updates.append(player_update_proto) for player_update_proto in added_player_updates: player_update_queue[player_id].remove( player_update_proto) t = int(zwift_offline.get_utc_time()) #Check if any updates are added and should be sent to client, otherwise just keep alive every 25 seconds if len(message.updates) > 0: last_alive_check = t message_payload = message.SerializeToString() self.request.sendall( struct.pack('!h', len(message_payload))) self.request.sendall(message_payload) elif last_alive_check < t - 25: last_alive_check = t self.request.sendall(struct.pack('!h', len(payload))) self.request.sendall(payload) except: break
def handle(self): global seqno global rec global play global last_rec global last_play global play_count global last_rt global ghosts_enabled global ghosts_loaded global ghosts_started data = self.request[0] socket = self.request[1] recv = udp_node_msgs_pb2.ClientToServer() try: recv.ParseFromString(data[:-4]) except: return if recv.seqno == 1: del rec.states[:] del play.ghosts[:] seqno = 1 last_rt = 0 play_count = 0 ghosts_enabled = os.path.exists(ENABLEGHOSTS_FILE) ghosts_loaded = False ghosts_started = False rec.player_id = recv.player_id organizeGhosts(recv.player_id) t = int(time.time()) if ghosts_enabled: if not ghosts_loaded and course(recv.state): ghosts_loaded = True loadGhosts(recv.player_id, recv.state) if recv.state.roadTime and last_rt and recv.state.roadTime != last_rt: if t >= last_rec + update_freq: state = rec.states.add() state.CopyFrom(recv.state) last_rec = t if not ghosts_started and play.ghosts and roadID(recv.state) == start_road: if isForward(recv.state): if recv.state.roadTime >= start_rt >= last_rt: ghosts_started = True else: if recv.state.roadTime <= start_rt <= last_rt: ghosts_started = True last_rt = recv.state.roadTime if ghosts_started and t >= last_play + update_freq: message = udp_node_msgs_pb2.ServerToClient() message.f1 = 1 message.player_id = recv.player_id message.f5 = 1 message.f11 = 1 msgnum = 1 active_ghosts = 0 for g in play.ghosts: if len(g.states) > play_count: active_ghosts += 1 if active_ghosts: message.num_msgs = active_ghosts // 10 if active_ghosts % 10: message.num_msgs += 1 ghost_id = 1 for g in play.ghosts: if len(g.states) > play_count: if len(message.states) < 10: state = message.states.add() state.CopyFrom(g.states[play_count]) state.id = ghost_id state.worldTime = zwift_offline.world_time() else: message.world_time = zwift_offline.world_time() message.seqno = seqno message.msgnum = msgnum socket.sendto(message.SerializeToString(), self.client_address) seqno += 1 msgnum += 1 del message.states[:] state = message.states.add() state.CopyFrom(g.states[play_count]) state.id = ghost_id state.worldTime = zwift_offline.world_time() ghost_id += 1 else: message.num_msgs = 1 message.world_time = zwift_offline.world_time() message.seqno = seqno message.msgnum = msgnum socket.sendto(message.SerializeToString(), self.client_address) seqno += 1 play_count += 1 last_play = t else: message = udp_node_msgs_pb2.ServerToClient() message.f1 = 1 message.player_id = recv.player_id message.world_time = zwift_offline.world_time() message.seqno = seqno message.f5 = 1 message.f11 = 1 message.num_msgs = 1 message.msgnum = 1 socket.sendto(message.SerializeToString(), self.client_address) seqno += 1
def handle(self): self.data = self.request.recv(1024) if len(self.data) > 3 and self.data[3] != 0: print("TCPHandler hello(0) expected, got %s" % self.data[3]) return #print("TCPHandler hello: %s" % self.data.hex()) hello = udp_node_msgs_pb2.ClientToServer() try: hello.ParseFromString( self.data[4:-4] ) #2 bytes: payload length, 1 byte: =0x1 (TcpClient::sendClientToServer) 1 byte: type; payload; 4 bytes: hash #type: TcpClient::sayHello(=0x0), TcpClient::sendSubscribeToSegment(=0x1), TcpClient::processSegmentUnsubscription(=0x1) except Exception as exc: print('TCPHandler ParseFromString exception: %s' % repr(exc)) return # send packet containing UDP server (127.0.0.1) # (very little investigation done into this packet while creating # protobuf structures hence the excessive "details" usage) msg = udp_node_msgs_pb2.ServerToClient() msg.player_id = hello.player_id msg.world_time = 0 if os.path.exists(SERVER_IP_FILE): with open(SERVER_IP_FILE, 'r') as f: udp_node_ip = f.read().rstrip('\r\n') else: udp_node_ip = "127.0.0.1" details1 = msg.udp_config.relay_addresses.add() details1.lb_realm = udp_node_msgs_pb2.ZofflineConstants.RealmID details1.lb_course = 6 # watopia crowd details1.ip = udp_node_ip details1.port = 3022 details2 = msg.udp_config.relay_addresses.add() details2.lb_realm = 0 #generic load balancing realm details2.lb_course = 0 #generic load balancing course details2.ip = udp_node_ip details2.port = 3022 msg.udp_config.uc_f2 = 10 msg.udp_config.uc_f3 = 30 msg.udp_config.uc_f4 = 3 wdetails1 = msg.udp_config_vod_1.relay_addresses_vod.add() wdetails1.lb_realm = udp_node_msgs_pb2.ZofflineConstants.RealmID wdetails1.lb_course = 6 # watopia crowd details3 = wdetails1.relay_addresses.add() details3.CopyFrom(details1) wdetails2 = msg.udp_config_vod_1.relay_addresses_vod.add() wdetails2.lb_realm = 0 #generic load balancing realm wdetails2.lb_course = 0 #generic load balancing course details4 = wdetails2.relay_addresses.add() details4.CopyFrom(details2) msg.udp_config_vod_1.port = 3022 payload = msg.SerializeToString() # Send size of payload as 2 bytes self.request.sendall(struct.pack('!h', len(payload))) self.request.sendall(payload) player_id = hello.player_id #print("TCPHandler for %d" % player_id) msg = udp_node_msgs_pb2.ServerToClient() msg.player_id = player_id msg.world_time = 0 msg.stc_f11 = True payload = msg.SerializeToString() last_alive_check = int(zo.get_utc_time()) self.request.settimeout(1) #make recv non-blocking while True: self.data = b'' try: self.data = self.request.recv(1024) #print(self.data.hex()) i = 0 while i < len(self.data): size = int.from_bytes(self.data[i:i + 2], "big") packet = self.data[i:i + size + 2] #print(packet.hex()) if len(packet) == size + 2 and packet[3] == 1: subscr = udp_node_msgs_pb2.ClientToServer() try: subscr.ParseFromString(packet[4:-4]) #print(subscr) except Exception as exc: print('TCPHandler ParseFromString exception: %s' % repr(exc)) if subscr.subsSegments: msg1 = udp_node_msgs_pb2.ServerToClient() msg1.server_realm = udp_node_msgs_pb2.ZofflineConstants.RealmID msg1.player_id = subscr.player_id msg1.world_time = zo.world_time() msg1.ackSubsSegm.extend(subscr.subsSegments) payload1 = msg1.SerializeToString() self.request.sendall( struct.pack('!h', len(payload1))) self.request.sendall(payload1) #print('TCPHandler subscr: %s' % msg1.ackSubsSegm) i += size + 2 except Exception as exc: #print('TCPHandler exception: %s' % repr(exc)) #timeout is ok here pass #Check every 5 seconds for new updates #tcpthreadevent.wait(timeout=5) # no more, we will use the request timeout now try: t = int(zo.get_utc_time()) #if ZC need to be registered if player_id in zo.zc_connect_queue: # and player_id in online: zc_params = udp_node_msgs_pb2.ServerToClient() zc_params.player_id = player_id zc_params.world_time = 0 zc_params.zc_local_ip = zo.zc_connect_queue[player_id][0] zc_params.zc_local_port = zo.zc_connect_queue[player_id][ 1] #21587 zc_params.zc_protocol = udp_node_msgs_pb2.IPProtocol.TCP #=2 zc_params_payload = zc_params.SerializeToString() last_alive_check = t self.request.sendall( struct.pack('!h', len(zc_params_payload))) self.request.sendall(zc_params_payload) #print("TCPHandler register_zc %d %s" % (player_id, zc_params_payload.hex())) zo.zc_connect_queue.pop(player_id) message = udp_node_msgs_pb2.ServerToClient() message.server_realm = udp_node_msgs_pb2.ZofflineConstants.RealmID message.player_id = player_id message.world_time = zo.world_time() #PlayerUpdate if player_id in player_update_queue and len( player_update_queue[player_id] ) > 0 and player_id in online: added_player_updates = list() for player_update_proto in player_update_queue[player_id]: player_update = message.updates.add() player_update.ParseFromString(player_update_proto) #Send if 10 updates has already been added and start a new message if len(message.updates) > 9: message_payload = message.SerializeToString() self.request.sendall( struct.pack('!h', len(message_payload))) self.request.sendall(message_payload) message = udp_node_msgs_pb2.ServerToClient() message.server_realm = udp_node_msgs_pb2.ZofflineConstants.RealmID message.player_id = player_id message.world_time = zo.world_time() added_player_updates.append(player_update_proto) for player_update_proto in added_player_updates: player_update_queue[player_id].remove( player_update_proto) #Check if any updates are added and should be sent to client, otherwise just keep alive every 25 seconds if len(message.updates) > 0: last_alive_check = t message_payload = message.SerializeToString() self.request.sendall( struct.pack('!h', len(message_payload))) self.request.sendall(message_payload) elif last_alive_check < t - 25: last_alive_check = t self.request.sendall(struct.pack('!h', len(payload))) self.request.sendall(payload) except Exception as exc: print('TCPHandler loop exception: %s' % repr(exc)) break
def handle(self): global rec global play global last_rec global last_play global play_count global last_rt global last_recv global ghosts data = self.request[0] socket = self.request[1] recv = udp_node_msgs_pb2.ClientToServer() try: recv.ParseFromString(data[:-4]) except: return if enable_ghosts: t = int(time.time()) if t > last_recv + timeout: del rec.states[:] del play.ghosts[:] last_rt = 0 play_count = 0 ghosts = False last_recv = t if recv.state.roadTime: if not last_rt and not play.ghosts: loadGhosts(recv.player_id, recv.state) rec.player_id = recv.player_id if last_rt and recv.state.roadTime != last_rt: if t >= last_rec + update_freq: state = rec.states.add() state.CopyFrom(recv.state) last_rec = t if not ghosts and play.ghosts and roadID(recv.state) == start_road: if isForward(recv.state): if recv.state.roadTime >= start_rt >= last_rt: ghosts = True else: if recv.state.roadTime <= start_rt <= last_rt: ghosts = True last_rt = recv.state.roadTime message = udp_node_msgs_pb2.ServerToClient() message.f1 = 1 message.player_id = recv.player_id message.world_time = zwift_offline.world_time() message.seqno = 1 message.f5 = 1 if ghosts and t >= last_play + update_freq: ghost_id = 1 for g in play.ghosts: if len(g.states) > play_count: state = message.states.add() state.CopyFrom(g.states[play_count]) state.id = ghost_id state.worldTime = zwift_offline.world_time() ghost_id += 1 last_play = t play_count += 1 message.f11 = 1 message.num_msgs = 1 message.msgnum = 1 socket.sendto(message.SerializeToString(), self.client_address)