from .packet import Packet from .EnumQuery import EnumQuery from .EnumResponse import EnumResponse from .CFrame import CFrame from .DFrame import DFrame from giants.masterserver import MasterServer from .session import Session import socket import threading import traceback import uuid from utils.logger import setup_logger from giants.player import Player logger = setup_logger(__name__) class Netserver: def __init__(self, server): self.socket = None self.statssocket = None self.server = server self.addrs = [] self.guid = uuid.uuid4().bytes def run(self): self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.socket.bind((self.server.listen_ip, self.server.listen_port)) logger.debug("Listening to %s:%s", self.server.listen_ip, self.server.listen_port) gameserverthread = threading.Thread(target=self.handle_packets) gameserverthread.start() #ms = MasterServer(self.server) #statsserverthread = threading.Thread(target=ms.register_and_run) #statsserverthread.start() gameserverthread.join() #statsserverthread.join() def handle_packets(self): while True: data, addr = self.socket.recvfrom(1024) logger.debug("%s:%s > %s", addr[0], addr[1], data.hex()) self.handle_new_packet(addr, data) def handle_new_packet(self, addr, bData): pPacket = Packet(bData) first = pPacket.getByte() if len(bData) >= 4 and first & DFrame.PACKET_COMMAND_DATA: self.handle_new_dframe(addr, pPacket) elif len(bData) >= 12 and first & CFrame.PACKET_COMMAND_FRAME: self.handle_new_cframe(addr, pPacket) elif first == EnumQuery.LEAD or first == EnumResponse.LEAD: self.handle_new_enum(addr, pPacket) else: logger.error("Unknown frame received") return def handle_new_enum(self, addr, data): # EnumQuery or EnumResponse second = data.getByte() if second == EnumQuery.COMMAND: # EnumQuery try: eq = EnumQuery(data) logger.debug("Got EnumQuery, sending EnumResponse") er = EnumResponse() er.Payload = eq.Payload er.ApplicationDescSize = 0x50 er.ApplicationDescFlags = 0x41 er.MaxPlayers = self.server.maxplayers er.CurrentPlayers = len(self.server.players) er.SessionName = self.server.name er.ApplicationInstanceGUID = self.guid er.ApplicationGUID = eq.ApplicationGUID er.ApplicationReservedData = b'\xff' # Map ID er.ApplicationReservedData += b'\x00\x04\x00' er.ApplicationReservedData += b'\xd9\x05' # game version er.ApplicationReservedData += b'\x02\x92\x05\x00\x01\x00\x00\x00\x00\x00' # Unknown er.ApplicationReservedData += b'\x9c\x53\xf4\xdd' # Seems to be a checksum of current map # \x00\x00\x00\x00: [None] # \x00\x00\x00\x01: # \x9c\x53\xf4\xdd: Three Way Island - Canyons # \x1e\xe9\x39\xe1: Still Winter er.ApplicationReservedData += self.server.currentmap.mapname.encode("ascii") er.ApplicationReservedData += b'\x00' * (32 - len(self.server.currentmap.mapname)) self.send_packet(addr, er.to_packet()) except Exception: logger.error("Could not parse EnumQuery or forge EnumResponse: ") traceback.print_exc() return elif second == EnumResponse.COMMAND: # wait what? ignore that shit return else: logger.error("Unknown DPLHP command: %s", second) def handle_new_cframe(self, addr, data): try: cframe = CFrame(data) session = self.get_session(addr) if cframe.ExtOpCode == CFrame.FRAME_EXOPCODE_CONNECT: # CONNECT CFRAME if session and session.Full: logger.error("Session %s:%s was already fully connected. Ignoring.", session.ip, session.port) return elif session and not session.Full and session.SessID == cframe.SessID: # send CONNECTED logger.debug("Already partially established connection. Sending a CFRAME CONNECTED again.") session.send_cframe_connected(cframe) #session.setup_Connect_Retry_Timer() return if not self.server.accept_new_players: # ignore new players return else: logger.debug("New connection. Sending a CFRAME CONNECTED.") session = Session(self.socket) session.SessID = cframe.SessID session.ip = addr[0] session.port = addr[1] self.addrs.append(session) session.send_cframe_connected(cframe) #session.setup_Connect_Retry_Timer() elif cframe.ExtOpCode == CFrame.FRAME_EXOPCODE_CONNECTED: # CONNECTED CFRAME # check if already sent a CONNECT packet logger.debug("%s:%s sent back a CONNECTED CFrame.", session.ip, session.port) if not session: logger.error("%s sent a CONNECTED opcode without having sent a CONNECT before. GTFO.", addr) return if not cframe.SessID == session.SessID or cframe.Command & CFrame.PACKET_COMMAND_POLL: logger.error("Sent a CONNECTED packet with incorrect SessID or had COMMAND_POLL") return session.Full = True # fully connected session.cancel_Connect_Retry_Timer() elif cframe.ExtOpCode == CFrame.FRAME_EXOPCODE_SACK: if not session or not session.Full: logger.error("Received a SACK packet for a non fully connected session") return sack_sent = False if not cframe.NSeq == session.next_expected_seq: logger.error("Received CFRAME (%s) does not have the same NSeq (%s). Did we miss a packet?", cframe.NSeq, session.next_expected_seq) if not sack_sent: session.send_cframe_sack() sack_sent = True if not session.CFRAME_NRcv == cframe.NRecv: logger.error("Received CFRAME (%s) does not have same NRcv (%s). One sent packet might have been lost.", cframe.NRecv, session.CFRAME_NRcv) if not sack_sent: session.send_cframe_sack() sack_sent = True # WIP: The bNSeq, bNRcv, optional selective acknowledgment (SACK), and optional send mask fields are then processed by using the standard rules in sections 3.1.5.2.1 through 3.1.5.2.4 # TODO: A successfully validated SACK packet SHOULD count as a valid receive and thus restart the KeepAlive timer if cframe.Command & CFrame.PACKET_COMMAND_POLL: if not session: logger.error("Received a POLL packet for a non fully connected session") return logger.debug("Got a CFrame POLL. Replying with a SACK.") # must send back a ACK session.send_cframe_sack() except Exception: logger.error("Should have been a CFRAME but could not parse it") traceback.print_exc() return def handle_new_dframe(self, addr, data): try: dframe = DFrame(data) logger.debug("Received DFRAME") session = next((x for x in self.addrs if x.ip == addr[0] and x.port == addr[1]), None) if not session: logger.debug("%s sent a DFRAME without having sent a CONNECT before. GTFO.", addr) logger.debug(self.addrs) return if not dframe.Seq == session.next_expected_seq: logger.error("%s unexpected SEQ. Got %s, expected %s", addr, dframe.Seq, session.next_expected_seq) #return if dframe.Control & DFrame.PACKET_CONTROL_END_STREAM: if not session: logger.error("Received a END STREAM packet for a non fully connected session") return # disconnect resp = DFrame() resp.Command = DFrame.PACKET_COMMAND_DATA | DFrame.PACKET_COMMAND_NEW_MSG | DFrame.PACKET_COMMAND_END_MSG | DFrame.PACKET_COMMAND_RELIABLE | DFrame.PACKET_COMMAND_SEQUENTIAL resp.Control = DFrame.PACKET_CONTROL_END_STREAM resp.Seq = dframe.NRcv resp.NRcv = session.next_send session.send(resp) session.send_cframe_sack() # TODO: broadcast session has disconnected self.addrs.remove(session) return session.next_expected_seq += 1 if dframe.Payload: self.handle_game_packet(session, dframe.Payload) else: pass except Exception as e: logger.error("Could not parse DFRAME: ") traceback.print_exc() return def handle_game_packet(self, session, payload): logger.debug("Payload: %s", payload) if payload[0] == 0xc1: # connect frame? _ = payload[0:4] _ = payload[4:8] _ = payload[8:12] _ = payload[12:16] _ = payload[16:20] _ = payload[20:52] instanceguid = payload[52:68] gameguid = payload[68:84] _ = payload[84:88] _ = payload[88:92] name = payload[92:] name = name.decode("utf-16-le")[0:-1] logger.debug("%s connected!", name) player = Player(name, session) self.server.new_player(player) session.send_dframe_keepalive() r = DFrame() r.Command = DFrame.PACKET_COMMAND_DATA | DFrame.PACKET_COMMAND_RELIABLE | DFrame.PACKET_COMMAND_SEQUENTIAL | DFrame.PACKET_COMMAND_POLL | DFrame.PACKET_COMMAND_NEW_MSG | DFrame.PACKET_COMMAND_END_MSG | DFrame.PACKET_COMMAND_USER_1 r.Control = 0x00 r.Seq = session.next_send r.NRcv = session.next_expected_seq payload = Packet() payload.putLong(0xc2) # C2 = response to a C1 connection? payload.putLong(0x00) # unknown payload.putLong(0x00) # unknown payload.putLong(0x50) # unknown - 80 payload.putLong(0x41) # unknown - 65 payload.putLong(0x14) # max players payload.putLong(0x02) # current players payload.write(b'\x0e\x01\x00\x00') # unknown - 3585 - or \x16\x01\x00\x00 payload.putLong(len((self.server.name + "\x00").encode("utf-16-le"))) # SERVERNAME LENGTH for _ in range(4): payload.putLong(0) # unknown payload.putLong(0xda) # unknown - 218 - or 0xe2 payload.putLong(0x34) # unknown - 52 payload.write(self.guid) # instance guid payload.write( b"\x10\x5e\x62\xa7\x96\x1a\xd2\x11\x9a\xfc\x00\x60\x08\x45\xe5\x71") # app guid payload.write(b'\x40\xf5\x62\xe1') payload.putLong(0x21) # unknown - 33 payload.putLong(0x00) # unknown payload.putLong(0x02) # unknown - 2 payload.putLong(0x00) payload.write(b'\x45\xf5\x52\xe3') payload.putLong(0x00) payload.write(b'\x02\x04\x00\x00') # unknown payload.putLong(0x02) # unknown - 2 payload.putLong(0x00) # unknown payload.putLong(0x07) # unknown - 7 for _ in range(6): payload.putLong(0) # unknown payload.write(b'\x40\xf5\x62\xe1') # unknown - 1089823457 payload.putLong(0x00) # unknown payload.write(b'\x00\x02\x00\x00') # unknown - ? payload.putLong(0x21) # unknown - 33 payload.putLong(0x00) # unknown - 0 payload.putLong(0x07) # unknown - 7 payload.putLong(0xcc) # unknown - 204 payload.putLong(0x0e) # unknown - 6 for _ in range(4): payload.putLong(0) # unknown payload.write((name + "\x00").encode("utf-16-le")) payload.write(b'\xff') # map ID payload.write(b'\x01\x01\x00') #payload.write(b'\x00\x04\x00') payload.write(b'\xd9\x05') # game version payload.write(b'\x02\x92\x05\x00\x01\x00\x00\x00\x00\x00') # Unknown payload.write(b'\x9c\x53\xf4\xde') # Seems to be a checksum of current map payload.write(self.server.currentmap.mapname.encode("ascii")) payload.putLong(0x00) # ?? payload.write((self.server.name + "\x00").encode("utf-16-le")) r.Payload = payload.getvalue() session.send(r) if payload[0] == 0xc3: self.server.broadcast_message(name + " is a dick.") def send_packet(self, addr, packet): self.socket.sendto(packet.getvalue(), addr) logger.debug("%s:%s < %s", addr[0], addr[1], packet.getvalue().hex()) def get_session(self, iporaddr, port=None): if not port: return next((x for x in self.addrs if x.ip == iporaddr[0] and x.port == iporaddr[1]), None) else: return next((x for x in self.addrs if x.ip == iporaddr and x.port == port), None)