def perform_getprofile(self, data_parsed): #profile = self.db.get_profile_from_session_key(data_parsed['sesskey']) profile = self.db.get_profile_from_profileid(data_parsed['profileid']) # Wii example: \pi\\profileid\474888031\nick\5pde5vhn1WR9E2g1t533\userid\442778352\email\5pde5vhn1WR9E2g1t533@nds\sig\b126556e5ee62d4da9629dfad0f6b2a8\uniquenick\5pde5vhn1WR9E2g1t533\pid\11\lon\0.000000\lat\0.000000\loc\\id\2\final\ sig = utils.generate_random_hex_str(32) msg_d = [] msg_d.append(('__cmd__', "pi")) msg_d.append(('__cmd_val__', "")) msg_d.append(('profileid', profile['profileid'])) msg_d.append(('nick', profile['uniquenick'])) msg_d.append(('userid', profile['userid'])) msg_d.append(('email', profile['email'])) msg_d.append(('sig', sig)) msg_d.append(('uniquenick', profile['uniquenick'])) msg_d.append(('pid', profile['pid'])) if profile['firstname'] != "": msg_d.append( ('firstname', profile['firstname'])) # Wii gets a firstname if profile['lastname'] != "": msg_d.append(('lastname', profile['lastname'])) msg_d.append(('lon', profile['lon'])) msg_d.append(('lat', profile['lat'])) msg_d.append(('loc', profile['loc'])) msg_d.append(('id', data_parsed['id'])) msg = gs_query.create_gamespy_message(msg_d) self.log(logging.DEBUG, "SENDING: %s" % msg) self.transport.write(bytes(msg))
def perform_getprofile(self, data_parsed): #profile = self.db.get_profile_from_session_key(data_parsed['sesskey']) profile = self.db.get_profile_from_profileid(data_parsed['profileid']) # Wii example: \pi\\profileid\474888031\nick\5pde5vhn1WR9E2g1t533\userid\442778352\email\5pde5vhn1WR9E2g1t533@nds\sig\b126556e5ee62d4da9629dfad0f6b2a8\uniquenick\5pde5vhn1WR9E2g1t533\pid\11\lon\0.000000\lat\0.000000\loc\\id\2\final\ sig = utils.generate_random_hex_str(32) msg_d = [ ('__cmd__', "pi"), ('__cmd_val__', ""), ('profileid', profile['profileid']), ('nick', profile['uniquenick']), ('userid', profile['userid']), ('email', profile['email']), ('sig', sig), ('uniquenick', profile['uniquenick']), ('pid', profile['pid']), ] if profile['firstname'] != "": msg_d.append(('firstname', profile['firstname'])) # Wii gets a firstname if profile['lastname'] != "": msg_d.append(('lastname', profile['lastname'])) msg_d.extend([ ('lon', profile['lon']), ('lat', profile['lat']), ('loc', profile['loc']), ('id', data_parsed['id']), ]) msg = gs_query.create_gamespy_message(msg_d) self.log(logging.DEBUG, "SENDING: %s" % msg) self.transport.write(bytes(msg))
def forward_data_to_client(self, data, forward_client): # Find session id of server # Iterate through the list of servers sent to the client and match by IP and port. # Is there a better way to determine this information? if self.forward_client == None or len(self.forward_client) != 2: return server, ip = self.find_server_in_cache(self.forward_client[0], self.forward_client[1], self.console) if server == None: if self.console == 0: server, ip = self.find_server_in_cache(self.forward_client[0], self.forward_client[1], 1) # Try Wii elif self.console == 1: server, ip = self.find_server_in_cache(self.forward_client[0], self.forward_client[1], 0) # Try DS self.log(logging.DEBUG, "find_server_in_cache returned: %s" % server) self.log( logging.DEBUG, "Trying to send message to %s:%d..." % (self.forward_client[0], self.forward_client[1])) self.log(logging.DEBUG, utils.pretty_print_hex(bytearray(data))) if server == None: return self.log(logging.DEBUG, "%s %s" % (ip, server['publicip'])) if server['publicip'] == ip and server['publicport'] == str( self.forward_client[1]): # Send command to server to get it to connect to natneg natneg_session = int( utils.generate_random_hex_str(8), 16 ) # Quick and lazy way to get a random 32bit integer. Replace with something else later output = bytearray([0xfe, 0xfd, 0x06]) output += utils.get_bytes_from_int(server['__session__']) output += bytearray(utils.get_bytes_from_int(natneg_session)) output += bytearray(data) if self.qr != None: self.qr.socket.sendto(output, forward_client) self.log( logging.DEBUG, "Forwarded data to %s:%s through QR server..." % (forward_client[0], forward_client[1])) else: # In case we can't contact the QR server, just try sending the packet directly. # This isn't standard behavior but it can work in some instances. client_s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) client_s.sendto(output, forward_client) self.log( logging.DEBUG, "Forwarded data to %s:%s directly (potential error occurred)..." % (forward_client[0], forward_client[1]))
def forward_data_to_client(self, data, forward_client): # Find session id of server # Iterate through the list of servers sent to the client and match by IP and port. # Is there a better way to determine this information? if self.forward_client == None or len(self.forward_client) != 2: return server, ip = self.find_server_in_cache(self.forward_client[0], self.forward_client[1], self.console) if server == None: if self.console == 0: server, ip = self.find_server_in_cache(self.forward_client[0], self.forward_client[1], 1) # Try Wii elif self.console == 1: server, ip = self.find_server_in_cache(self.forward_client[0], self.forward_client[1], 0) # Try DS self.log(logging.DEBUG, "find_server_in_cache returned: %s" % server) self.log(logging.DEBUG, "Trying to send message to %s:%d..." % (self.forward_client[0], self.forward_client[1])) self.log(logging.DEBUG, utils.pretty_print_hex(bytearray(data))) if server == None: return self.log(logging.DEBUG, "%s %s" % (ip, server['publicip'])) if server['publicip'] == ip and server['publicport'] == str(self.forward_client[1]): if self.forward_client[1] == 0 and 'localport' in server: # No public port returned from client, try contacting on the local port. self.forward_client = (self.forward_client[0], int(server['localport'])) # Send command to server to get it to connect to natneg cookie = int(utils.generate_random_hex_str(8), 16) # Quick and lazy way to get a random 32bit integer. Replace with something else later if len(data) == 10 and bytearray(data)[0:6] == bytearray([0xfd, 0xfc, 0x1e, 0x66, 0x6a, 0xb2]): natneg_session = utils.get_int(data,6) self.log(logging.DEBUG, "Adding %d to natneg server list: %s" % (natneg_session, server)) self.server_manager.add_natneg_server(natneg_session, server) # Store info in backend so we can get it later in natneg # if self.qr != None: # own_server = self.qr.get_own_server() # # self.log(logging.DEBUG, "Adding %d to natneg server list: %s" % (natneg_session, own_server)) # self.server_manager.add_natneg_server(natneg_session, own_server) # Store info in backend so we can get it later in natneg output = bytearray([0xfe, 0xfd, 0x06]) output += utils.get_bytes_from_int(server['__session__']) output += bytearray(utils.get_bytes_from_int(cookie)) output += bytearray(data) if self.qr != None: self.log(logging.DEBUG, "Forwarded data to %s:%s through QR server..." % (forward_client[0], forward_client[1])) self.qr.socket.sendto(output, forward_client) else: # In case we can't contact the QR server, just try sending the packet directly. # This isn't standard behavior but it can work in some instances. self.log(logging.DEBUG, "Forwarded data to %s:%s directly (potential error occurred)..." % (forward_client[0], forward_client[1])) client_s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) client_s.sendto(output, forward_client)
def send_buddy_request(self, session, profileid, senttime=None): sig = utils.generate_random_hex_str(32) msg = "\r\n\r\n" msg += "|signed|" + sig if senttime is None: senttime = int(time.time()) msg = gs_query.create_gamespy_message( [("__cmd__", "bm"), ("__cmd_val__", "2"), ("f", profileid), ("date", senttime), ("msg", msg)] ) session.transport.write(bytes(msg))
def send_buddy_request(self, session, profileid, senttime=None): sig = utils.generate_random_hex_str(32) msg = "\r\n\r\n" msg += "|signed|" + sig if senttime == None: senttime = int(time.time()) msg_d = [] msg_d.append(('__cmd__', "bm")) msg_d.append(('__cmd_val__', "2")) msg_d.append(('f', profileid)) msg_d.append(('date', senttime)) msg_d.append(('msg', msg)) msg = gs_query.create_gamespy_message(msg_d) session.transport.write(bytes(msg))
def send_buddy_request(self, session, profileid, senttime = None): sig = utils.generate_random_hex_str(32) msg = "\r\n\r\n" msg += "|signed|" + sig if senttime == None: senttime = int(time.time()) msg_d = [] msg_d.append(('__cmd__', "bm")) msg_d.append(('__cmd_val__', "2")) msg_d.append(('f', profileid)) msg_d.append(('date', senttime)) msg_d.append(('msg', msg)) msg = gs_query.create_gamespy_message(msg_d) session.transport.write(bytes(msg))
def get_buddy_requests(self): # Get list people who have added the user but haven't been accepted yet. buddies = self.db.get_pending_buddy_requests(self.profileid) profile = self.db.get_profile_from_profileid(self.profileid) sig = utils.generate_random_hex_str(32) msg = "\r\n\r\n" msg += "|signed|" + sig for buddy in buddies: msg_d = [] msg_d.append(('__cmd__', "bm")) msg_d.append(('__cmd_val__', "2")) msg_d.append(('f', buddy['userProfileId'])) msg_d.append(('date', buddy['time'])) msg_d.append(('msg', msg)) msg = gs_query.create_gamespy_message(msg_d) self.transport.write(bytes(msg))
def forward_data_to_client(self, data, forward_client): # Find session id of server # Iterate through the list of servers sent to the client and match by IP and port. # Is there a better way to determine this information? if self.forward_client == None or len(self.forward_client) != 2: return server, ip = self.find_server_in_cache(self.forward_client[0], self.forward_client[1], self.console) if server == None: if self.console == 0: server, ip = self.find_server_in_cache(self.forward_client[0], self.forward_client[1], 1) # Try Wii elif self.console == 1: server, ip = self.find_server_in_cache(self.forward_client[0], self.forward_client[1], 0) # Try DS self.log(logging.DEBUG, "find_server_in_cache returned: %s" % server) self.log(logging.DEBUG, "Trying to send message to %s:%d..." % (self.forward_client[0], self.forward_client[1])) self.log(logging.DEBUG, utils.pretty_print_hex(bytearray(data))) if server == None: return self.log(logging.DEBUG, "%s %s" % (ip, server['publicip'])) if server['publicip'] == ip and server['publicport'] == str(self.forward_client[1]): # Send command to server to get it to connect to natneg natneg_session = int(utils.generate_random_hex_str(8), 16) # Quick and lazy way to get a random 32bit integer. Replace with something else later output = bytearray([0xfe, 0xfd, 0x06]) output += utils.get_bytes_from_int(server['__session__']) output += bytearray(utils.get_bytes_from_int(natneg_session)) output += bytearray(data) if self.qr != None: self.qr.socket.sendto(output, forward_client) self.log(logging.DEBUG, "Forwarded data to %s:%s through QR server..." % (forward_client[0], forward_client[1])) else: # In case we can't contact the QR server, just try sending the packet directly. # This isn't standard behavior but it can work in some instances. client_s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) client_s.sendto(output, forward_client) self.log(logging.DEBUG, "Forwarded data to %s:%s directly (potential error occurred)..." % (forward_client[0], forward_client[1]))
def perform_getprofile(self, data_parsed): # profile = self.db.get_profile_from_session_key( # data_parsed['sesskey'] # ) profile = self.db.get_profile_from_profileid(data_parsed["profileid"]) # Wii example: # \pi\\profileid\474888031\nick\5pde5vhn1WR9E2g1t533\userid\442778352 # \email\5pde5vhn1WR9E2g1t533@nds\sig\b126556e5ee62d4da9629dfad0f6b2a8 # \uniquenick\5pde5vhn1WR9E2g1t533\pid\11\lon\0.000000\lat\0.000000 # \loc\\id\2\final\ sig = utils.generate_random_hex_str(32) msg_d = [ ("__cmd__", "pi"), ("__cmd_val__", ""), ("profileid", profile["profileid"]), ("nick", profile["uniquenick"]), ("userid", profile["userid"]), ("email", profile["email"]), ("sig", sig), ("uniquenick", profile["uniquenick"]), ("pid", profile["pid"]), ] if profile["firstname"]: # Wii gets a firstname msg_d.append(("firstname", profile["firstname"])) if profile["lastname"]: msg_d.append(("lastname", profile["lastname"])) msg_d.extend( [("lon", profile["lon"]), ("lat", profile["lat"]), ("loc", profile["loc"]), ("id", data_parsed["id"])] ) msg = gs_query.create_gamespy_message(msg_d) self.log(logging.DEBUG, "SENDING: %s", msg) self.transport.write(bytes(msg))
def forward_data_to_client(self, data, forward_client): # Find session id of server # Iterate through the list of servers sent to the client and match by # IP and port. Is there a better way to determine this information? if forward_client is None or len(forward_client) != 2: return server, ip = self.find_server_in_cache(forward_client[0], forward_client[1], self.console) if server is None: if self.console == 0: server, ip = self.find_server_in_cache(forward_client[0], forward_client[1], 1) # Try Wii elif self.console == 1: server, ip = self.find_server_in_cache(forward_client[0], forward_client[1], 0) # Try DS self.log(logging.DEBUG, "find_server_in_cache returned: %s", server) self.log(logging.DEBUG, "Trying to send message to %s:%d...", forward_client[0], forward_client[1]) self.log(logging.DEBUG, "%s", utils.pretty_print_hex(bytearray(data))) if server is None: return self.log(logging.DEBUG, "%s %s", ip, server['publicip']) if server['publicip'] == ip and \ server['publicport'] == str(forward_client[1]): if forward_client[1] == 0 and 'localport' in server: # No public port returned from client, try contacting on # the local port. forward_client = (forward_client[0], int(server['localport'])) # Send command to server to get it to connect to natneg # Quick and lazy way to get a random 32bit integer. Replace with # something else later cookie = int(utils.generate_random_hex_str(8), 16) # if (len(data) == 24 and bytearray(data)[0:10] == \ # bytearray([0x53, 0x42, 0x43, 0x4d, 0x03, # 0x00, 0x00, 0x00, 0x01, 0x04])) or \ # (len(data) == 40 and bytearray(data)[0:10] == \ # bytearray([0x53, 0x42, 0x43, 0x4d, # 0x0b, 0x00, 0x00, 0x00, # 0x01, 0x04])): if self.own_server is None and len(data) >= 16 and \ bytearray(data)[0:4] in (bytearray([0xbb, 0x49, 0xcc, 0x4d]), bytearray([0x53, 0x42, 0x43, 0x4d])): # Is the endianness the same between the DS and Wii here? # It seems so but I'm not positive. # Note to self: Port is little endian here. self_port = utils.get_short(bytearray(data[10:12]), 0, False) self_ip = '.'.join(["%d" % x for x in bytearray(data[12:16])]) self.own_server, _ = self.find_server_in_cache( self_ip, self_port, self.console) if self.own_server is None: if self.console == 0: # Try Wii self.own_server, _ = self.find_server_in_cache( self_ip, self_port, 1) elif self.console == 1: # Try DS self.own_server, _ = self.find_server_in_cache( self_ip, self_port, 0) if self.own_server is None: self.log(logging.DEBUG, "Could not find own server: %s:%d", self_ip, self_port) else: self.log(logging.DEBUG, "Found own server: %s", self.own_server) elif len(data) == 10 and \ bytearray(data)[0:6] == \ bytearray([0xfd, 0xfc, 0x1e, 0x66, 0x6a, 0xb2]): natneg_session = utils.get_int_signed(data, 6) self.log(logging.DEBUG, "Adding %d to natneg server list: %s", natneg_session, server) # Store info in backend so we can get it later in natneg self.server_manager.add_natneg_server(natneg_session, server) if self.own_server is not None: self.log(logging.DEBUG, "Adding %d to natneg server list: %s (self)", natneg_session, self.own_server) # Store info in backend so we can get it later in natneg self.server_manager.add_natneg_server( natneg_session, self.own_server) # if self.qr is not None: # own_server = self.qr.get_own_server() # # self.log(logging.DEBUG, # "Adding %d to natneg server list: %s", # natneg_session, own_server) # self.server_manager.add_natneg_server(natneg_session, # own_server) output = bytearray([0xfe, 0xfd, 0x06]) output += utils.get_bytes_from_int(server['__session__']) output += bytearray(utils.get_bytes_from_int(cookie)) output += bytearray(data) if self.qr is not None: self.log(logging.DEBUG, "Forwarded data to %s:%s through QR server...", forward_client[0], forward_client[1]) self.qr.socket.sendto(output, forward_client) else: # In case we can't contact the QR server, just try sending # the packet directly. This isn't standard behavior but it # can work in some instances. self.log( logging.DEBUG, "Forwarded data to %s:%s directly" " (potential error occurred)...", forward_client[0], forward_client[1]) client_s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) client_s.sendto(output, forward_client)
def rawDataReceived(self, data): # First 2 bytes are the packet size. # # Third byte is the command byte. # According to Openspy-Core: # 0x00 - Server list request # 0x01 - Server info request # 0x02 - Send message request # 0x03 - Keep alive reply # 0x04 - Map loop request (?) # 0x05 - Player search request # # For Tetris DS, at the very least 0x00 and 0x02 need to be implemented. if self.forward_to_client: self.forward_to_client = False # Find session id of server # Iterate through the list of servers sent to the client and match by IP and port. # Is there a better way to determine this information? if self.console != 0: ip = str(ctypes.c_int32(utils.get_int_be(bytearray([int(x) for x in self.forward_client[0].split('.')]), 0)).value) # Wii else: ip = str(ctypes.c_int32(utils.get_int(bytearray([int(x) for x in self.forward_client[0].split('.')]), 0)).value) # DS logger.log(logging.DEBUG, "Trying to send message to %s:%d..." % (self.forward_client[0], self.forward_client[1])) logger.log(logging.DEBUG, utils.pretty_print_hex(bytearray(data))) # Get server based on ip/port server = self.server_manager.find_server_by_address(ip, self.forward_client[1])._getvalue() logger.log(logging.DEBUG, "find_server_by_address returned: %s" % server) if server == None: pass logger.log(logging.DEBUG, "%s %s" % (ip, server['publicip'])) if server['publicip'] == ip and server['publicport'] == str(self.forward_client[1]): # Send command to server to get it to connect to natneg natneg_session = int(utils.generate_random_hex_str(8), 16) # Quick and lazy way to get a random 32bit integer. Replace with something else late.r output = bytearray([0xfe, 0xfd, 0x06]) output += utils.get_bytes_from_int(server['__session__']) output += bytearray(utils.get_bytes_from_int(natneg_session)) output += bytearray(data) client_s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) client_s.sendto(output, self.forward_client) logger.log(logging.DEBUG, "Forwarded data to %s:%s..." % (self.forward_client[0], self.forward_client[1])) return if data[2] == '\x00': # Server list request logger.log(logging.DEBUG, "Received server list request from %s:%s..." % (self.address.host, self.address.port)) # This code is so... not python. The C programmer in me is coming out strong. # TODO: Rewrite this section later? idx = 3 list_version = ord(data[idx]) idx += 1 encoding_version = ord(data[idx]) idx += 1 game_version = utils.get_int(data, idx) idx += 4 query_game = utils.get_string(data, idx) idx += len(query_game) + 1 game_name = utils.get_string(data, idx) idx += len(game_name) + 1 challenge = data[idx:idx+8] idx += 8 filter = utils.get_string(data, idx) idx += len(filter) + 1 fields = utils.get_string(data, idx) idx += len(fields) + 1 options = utils.get_int_be(data, idx) idx += 4 source_ip = 0 max_servers = 0 ALTERNATE_SOURCE_IP = 0x08 LIMIT_RESULT_COUNT = 0x80 if (options & LIMIT_RESULT_COUNT): max_servers = utils.get_int(data, idx) elif (options & ALTERNATE_SOURCE_IP): source_ip = utils.get_int(data, idx) if '\\' in fields: fields = [x for x in fields.split('\\') if x and not x.isspace()] #print "%02x %02x %08x" % (list_version, encoding_version, game_version) #print "%s" % query_game #print "%s" % game_name #print "%s" % challenge #print "%s" % filter #print "%s" % fields #print "%08x" % options #print "%d %08x" % (max_servers, source_ip) logger.log(logging.DEBUG, "list version: %02x / encoding version: %02x / game version: %08x / query game: %s / game name: %s / challenge: %s / filter: %s / fields: %s / options: %08x / max servers: %d / source ip: %08x" % (list_version, encoding_version, game_version, query_game, game_name, challenge, filter, fields, options, max_servers, source_ip)) # Requesting ip and port of client, not server if filter == "" or fields == "": output = bytearray([int(x) for x in self.address.host.split('.')]) output += utils.get_bytes_from_short_be(self.address.port) self.transport.write(bytes(output)) logger.log(logging.DEBUG, "Responding with own IP and port...") logger.log(logging.DEBUG, utils.pretty_print_hex(output)) else: self.find_server(query_game, filter, fields, max_servers, game_name, challenge) elif data[2] == '\x02': # Send message request dest_addr = '.'.join(["%d" % ord(x) for x in data[3:7]]) dest_port = utils.get_short_be(data, 7) # What's the pythonic way to do this? unpack? dest = (dest_addr, dest_port) logger.log(logging.DEBUG, "Received send message request from %s:%s to %s:%d..." % (self.address.host, self.address.port, dest_addr, dest_port)) logger.log(logging.DEBUG, utils.pretty_print_hex(bytearray(data))) self.forward_to_client = True self.forward_client = dest elif data[2] == '\x03': # Keep alive reply logger.log(logging.DEBUG, "Received keep alive from %s:%s..." % (self.address.host, self.address.port)) else: logger.log(logging.DEBUG, "Received unknown command (%02x) from %s:%s..." % (ord(data[2]), self.address.host, self.address.port)) logger.log(logging.DEBUG, utils.pretty_print_hex(bytearray(data))) logger.log(logging.DEBUG, utils.pretty_print_hex(data))
def forward_data_to_client(self, data, forward_client): # Find session id of server # Iterate through the list of servers sent to the client and match by # IP and port. Is there a better way to determine this information? if forward_client is None or len(forward_client) != 2: return server, ip = self.find_server_in_cache(forward_client[0], forward_client[1], self.console) if server is None: if self.console == 0: server, ip = self.find_server_in_cache(forward_client[0], forward_client[1], 1) # Try Wii elif self.console == 1: server, ip = self.find_server_in_cache(forward_client[0], forward_client[1], 0) # Try DS self.log(logging.DEBUG, "find_server_in_cache returned: %s", server) self.log(logging.DEBUG, "Trying to send message to %s:%d...", forward_client[0], forward_client[1]) self.log(logging.DEBUG, "%s", utils.pretty_print_hex(bytearray(data))) if server is None: return self.log(logging.DEBUG, "%s %s", ip, server['publicip']) if server['publicip'] == ip and \ server['publicport'] == str(forward_client[1]): if forward_client[1] == 0 and 'localport' in server: # No public port returned from client, try contacting on # the local port. forward_client = (forward_client[0], int(server['localport'])) # Send command to server to get it to connect to natneg # Quick and lazy way to get a random 32bit integer. Replace with # something else later cookie = int(utils.generate_random_hex_str(8), 16) # if (len(data) == 24 and bytearray(data)[0:10] == \ # bytearray([0x53, 0x42, 0x43, 0x4d, 0x03, # 0x00, 0x00, 0x00, 0x01, 0x04])) or \ # (len(data) == 40 and bytearray(data)[0:10] == \ # bytearray([0x53, 0x42, 0x43, 0x4d, # 0x0b, 0x00, 0x00, 0x00, # 0x01, 0x04])): if self.own_server is None and len(data) >= 16 and \ bytearray(data)[0:4] in (bytearray([0xbb, 0x49, 0xcc, 0x4d]), bytearray([0x53, 0x42, 0x43, 0x4d])): # Is the endianness the same between the DS and Wii here? # It seems so but I'm not positive. # Note to self: Port is little endian here. self_port = utils.get_short(bytearray(data[10:12]), 0, False) self_ip = '.'.join(["%d" % x for x in bytearray(data[12:16])]) self.own_server, _ = self.find_server_in_cache(self_ip, self_port, self.console) if self.own_server is None: if self.console == 0: # Try Wii self.own_server, _ = self.find_server_in_cache( self_ip, self_port, 1 ) elif self.console == 1: # Try DS self.own_server, _ = self.find_server_in_cache( self_ip, self_port, 0 ) if self.own_server is None: self.log(logging.DEBUG, "Could not find own server: %s:%d", self_ip, self_port) else: self.log(logging.DEBUG, "Found own server: %s", self.own_server) elif len(data) == 10 and \ bytearray(data)[0:6] == \ bytearray([0xfd, 0xfc, 0x1e, 0x66, 0x6a, 0xb2]): natneg_session = utils.get_int_signed(data, 6) self.log(logging.DEBUG, "Adding %d to natneg server list: %s", natneg_session, server) # Store info in backend so we can get it later in natneg self.server_manager.add_natneg_server(natneg_session, server) if self.own_server is not None: self.log(logging.DEBUG, "Adding %d to natneg server list: %s (self)", natneg_session, self.own_server) # Store info in backend so we can get it later in natneg self.server_manager.add_natneg_server(natneg_session, self.own_server) # if self.qr is not None: # own_server = self.qr.get_own_server() # # self.log(logging.DEBUG, # "Adding %d to natneg server list: %s", # natneg_session, own_server) # self.server_manager.add_natneg_server(natneg_session, # own_server) output = bytearray([0xfe, 0xfd, 0x06]) output += utils.get_bytes_from_int(server['__session__']) output += bytearray(utils.get_bytes_from_int(cookie)) output += bytearray(data) if self.qr is not None: self.log(logging.DEBUG, "Forwarded data to %s:%s through QR server...", forward_client[0], forward_client[1]) self.qr.socket.sendto(output, forward_client) else: # In case we can't contact the QR server, just try sending # the packet directly. This isn't standard behavior but it # can work in some instances. self.log(logging.DEBUG, "Forwarded data to %s:%s directly" " (potential error occurred)...", forward_client[0], forward_client[1]) client_s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) client_s.sendto(output, forward_client)