def handle_get_public_data(self, caller_id, input, output):
logger.info("AccountServer.get_public_data()")
#--- request ---
response = common.ResponseObject()
self.get_public_data(caller_id, response)
#--- response ---
for field in ['result', 'data']:
if not hasattr(response, field):
raise RuntimeError("Missing field in response object: %s" %field)
output.bool(response.result)
output.anydata(response.data)
def handle_retrieve_account(self, caller_id, input, output):
logger.info("AccountServer.retrieve_account()")
#--- request ---
response = common.ResponseObject()
self.retrieve_account(caller_id, response)
#--- response ---
for field in ['account_data', 'public_data', 'private_data']:
if not hasattr(response, field):
raise RuntimeError("Missing field in response object: %s" %field)
output.add(response.account_data)
output.anydata(response.public_data)
output.anydata(response.private_data)
def get_public_data(self):
logger.info("AccountClient.get_public_data()")
#--- request ---
stream, call_id = self.client.init_request(self.PROTOCOL_ID, self.METHOD_GET_PUBLIC_DATA)
self.client.send_message(stream)
#--- response ---
stream = self.client.get_response(call_id)
obj = common.ResponseObject()
obj.result = stream.bool()
obj.data = stream.anydata()
logger.info("AccountClient.get_public_data -> done")
return obj
def get_account_data(self):
logger.info("AccountClient.get_account_data()")
#--- request ---
stream, call_id = self.client.init_request(self.PROTOCOL_ID, self.METHOD_GET_ACCOUNT_DATA)
self.client.send_message(stream)
#--- response ---
stream = self.client.get_response(call_id)
obj = common.ResponseObject()
obj.result = stream.result()
obj.data = stream.extract(AccountData)
logger.info("AccountClient.get_account_data -> done")
return obj
def handle_get_last_connection_stats(self, caller_id, input, output):
logger.info("AccountServer.get_last_connection_stats()")
#--- request ---
pid = input.pid()
response = common.ResponseObject()
self.get_last_connection_stats(caller_id, response, pid)
#--- response ---
for field in ['last_session_login', 'last_session_logout', 'current_session_login']:
if not hasattr(response, field):
raise RuntimeError("Missing field in response object: %s" %field)
output.datetime(response.last_session_login)
output.datetime(response.last_session_logout)
output.datetime(response.current_session_login)
def handle_get_metas_multiple_param(self, caller_id, input, output):
logger.info("DataStoreServer.get_metas_multiple_param()")
#--- request ---
params = input.list(DataStoreGetMetaParam)
response = common.ResponseObject()
self.get_metas_multiple_param(caller_id, response, params)
#--- response ---
for field in ['infos', 'results']:
if not hasattr(response, field):
raise RuntimeError("Missing field in response object: %s" %
field)
output.list(response.infos, output.add)
output.list(response.results, output.result)
def retrieve_account(self):
logger.info("AccountClient.retrieve_account()")
#--- request ---
stream, call_id = self.client.init_request(self.PROTOCOL_ID, self.METHOD_RETRIEVE_ACCOUNT)
self.client.send_message(stream)
#--- response ---
stream = self.client.get_response(call_id)
obj = common.ResponseObject()
obj.account_data = stream.extract(AccountData)
obj.public_data = stream.anydata()
obj.private_data = stream.anydata()
logger.info("AccountClient.retrieve_account -> done")
return obj
def get_last_connection_stats(self, pid):
logger.info("AccountClient.get_last_connection_stats()")
#--- request ---
stream, call_id = self.client.init_request(self.PROTOCOL_ID, self.METHOD_GET_LAST_CONNECTION_STATS)
stream.pid(pid)
self.client.send_message(stream)
#--- response ---
stream = self.client.get_response(call_id)
obj = common.ResponseObject()
obj.last_session_login = stream.datetime()
obj.last_session_logout = stream.datetime()
obj.current_session_login = stream.datetime()
logger.info("AccountClient.get_last_connection_stats -> done")
return obj
def get_metas_multiple_param(self, params):
logger.info("DataStoreClient.get_metas_multiple_param()")
#--- request ---
stream, call_id = self.client.init_request(
self.PROTOCOL_ID, self.METHOD_GET_METAS_MULTIPLE_PARAM)
stream.list(params, stream.add)
self.client.send_message(stream)
#--- response ---
stream = self.client.get_response(call_id)
obj = common.ResponseObject()
obj.infos = stream.list(DataStoreMetaInfo)
obj.results = stream.list(stream.result)
logger.info("DataStoreClient.get_metas_multiple_param -> done")
return obj
def handle_request_ticket(self, caller_id, input, output):
logger.info("AuthenticationServer.request_ticket()")
#--- request ---
source = input.pid()
target = input.pid()
response = common.ResponseObject()
self.request_ticket(caller_id, response, source, target)
#--- response ---
for field in ['result', 'ticket']:
if not hasattr(response, field):
raise RuntimeError("Missing field in response object: %s" %
field)
output.result(response.result)
output.buffer(response.ticket)
def handle_register(self, caller_id, input, output):
logger.info("SecureConnectionServer.register()")
#--- request ---
urls = input.list(input.stationurl)
response = common.ResponseObject()
self.register(caller_id, response, urls)
#--- response ---
for field in ['result', 'connection_id', 'public_station']:
if not hasattr(response, field):
raise RuntimeError("Missing field in response object: %s" %
field)
output.result(response.result)
output.u32(response.connection_id)
output.stationurl(response.public_station)
def handle_request_urls(self, caller_id, input, output):
logger.info("SecureConnectionServer.request_urls()")
#--- request ---
cid = input.u32()
pid = input.pid()
response = common.ResponseObject()
self.request_urls(caller_id, response, cid, pid)
#--- response ---
for field in ['result', 'urls']:
if not hasattr(response, field):
raise RuntimeError("Missing field in response object: %s" %
field)
output.bool(response.result)
output.list(response.urls, output.stationurl)
def request_ticket(self, source, target):
logger.info("AuthenticationClient.request_ticket()")
#--- request ---
stream, call_id = self.client.init_request(self.PROTOCOL_ID,
self.METHOD_REQUEST_TICKET)
stream.pid(source)
stream.pid(target)
self.client.send_message(stream)
#--- response ---
stream = self.client.get_response(call_id)
obj = common.ResponseObject()
obj.result = stream.result()
obj.ticket = stream.buffer()
logger.info("AuthenticationClient.request_ticket -> done")
return obj
def request_urls(self, cid, pid):
logger.info("SecureConnectionClient.request_urls()")
#--- request ---
stream, call_id = self.client.init_request(self.PROTOCOL_ID,
self.METHOD_REQUEST_URLS)
stream.u32(cid)
stream.pid(pid)
self.client.send_message(stream)
#--- response ---
stream = self.client.get_response(call_id)
obj = common.ResponseObject()
obj.result = stream.bool()
obj.urls = stream.list(stream.stationurl)
logger.info("SecureConnectionClient.request_urls -> done")
return obj
def register(self, urls):
logger.info("SecureConnectionClient.register()")
#--- request ---
stream, call_id = self.client.init_request(self.PROTOCOL_ID,
self.METHOD_REGISTER)
stream.list(urls, stream.stationurl)
self.client.send_message(stream)
#--- response ---
stream = self.client.get_response(call_id)
obj = common.ResponseObject()
obj.result = stream.result()
obj.connection_id = stream.u32()
obj.public_station = stream.stationurl()
logger.info("SecureConnectionClient.register -> done")
return obj
def request_connection_data(self, cid, pid):
logger.info("SecureConnectionClient.request_connection_data()")
#--- request ---
stream, call_id = self.client.init_request(
self.PROTOCOL_ID, self.METHOD_REQUEST_CONNECTION_DATA)
stream.u32(cid)
stream.pid(pid)
self.client.send_message(stream)
#--- response ---
stream = self.client.get_response(call_id)
obj = common.ResponseObject()
obj.result = stream.bool()
obj.connection_data = stream.list(ConnectionData)
logger.info("SecureConnectionClient.request_connection_data -> done")
return obj
def handle_nintendo_create_account(self, caller_id, input, output):
logger.info("AccountServer.nintendo_create_account()")
#--- request ---
name = input.string()
key = input.string()
groups = input.u32()
email = input.string()
auth_data = input.anydata()
response = common.ResponseObject()
self.nintendo_create_account(caller_id, response, name, key, groups, email, auth_data)
#--- response ---
for field in ['pid', 'pid_hmac']:
if not hasattr(response, field):
raise RuntimeError("Missing field in response object: %s" %field)
output.pid(response.pid)
output.string(response.pid_hmac)
def login(self, username):
logger.info("AuthenticationClient.login()")
#--- request ---
stream, call_id = self.client.init_request(self.PROTOCOL_ID,
self.METHOD_LOGIN)
stream.string(username)
self.client.send_message(stream)
#--- response ---
stream = self.client.get_response(call_id)
obj = common.ResponseObject()
obj.result = stream.result()
obj.pid = stream.pid()
obj.ticket = stream.buffer()
obj.connection_data = stream.extract(RVConnectionData)
obj.server_name = stream.string()
logger.info("AuthenticationClient.login -> done")
return obj
def nintendo_create_account(self, name, key, groups, email, auth_data):
logger.info("AccountClient.nintendo_create_account()")
#--- request ---
stream, call_id = self.client.init_request(self.PROTOCOL_ID, self.METHOD_NINTENDO_CREATE_ACCOUNT)
stream.string(name)
stream.string(key)
stream.u32(groups)
stream.string(email)
stream.anydata(auth_data)
self.client.send_message(stream)
#--- response ---
stream = self.client.get_response(call_id)
obj = common.ResponseObject()
obj.pid = stream.pid()
obj.pid_hmac = stream.string()
logger.info("AccountClient.nintendo_create_account -> done")
return obj
def handle_login(self, caller_id, input, output):
logger.info("AuthenticationServer.login()")
#--- request ---
username = input.string()
response = common.ResponseObject()
self.login(caller_id, response, username)
#--- response ---
for field in [
'result', 'pid', 'ticket', 'connection_data', 'server_name'
]:
if not hasattr(response, field):
raise RuntimeError("Missing field in response object: %s" %
field)
output.result(response.result)
output.pid(response.pid)
output.buffer(response.ticket)
output.add(response.connection_data)
output.string(response.server_name)
def handle_get_all_information(self, caller_id, input, output):
logger.info("FriendsServer.get_all_information()")
#--- request ---
nna_info = input.extract(NNAInfo)
presence = input.extract(NintendoPresenceV2)
birthday = input.datetime()
response = common.ResponseObject()
self.get_all_information(caller_id, response, nna_info, presence, birthday)
#--- response ---
for field in ['principal_preference', 'comment', 'friends', 'sent_requests', 'received_requests', 'blacklist', 'unk1', 'notifications', 'unk2']:
if not hasattr(response, field):
raise RuntimeError("Missing field in response object: %s" %field)
output.add(response.principal_preference)
output.add(response.comment)
output.list(response.friends, output.add)
output.list(response.sent_requests, output.add)
output.list(response.received_requests, output.add)
output.list(response.blacklist, output.add)
output.bool(response.unk1)
output.list(response.notifications, output.add)
output.bool(response.unk2)
def get_all_information(self, nna_info, presence, birthday):
logger.info("FriendsClient.get_all_information()")
#--- request ---
stream, call_id = self.client.init_request(self.PROTOCOL_ID, self.METHOD_GET_ALL_INFORMATION)
stream.add(nna_info)
stream.add(presence)
stream.datetime(birthday)
self.client.send_message(stream)
#--- response ---
stream = self.client.get_response(call_id)
obj = common.ResponseObject()
obj.principal_preference = stream.extract(PrincipalPreference)
obj.comment = stream.extract(Comment)
obj.friends = stream.list(FriendInfo)
obj.sent_requests = stream.list(FriendRequest)
obj.received_requests = stream.list(FriendRequest)
obj.blacklist = stream.list(BlacklistedPrincipal)
obj.unk1 = stream.bool()
obj.notifications = stream.list(PersistentNotification)
obj.unk2 = stream.bool()
logger.info("FriendsClient.get_all_information -> done")
return obj
