hipstercat/giantsd
1
0
Fork 1
Code Issues Pull Requests Releases Wiki Activity
30aa2a81c7
giantsd/dpnet/netserver.py

422 lines
21 KiB
Python
Raw Normal View History

Initial commit
2019-01-22 01:30:42 +01:00
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
Dynamic packet payloads
2019-01-23 10:54:51 +01:00
import struct
Moar things
2019-02-05 01:35:22 +01:00
from _datetime import datetime
Initial commit
2019-01-22 01:30:42 +01:00
from utils.logger import setup_logger
Moar things
2019-02-05 01:35:22 +01:00
from giants.player import Player, PlayerPhases
import time
from giants import APPLICATION_GUID
from .DN_MSG_INTERNAL_SEND_CONNECT_INFO import DN_MSG_INTERNAl_SEND_CONNECT_INFO
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
import asyncio
Initial commit
2019-01-22 01:30:42 +01:00
logger = setup_logger(__name__)
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
class Netserver(asyncio.DatagramProtocol):
Initial commit
2019-01-22 01:30:42 +01:00
def __init__(self, server):
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
self.remotesocket = None
Initial commit
2019-01-22 01:30:42 +01:00
self.statssocket = None
self.server = server
self.addrs = []
self.guid = uuid.uuid4().bytes
Moar things
2019-02-05 01:35:22 +01:00
self.incoming_packets = []
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
super().__init__()
def connection_made(self, transport):
logger.debug("Connection made")
self.remotesocket = transport
Initial commit
2019-01-22 01:30:42 +01:00
def run(self):
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
logger.debug("Run")
return
Initial commit
2019-01-22 01:30:42 +01:00
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)
Moar things
2019-02-05 01:35:22 +01:00
networkthread = threading.Thread(target=self.handle_packets)
networkthread.start()
Initial commit
2019-01-22 01:30:42 +01:00
Moved the register to MS function to a variable, added Giants enums, implemented plugin system
2019-01-23 10:28:23 +01:00
if self.server.register_with_ms:
ms = MasterServer(self.server)
ms.register()
Moar things
2019-02-05 01:35:22 +01:00
while self.server.running:
start = datetime.now()
self.read_packets()
self.server.update()
self.send_packets()
sleep_ms = (start-datetime.now()).total_seconds()+1/self.server.ticks
if sleep_ms > 0:
time.sleep(sleep_ms)
Initial commit
2019-01-22 01:30:42 +01:00
Moar things
2019-02-05 01:35:22 +01:00
networkthread.join()
def read_packets(self):
pass
def send_packets(self):
pass
Initial commit
2019-01-22 01:30:42 +01:00
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
def datagram_received(self, data, addr):
logger.debug("%s:%s > %s", addr[0], addr[1], data.hex())
loop = asyncio.get_event_loop()
loop.create_task(self.handle_new_packet(addr, data))
Initial commit
2019-01-22 01:30:42 +01:00
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
async def handle_new_packet(self, addr, bData):
Initial commit
2019-01-22 01:30:42 +01:00
pPacket = Packet(bData)
first = pPacket.getByte()
if len(bData) >= 4 and first & DFrame.PACKET_COMMAND_DATA:
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
await self.handle_new_dframe(addr, pPacket)
Initial commit
2019-01-22 01:30:42 +01:00
elif len(bData) >= 12 and first & CFrame.PACKET_COMMAND_FRAME:
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
await self.handle_new_cframe(addr, pPacket)
Initial commit
2019-01-22 01:30:42 +01:00
elif first == EnumQuery.LEAD or first == EnumResponse.LEAD:
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
await self.handle_new_enum(addr, pPacket)
Initial commit
2019-01-22 01:30:42 +01:00
else:
logger.error("Unknown frame received")
return
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
async def handle_new_enum(self, addr, data):
Initial commit
2019-01-22 01:30:42 +01:00
# 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
Moar things
2019-02-05 22:33:25 +01:00
'''er.ApplicationReservedData = b'\xff' # Map ID
Moved the register to MS function to a variable, added Giants enums, implemented plugin system
2019-01-23 10:28:23 +01:00
er.ApplicationReservedData += b'\x00\x04\x00' # game type and teams
Dynamic packet payloads
2019-01-23 10:54:51 +01:00
er.ApplicationReservedData += struct.pack("<L", int(self.server.version*1000)) # game version
Initial commit
2019-01-22 01:30:42 +01:00
er.ApplicationReservedData += b'\x02\x92\x05\x00\x01\x00\x00\x00\x00\x00' # Unknown
Moar things
2019-02-05 01:35:22 +01:00
er.ApplicationReservedData += b'\x9c\x53\xf4\xdd' # Seems to be a checksum of current map
Initial commit
2019-01-22 01:30:42 +01:00
# \x00\x00\x00\x00: [None]
# \x00\x00\x00\x01: <custom map>
# \x9c\x53\xf4\xdd: Three Way Island - Canyons
# \x1e\xe9\x39\xe1: Still Winter
Moar things
2019-02-05 22:33:25 +01:00
er.ApplicationReservedData += self.server.currentmap.mapname.encode("ascii")'''
appdata = Packet()
appdata.putByte(0xff) # map ID
appdata.putByte(self.server.game_type) # game type
appdata.putByte(self.server.teams) # teams
appdata.write(b'\x00') # original: 0x00 - does not seem to affect client
appdata.putShort(int(self.server.version * 1000))
appdata.write(b'\x02\x92') # original: 0292 - does not seem to affect client
appdata.putShort(self.server.points_per_capture)
appdata.putShort(self.server.points_per_kill)
appdata.write(b'\x00\x00') # original: 0000 - does not seem to affect client
appdata.putShort(self.server.detente_time)
appdata.write(
b'\x9c\x53\xf4\xdd') # Seems to be a checksum of current map OR linked to the number of chars in the map name
appdata.write(self.server.currentmap.mapname.encode("ascii"))
appdata.write(b'\x00' * (32 - len(self.server.currentmap.mapname)))
er.ApplicationReservedData = appdata.getvalue()
logger.debug("Current map: %s", self.server.currentmap.mapname)
Initial commit
2019-01-22 01:30:42 +01:00
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)
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
async def handle_new_cframe(self, addr, data):
Initial commit
2019-01-22 01:30:42 +01:00
try:
cframe = CFrame(data)
session = self.get_session(addr)
Moar things
2019-02-05 01:35:22 +01:00
player = self.get_player(session) if session else None
Initial commit
2019-01-22 01:30:42 +01:00
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.")
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
session = Session(self.remotesocket)
Initial commit
2019-01-22 01:30:42 +01:00
session.SessID = cframe.SessID
session.ip = addr[0]
session.port = addr[1]
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
await session.lock.acquire()
Initial commit
2019-01-22 01:30:42 +01:00
self.addrs.append(session)
session.send_cframe_connected(cframe)
Moar things
2019-02-05 01:35:22 +01:00
player = Player("Unknown", session)
def bxor(b1, b2): # use xor for bytes
result = bytearray()
for b1, b2 in zip(b1, b2):
result.append(b1 ^ b2)
return result
player.id = struct.unpack(">L", bxor(struct.pack("<L", len(self.server.players)), self.guid[0:4]))[0]
logger.debug("Value for connected player: %s", player.id)
player.phase = PlayerPhases.CFRAME_CONNECT
self.server.create_temp_player(player)
Initial commit
2019-01-22 01:30:42 +01:00
#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()
Moar things
2019-02-05 01:35:22 +01:00
player.phase = PlayerPhases.CFRAME_CONNECTED
Moar things
2019-02-05 22:33:25 +01:00
session.send_dframe_keepalive()
Initial commit
2019-01-22 01:30:42 +01:00
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
Added more
2019-01-22 10:35:15 +01:00
if not session.next_send == cframe.NRecv:
Initial commit
2019-01-22 01:30:42 +01:00
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
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
# release lock for new packet to be sent
session.lock.release()
Initial commit
2019-01-22 01:30:42 +01:00
# 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
Moar things
2019-02-05 22:33:25 +01:00
#logger.debug("Got a CFrame POLL. Replying with a SACK.")
Initial commit
2019-01-22 01:30:42 +01:00
# must send back a ACK
Moar things
2019-02-05 22:33:25 +01:00
#session.send_cframe_sack()
Initial commit
2019-01-22 01:30:42 +01:00
except Exception:
logger.error("Should have been a CFRAME but could not parse it")
traceback.print_exc()
return
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
async def handle_new_dframe(self, addr, data):
Initial commit
2019-01-22 01:30:42 +01:00
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
Added more
2019-01-22 10:35:15 +01:00
if dframe.Control & DFrame.PACKET_CONTROL_KEEPALIVE_OR_CORRELATE:
Moar things
2019-02-05 22:33:25 +01:00
pass
#session.send_dframe_keepalive()
Initial commit
2019-01-22 01:30:42 +01:00
session.next_expected_seq += 1
if dframe.Payload:
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
await self.handle_game_packet(session, dframe.Payload)
Initial commit
2019-01-22 01:30:42 +01:00
else:
pass
except Exception as e:
logger.error("Could not parse DFRAME: ")
traceback.print_exc()
return
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
async def handle_game_packet(self, session, payload):
Moar things
2019-02-05 01:35:22 +01:00
player = self.get_temp_player(session)
Initial commit
2019-01-22 01:30:42 +01:00
if payload[0] == 0xc1:
Moar things
2019-02-05 01:35:22 +01:00
if not player or not player.phase == PlayerPhases.CFRAME_CONNECTED:
logger.error("Fuck you. Playerphase was %s", player.phase)
return
# DN_INTERNAL_MESSAGE_PLAYER_CONNECT_INFO_EX
ppayload = Packet(payload)
dwPacketType = ppayload.getULong()
dwFlags = ppayload.getULong()
dwDNETVersion = ppayload.getULong()
dwNameOffset = ppayload.getULong()
dwNameSize = ppayload.getULong()
dwDataOffset = ppayload.getULong()
dwDataSize = ppayload.getULong()
dwPasswordOffset = ppayload.getULong()
dwPasswordSize = ppayload.getULong()
dwConnectDataOffset = ppayload.getULong()
dwConnectDataSize = ppayload.getULong()
dwURLOffset = ppayload.getULong()
dwURLSize = ppayload.getULong()
guidInstance = payload[52:68]
guidApplication = payload[68:84]
name = payload[dwNameOffset+4:dwNameOffset+4+dwNameSize]
name = name.decode("utf-16-le")
Initial commit
2019-01-22 01:30:42 +01:00
logger.debug("%s connected!", name)
Moar things
2019-02-05 01:35:22 +01:00
player.name = name
Moar things
2019-02-05 22:33:25 +01:00
#session.send_dframe_keepalive()
Initial commit
2019-01-22 01:30:42 +01:00
Moar things
2019-02-05 01:35:22 +01:00
# Response: DN_MSG_INTERNAL_SEND_CONNECT_INFO
d = DN_MSG_INTERNAl_SEND_CONNECT_INFO(self, player)
d.Seq = session.next_send
d.NRcv = session.next_expected_seq
appdata = Packet()
appdata.putByte(0xff) # map ID
appdata.putByte(self.server.game_type) # game type
appdata.putByte(self.server.teams) # teams
Moar things
2019-02-05 22:33:25 +01:00
appdata.write(b'\x00') # original: 0x00 - does not seem to affect client
Moar things
2019-02-05 01:35:22 +01:00
appdata.putShort(int(self.server.version * 1000))
appdata.write(b'\x03\x90') # original: 0292 - does not seem to affect client
appdata.putShort(self.server.points_per_capture)
appdata.putShort(self.server.points_per_kill)
Moar things
2019-02-05 22:33:25 +01:00
appdata.write(b'\x00\x00') # original: 0000 - does not seem to affect client
Moar things
2019-02-05 01:35:22 +01:00
appdata.putShort(self.server.detente_time)
appdata.write(b'\x9c\x53\xf4\xdd') # Seems to be a checksum of current map OR linked to the number of chars in the map name
appdata.write(self.server.currentmap.mapname.encode("ascii"))
appdata.write(b'\x00' * (32 - len(self.server.currentmap.mapname)))
d.ApplicationReservedData = appdata.getvalue()
session.send(d)
player.phase = PlayerPhases.DN_SEND_CONNECT_INFO
Initial commit
2019-01-22 01:30:42 +01:00
Added more
2019-01-22 10:35:15 +01:00
elif payload[0] == 0xc3:
Moar things
2019-02-05 01:35:22 +01:00
player = self.get_temp_player(session)
if not player or not player.phase == PlayerPhases.DN_SEND_CONNECT_INFO:
New byte deciphered
2019-01-22 15:11:47 +01:00
return
Moar things
2019-02-05 01:35:22 +01:00
player.phase = PlayerPhases.DN_ACK_CONNECT_INFO
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
await self.server.add_player(player)
Moar things
2019-02-05 01:35:22 +01:00
#player.session.send_cframe_sack()
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
await player.session.send_gamedata(b'\x3c'+struct.pack("<L", player.id)+b"\x00")
Moar things
2019-02-05 01:35:22 +01:00
p1 = b'\x01' + struct.pack("<B", len(self.server.players))
for pplayer in self.server.players:
p1 += struct.pack("<L", pplayer.id)
for pplayer in self.server.players:
if pplayer.name == "[Server]":
continue
p1 += b'\x0e'
p1 += b"\x01\x00"
for pplayer in self.server.players:
if pplayer == player or pplayer.name == "[Server]":
continue
p1 += struct.pack("<B", pplayer.team)
p1 += b'\x00\x00'
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
await player.session.send_gamedata(p1, acknow=False)
await player.session.send_gamedata(b'\x3d\x00\x5b\x53\x65\x72\x76\x65\x72\x5d'+b"\x00"*25) # [SERVER]
await player.session.send_gamedata(b'\x3d\x01'+player.name.encode("ascii")+b"\x00"*(33-len(player.name.encode("ascii")))) # playername
Moar things
2019-02-05 01:35:22 +01:00
"""
Added more
2019-01-22 10:35:15 +01:00
player.session.send_gamedata(b'\x0f\x56\xab\x31\x96\x06\x00\x00\x00\x00\x00\x00\x00\x00') # unknown
player.session.send_gamedata(b'\x10\x02\x56\xab\x31\x96\x00\x00\x00\x00\x00\x00\x00\x00') # unknown
player.session.send_gamedata(b'\x29\x28\x00\x00\x80\x32\x00\x00\x80\x05\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00') # unknown
player.session.send_gamedata(b'\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00') # unknown
player.session.send_gamedata(b'\x39\x01\x02\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00') # unknown
player.session.send_gamedata(b'\x0f\x56\xab\x31\x96\x07\x00\x00\x00\x00\x00\x00\x00\x00') # unknown
player.session.send_gamedata(b'\x0a\x12\x00\x00\x00\x00\x28\x10\x03\x10\x12\x00\x00\x00\xc1\xff\x41\xff\x00', acknow=True) # unknown
player.session.send_gamedata(b'\x0f\x56\xab\x31\x96\x08\x00\x00\x00\x00\x00\x00\x00\x00', acknow=True) # unknown
New byte deciphered
2019-01-22 15:11:47 +01:00
player.session.send_gamedata(b'\x0a\x12\x00\x00\x00\x00\x2c\x10\x03\x10\x12\x00\x00\x00\x08\x00\xb6\x01\x0a\x14\x00\x00\x00\x00\x2d\x10\x03\x01\x12\x00\x00\x00\xd4\xfc\x9b\xfd\x00\x00\x00', acknow=True) # unknown
#\x00
player.session.send_gamedata(b'\x2f\x02\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00', acknow=True) # unknown
player.session.send_gamedata(b'\x0a\x12\x00\x00\x00\x00\x2e\x10\x03\x10\x12\x00\x00\x00\xa8\xfd\x2d\x03\x0a\x14\x00\x00\x00\x00\x2e\x10\x03\x01\x12\x00\x00\x00\x60\xfd\x14\x03\x00\x00\x00', acknow=True) # unknown
player.session.send_gamedata(b'\x0a\x14\x00\x00\x00\x00\x28\x10\x03\x01\x12\x00\x00\x00\xbf\xff\x3f\xff\x00\x00\x00', acknow=True) # unknown
player.session.send_gamedata(b'\x0a\x12\x00\x00\x00\x00\x2a\x10\x03\x10\x12\x00\x00\x00\x73\x01\x42\x02\x0a\x14\x00\x00\x00\x00\x2a\x10\x03\x01\x12\x00\x00\x00\xbe\x01\x8c\x02\x00\x00\x00', acknow=True) # unknown
player.session.send_gamedata(b'\x2f\x02\x00\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00',acknow=True) # unknown
player.session.send_gamedata(b'\x0a\x14\x00\x00\x00\x00\x2c\x10\x03\x01\x12\x00\x00\x00\x06\x00\xb5\x01\x00\x00\x00', acknow=True) # unknown
player.session.send_gamedata(b'\x0a\x12\x00\x00\x00\x00\x2e\x10\x03\x10\x12\x00\x00\x00\xa4\xfd\x2c\x03\x00',acknow=True) # unknown
player.session.send_gamedata(b'\x2f\x02\x00\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00', acknow=True) # unknown
"""
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
else:
logger.debug("OPCODE: %s VALUES: %s", payload[0], payload[1:])
Initial commit
2019-01-22 01:30:42 +01:00
def send_packet(self, addr, packet):
Upgraded to Python 3.7 and using asyncio for coroutines now. Also made the client go up to Awaiting Snapshot.
2019-02-06 01:07:00 +01:00
self.remotesocket.sendto(packet.getvalue(), addr)
Initial commit
2019-01-22 01:30:42 +01:00
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)
Added more
2019-01-22 10:35:15 +01:00
def get_player(self, iporaddr, port=None):
if type(iporaddr) == Session:
Moar things
2019-02-05 01:35:22 +01:00
a = next((x for x in self.server.players if x.session.ip == iporaddr.ip and x.session.port == iporaddr.port), None)
if a:
return a
else:
return next((x for x in self.server.tempplayers if x.session.ip == iporaddr.ip and x.session.port == iporaddr.port),None)
if not port:
a = next((x for x in self.server.players if x.session.ip == iporaddr[0] and x.session.port == iporaddr[1]), None)
if a:
return a
else:
return next((x for x in self.server.tempplayers if x.session.ip == iporaddr[0] and x.session.port == iporaddr[1]),None)
else:
a = next((x for x in self.server.players if x.session.ip == iporaddr and x.session.port == port), None)
if a:
return a
else:
return next((x for x in self.server.tempplayers if x.session.ip == iporaddr and x.session.port == port), None)
def get_temp_player(self, iporaddr, port=None):
if type(iporaddr) == Session:
return next((x for x in self.server.tempplayers if x.session.ip == iporaddr.ip and x.session.port == iporaddr.port), None)
Added more
2019-01-22 10:35:15 +01:00
if not port:
Moar things
2019-02-05 01:35:22 +01:00
return next((x for x in self.server.tempplayers if x.session.ip == iporaddr[0] and x.session.port == iporaddr[1]), None)
Added more
2019-01-22 10:35:15 +01:00
else:
Moar things
2019-02-05 01:35:22 +01:00
return next((x for x in self.server.tempplayers if x.session.ip == iporaddr and x.session.port == port), None)
Reference in New Issue Copy Permalink