path: root/bin/fs-uae-game-server-1.3.1.py

"""
FS-UAE Netplay Game Server
Copyright (C) 2012 Frode Solheim

This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or (at
your option) any later version.

This library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this library; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
"""
from __future__ import print_function

import sys
import time
from collections import deque
import socket
import traceback
import threading
import random
from hashlib import sha1

SERVER_PROTOCOL_VERSION = 1
MAX_PLAYERS = 6

if sys.version > '3':
    PYTHON3 = True
else:
    PYTHON3 = False

if PYTHON3:
    def int_to_bytes(number):
        return bytes([(number & 0xff000000) >> 24, (number & 0x00ff0000) >> 16,
                (number & 0x0000ff00) >> 8, (number & 0x000000ff)])
    def bytes_to_int(m):
        return m[0] << 24 | m[1] << 16 | m[2] << 8 | m[3]
    def byte_ord(v):
        #print("byte_ord", v)
        try:
            return v[0]
        except TypeError:
            return v
    def byte(v):
        return bytes([v])
    server_protocol_version = byte(SERVER_PROTOCOL_VERSION)

else:
    def int_to_bytes(number):
        return chr((number & 0xff000000) >> 24) + \
                chr((number & 0x00ff0000) >> 16) + \
                chr((number & 0x0000ff00) >> 8) + \
                chr((number & 0x000000ff))
    def bytes_to_int(m):
        return ord(m[0]) << 24 | ord(m[1]) << 16 | ord(m[2]) << 8 | ord(m[3])
    def byte_ord(v):
        return ord(v)
    def byte(v):
        return v
    server_protocol_version = chr(SERVER_PROTOCOL_VERSION)

max_drift = 25
num_clients = 2
port = 25100
host = "0.0.0.0"
game = None
game_password = 0
launch_timeout = 0

def create_game_password(value):
    # for python 2 + 3 compatibility
    #if not isinstance(value, unicode):
    value = value.encode("UTF-8")
    #print(repr(value))
    h = sha1()
    h.update(b"FSNP")
    val = b""
    for v in value:
        if byte_ord(v) < 128:
            val += byte(v)
    #print("update:", repr(val))
    h.update(val)
    return bytes_to_int(h.digest()[:4])

for arg in sys.argv:
    if arg.startswith("--"):
        parts = arg[2:].split("=", 1)
        if len(parts) == 2:
            key, value = parts
            key = key.lower()
            if key == "port":
                port = int(value)
            elif key == "players":
                num_clients = int(value)
            elif key == "password":
                #game_password = crc32(value) & 0xffffffff
                game_password = create_game_password(value)
                print("game password (numeric) is", game_password)
            elif key == "launch-timeout":
                launch_timeout = int(value)


MESSAGE_READY             =  0
MESSAGE_MEM_CHECK         =  5
MESSAGE_RND_CHECK         =  6
MESSAGE_PING              =  7
MESSAGE_PLAYERS           =  8
MESSAGE_PLAYER_TAG_0      =  9
MESSAGE_PLAYER_TAG_1      = 10
MESSAGE_PLAYER_TAG_2      = 11
MESSAGE_PLAYER_TAG_3      = 12
MESSAGE_PLAYER_TAG_4      = 13
MESSAGE_PLAYER_TAG_5      = 14

MESSAGE_PLAYER_PING       = 15
MESSAGE_PLAYER_LAG        = 16
MESSAGE_SET_PLAYER_TAG    = 17
MESSAGE_PROTOCOL_VERSION  = 18
MESSAGE_EMULATION_VERSION = 19
MESSAGE_ERROR             = 20
MESSAGE_TEXT              = 21
MESSAGE_SESSION_KEY       = 22

#MESSAGE_MEM_CHECK = 5
#MESSAGE_RND_CHECK = 6
#MESSAGE_PING = 7

MESSAGE_MEMCHECK_MASK = (0x80000000 | (MESSAGE_MEM_CHECK << 24))
MESSAGE_RNDCHECK_MASK = (0x80000000 | (MESSAGE_RND_CHECK << 24))

ERROR_PROTOCOL_MISMATCH    =  1
ERROR_WRONG_PASSWORD       =  2
ERROR_CANNOT_RESUME        =  3
ERROR_GAME_ALREADY_STARTED =  4
ERROR_PLAYER_NUMBER        =  5
ERROR_EMULATOR_MISMATCH    =  6
ERROR_CLIENT_ERROR         =  7
ERROR_MEMORY_DESYNC        =  8
ERROR_RANDOM_DESYNC        =  9
ERROR_SESSION_KEY          = 10
ERROR_GAME_STOPPED         = 99

def create_ext_message(ext, data):
    return 0x80000000 | ext << 24 | (data & 0xffffff)

class Client:
    
    def __init__(self, socket, address):
        #self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.socket = socket
        self.messages = []
        self.lock = threading.Lock()
        self.address = address
        self.ready = 0
        self.tag = b"PLY"
        self.player = 0
        self.playing = False
        self.frame = 0
        self.frame_times = [0.0 for x in range(100)]
        self.lag = 0.0
        self.out_seq = 0
        self.memcheck = [(0, 0) for x in range(100)]
        self.rndcheck = [(0, 0) for x in range(100)]
        self.ping_sent_at = 0
        self.pings = deque([0 for x in range(10)])
        self.pings_sum = 0
        self.pings_avg = 0
        #self.protocol_version = 0
        self.emulator_version = b""
        self.session_key = 0
        
        
        self.temp_a = 0
        self.temp_b = 0
        self.temp_c = 0
    
        threading.Thread(target=self.__thread_function).start()

    def send_error_message(self, error_num):
        print(self, "error", error_num)
        message = 0x80000000 | (MESSAGE_ERROR) << 24 | error_num
        self.send_message(message)

    def send_message(self, message):
        with self.lock:
            #if message == 0x87000000:
            #    #print("queueing %08x" % (message,))
            #    #traceback.print_stack()
            #    self.temp_c += 1
            self.__send_data(int_to_bytes(message))

    def __send_data(self, data):
        #if data[0] == '\x87':
        #    #print("queueing ping")
        #    #traceback.print_stack()
        #    self.temp_c += 1
        self.socket.sendall(data)

    def queue_message(self, message):
        with self.lock:
            #if message == 0x87000000:
            #    #print("queueing %08x" % (message,))
            #    #traceback.print_stack()
            #    self.temp_c += 1
            #print("queueing %08x" % (message,))
            #if message & 0x20000000:
            #    traceback.print_stack()
            self.messages.append(int_to_bytes(message))
            if len(self.messages) == 100:
                self.__send_queued_messages()

    def queue_bytes(self, message):
        with self.lock:
            self.messages.append(message)
            if len(self.messages) == 100:
                self.__send_queued_messages()

    def send_queued_messages(self):
        with self.lock:
            self.__send_queued_messages()

    def __send_queued_messages(self):
        data = b"".join(self.messages)
        self.messages[:] = []
        #print("sending", repr(data))
        self.__send_data(data)

    def initialize_client(self):
        print("initialize", self)
        def read_bytes(num):
            data = b""
            for i in range(num):
                data = data + self.socket.recv(1)
            if not len(data) == num:
                raise Exception("did not get {0} bytes".format(num))
            return data
        # check header message
        data = read_bytes(4)
        if data == b"PING":
            # connection check only
            self.__send_data(b"PONG")
            return False
        if data != b"FSNP":
            print(data)
            raise Exception("did not get expected FSNP header")
        # check protocol version
        data = self.socket.recv(1)
        #print(repr(data), repr(server_protocol_version))
        if data != server_protocol_version:
            print("protocol mismatch")
            self.send_error_message(ERROR_PROTOCOL_MISMATCH)
            return False
        # check net play password
        password = bytes_to_int(read_bytes(4))
        if password != game_password:
            print("wrong password")
            self.send_error_message(ERROR_WRONG_PASSWORD)
            return False
        # read emulator version
        self.emulator_version = read_bytes(8)
        # read player number and session key, session key is checked to
        # make sure another client cannot hijack this player slot
        self.session_key = bytes_to_int(b"\0" + read_bytes(3))  
        self.player = byte_ord(self.socket.recv(1))
        self.tag = read_bytes(3)
        # get package sequence number
        self.resume_from_packet = bytes_to_int(read_bytes(4))
        
        error = game.add_client(self)
        if error:
            self.send_error_message(error)
            return False

        message = create_ext_message(MESSAGE_SESSION_KEY, self.session_key)
        self.queue_message(message)
        data = (self.player << 8) | num_clients 
        message = create_ext_message(MESSAGE_PLAYERS, data)
        self.queue_message(message)
        
        game.send_player_tags(self)
        self.send_queued_messages()
        print("initialize done for", self)
        return True

    def __thread_function(self):
        try:
            try:
                if not self.initialize_client():
                    print("initialize failed for", self)
                    return
                self.receive_loop()
            except Exception:
                traceback.print_exc()
                game.stop = True
        finally:
            try:
                self.socket.close()
            except Exception:
                pass

    
    def receive_loop(self):
        data = b""
        count = 0
        while not game.stop:
            data = data + self.socket.recv(4 - count)
            count = len(data)
            if count == 4:
                self.on_message(data)
                count = 0
                data = b""
    
    def send_ping(self):
        with self.lock:
            #print("ping?", self.ping_sent_at)
            if self.ping_sent_at == 0:
                self.temp_a += 1
                self.ping_sent_at = time.time()
                message = int_to_bytes(0x80000000 | (7 << 24))
                self.__send_data(message)
                assert self.ping_sent_at > 0

    def on_ping(self):
        # may not need lock here
        with self.lock:
            self.temp_b += 1
            if self.temp_a != self.temp_b:
                print(self.temp_a, self.temp_b, self.temp_c)
            assert self.ping_sent_at > 0
            t = time.time()
            new = (t - self.ping_sent_at) / 1.0
            #print(t, "-", self.ping_sent_at, "=", new)
            old = self.pings.popleft()
            self.pings.append(new)
            #print(self.pings)
            self.pings_sum = self.pings_sum - old + new
            self.pings_avg = self.pings_sum / len(self.pings)
            self.ping_sent_at = 0
    
    def on_message(self, m):
        message = bytes_to_int(m)
        #with game.lock:
        #    if not self.playing:
        #        print(self, "is no longer playing/valid, ignoring message")
        
        if message & 0x80000000:
            # ext message
            command = (message & 0x7f000000) >> 24
            data = message & 0x00ffffff;
            if command == MESSAGE_MEM_CHECK:
                self.memcheck[self.frame % 100] = (data, self.frame)
            elif command == MESSAGE_RND_CHECK:
                self.rndcheck[self.frame % 100] = (data, self.frame)
            elif command == MESSAGE_PING:
                #print("{0:x}".format(message))
                self.on_ping()
            elif command == MESSAGE_TEXT:
                print("received text command")
                remaining = data
                text = b""
                while not game.stop:
                    part = self.socket.recv(remaining)
                    count = len(part)
                    text += part
                    remaining = remaining - count
                    if remaining == 0:
                        game.add_text_message(self, text)
                        break

        elif message & (1 << 30):
            frame =  message & 0x3fffffff
            #print("received frame", frame)
            if frame != self.frame + 1:
                print("error, expected frame", self.frame + 1, "got", frame)
            #print("received frame", frame)
            self.frame = frame
            t = time.time()
            self.frame_times[self.frame % 100] = t
            game_t = game.frame_times[self.frame % 100]
            self.lag = t - game_t

        elif message & (1 << 29):
            game.add_input_event(self, message & 0x00ffffff)

        else:
            print("warning: unknown command received %x" % (message,))
        
    def __str__(self):
        return "<Client {0}:{1} {2}>".format(self.player, self.tag,
                self.address)

def create_session_key():
    return random.randint(0, 2**24 - 1)

class Game:
    
    def __init__(self, num_clients):
        self.started = False
        self.frame = 0
        self.time = 0
        self.clients = []
        self.num_clients = 0
        self.frame_times = [0.0 for x in range(100)]
        self.lock = threading.Lock()
        self.stop = False
        self.session_keys = [0 for x in range(MAX_PLAYERS)]
        self.emulator_version = b""
        self.verified_frame = -1

    def __start(self):
        if len(self.clients) != num_clients:
            printf("error - cannot start until all players have connected")
            return
        print("{0} clients connected, starting game".format(num_clients))
        self.started = True
        threading.Thread(target=self.__thread_function).start()

    def add_client(self, client):
        with self.lock:
            if client.player == 0xff:
                if client.resume_from_packet != 0:
                    return ERROR_CLIENT_ERROR
                if self.started:
                    return ERROR_GAME_ALREADY_STARTED
                client.player = len(self.clients)
                if client.player == 0:
                    self.emulator_version = client.emulator_version
                else:
                    if self.emulator_version != client.emulator_version:
                        return ERROR_EMULATOR_MISMATCH
                client.session_key = create_session_key()
                self.session_keys[client.player] = client.session_key
                self.clients.append(client)
                client.playing = True
                if not self.started:
                    if len(self.clients) == num_clients:
                        self.__start()
            else:
                if client.player >= len(self.clients):
                    return ERROR_PLAYER_NUMBER
                if self.session_keys[client.player] != client.session_key:
                    return ERROR_SESSION_KEY
                old_client = self.clients[client.player]
                # FIXME: must transfer settings for resuming to work
                self.clients[client.player] = client
                client.playing = True
                
                if client.resume_from_packet > 0:
                    # cannot resume yet...
                    print("cannot resume at packet", resume_from_packet)
                    return ERROR_CANNOT_RESUME
        return 0
        # FIXME: start the game..?

    def __thread_function(self):
        try:
            self.__game_loop()
        except Exception:
            traceback.print_exc()
            self.stop = True

    def __send_player_tags(self, send_to_client):
        for i, client in enumerate(game.clients):
            data = bytes_to_int(b"\0" + client.tag)
            message = create_ext_message(MESSAGE_PLAYER_TAG_0 + i, data)
            send_to_client.queue_message(message)

    def send_player_tags(self, client):
        with game.lock:
            self.__send_player_tags(client)

    def __game_loop(self):
        with self.lock:
            for client in self.clients:
                self.__send_player_tags(client)
        print("game loop running")
        self.time = time.time()
        while True:
            if self.stop:
                print("stopping game loop")
                # try to send error message to all players
                with self.lock:
                    for client in self.clients:
                        try:
                            client.send_error_message(ERROR_GAME_STOPPED)
                        except Exception:
                            traceback.print_exc()
                return
            self.__game_loop_iteration()
    
    def __game_loop_iteration(self):
        # FIXME: higher precision sleep?
        target_time = self.time + 0.02
        t2 = time.time()
        diff = target_time - t2
        sleep = diff - 0.001
        if sleep > 0.0:
            #print(sleep)
            time.sleep(sleep)
        self.time = target_time
        while time.time() < target_time:
            # busy-loop until target time
            pass
        
        with self.lock:
            if self.frame % 100 == 0:
                self.__send_status()
            self.frame += 1
            self.frame_times[self.frame % 100] = time.time()
            message = (1 << 30) | self.frame
            self.__send_to_clients(message, True)
            if self.frame % 10 == 0:
                for client in self.clients:
                    client.send_ping()
            if self.frame % 200 == 0:
                self.__print_status()

        self.__check_game()

    def __check_game(self):
        oldest_frame, frames = self.__check_frame_status()
        while oldest_frame > self.verified_frame:
            self.check_synchronization(self.verified_frame + 1)
            self.verified_frame += 1
        diff = self.frame - oldest_frame
        if diff <= max_drift:
            # clients have not drifted too far
            return
        first = True
        count = 0;
        while diff > 0 and not self.stop:
            if first:
                first = False
                print("---", self.frame, "acked", frames)
            elif count % 100 == 0:
                print("   ", self.frame, "acked", frames)
            time.sleep(0.02)
            oldest_frame, frames = self.__check_frame_status()
            diff = self.frame - oldest_frame
            count += 1
        self.time = time.time() - 0.02

    def __check_frame_status(self):
        oldest_frame = self.frame
        frames = [] 
        with self.lock:
            for client in self.clients:
                af = client.frame
                if af < oldest_frame:
                    oldest_frame = af
                frames.append(af)
        return oldest_frame, frames

    def __print_status(self):
        for i, client in enumerate(self.clients):
            print("{0} f {1:6d} p avg: {2:3d} {3:3d}".format(i,
                    client.frame, int(client.pings_avg * 1000),
                    int(client.lag * 1000)))
            
    def __send_status(self):
        for i, client in enumerate(self.clients):
            v = int(client.lag * 1000) & 0x0000ffff
            message = 0x80000000 | MESSAGE_PLAYER_LAG << 24 | i << 16 | v
            self.__send_to_clients(message)
            v = int(client.pings_avg * 1000) & 0x0000ffff
            message = 0x80000000 | MESSAGE_PLAYER_PING << 24 | i << 16 | v
            self.__send_to_clients(message)
    
    def add_input_event(self, client, input_event):
        if not self.started:
            # game was not started - ignoring input event
            print("game not started, ignoring input event {0:08x}".format(
                    input_event))
            return
        with self.lock:
            if not client.playing:
                print("client", client, "is no longer valid, dropping msg")
                return
            # for now, just broadcast out again to all clients
            message = (1 << 29) | input_event
            self.__send_to_clients(message)

    def add_text_message(self, from_client, text):
        print("add text message")
        with self.lock:
            for client in self.clients:
                #if from_client == client:
                #    continue
                message = 0x80000000 | MESSAGE_TEXT << 24 \
                        | from_client.player << 16 | len(text)
                message = int_to_bytes(message) + text
                print("send", repr(message), "to", client)
                client.queue_bytes(message)

    def send_to_clients(self, message, force_send=False):
        # using a lock here to ensure that send_to_clients can
        # be called from multiple threads, but all clients will
        # still get messages in expected order
        with self.lock:
            self.__send_to_clients(message, force_send)
    
    def __send_to_clients(self, message, force_send=False):
        for client in self.clients:
            #print("send", message, "to", client)
            client.queue_message(message)
            if force_send:
                client.send_queued_messages()
    
    def check_synchronization(self, check_frame):
        # FIXME: MOVE TO GAME CLASS
        # FIXME: ONLY RUN ONCE PER FRAME, not once per frame * clients
        #if self.frame == 0:
        #    return
        with game.lock:
            #print("received memcheck", data)
            #check_frame = self.frame - 1
            if check_frame < 0:
                return
            index = check_frame % 100
            mem_check_data = []
            rnd_check_data = []
            for client in game.clients:
                if client.frame <= check_frame:
                    # cannot check yet
                    return
                #print(client, client.frame, client.memcheck)
                mem_check_data.append((client, client.memcheck[index]))
                rnd_check_data.append((client, client.rndcheck[index]))
            check = mem_check_data[0][1]
            for client, data in mem_check_data:
                if check != data:
                    print("memcheck failed for frame", check_frame)
                    for c, d in mem_check_data:
                        print("* {0:08x}  f {1:05d} {2}".format(d[0], d[1], c))
                    for c in game.clients:
                        c.send_error_message(ERROR_MEMORY_DESYNC)
                        c.send_queued_messages()
                    raise Exception("mem check failed")
            check = rnd_check_data[0][1]
            for client, data in rnd_check_data:
                if check != data:
                    print("rndcheck failed for frame", check_frame)
                    for c, d in rnd_check_data:
                        print("* {0:08x}  f {1:05d} {2}".format(d[0], d[1], c))
                    for c in game.clients:
                        c.send_error_message(ERROR_RANDOM_DESYNC)
                        c.send_queued_messages()
                    raise Exception("rnd check failed")

address_map = {

}

def accept_client(server_socket):
    server_socket.settimeout(1)
    client_socket, client_address = server_socket.accept()
    #client_socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDLOWAT, 4)
    client_socket.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, 1)
    client_socket.settimeout(None)
    client = Client(client_socket, client_address)
    #client.player = len(game.clients) + 1
    print("Client connected", client)
    #game.add_client(client)
    #client.start()
    #if game.can_start():
    #    game.start()

#stop_accepting = False

def accept_thread(server_socket):
    while not game.stop:
        try:
            accept_client(server_socket)            
        except socket.timeout:
            pass
        except Exception:
            traceback.print_exc()
            time.sleep(1.0)

def _run_server():
    global game
    game = Game(num_clients)
    address = (host, port)
    server_socket = socket.socket()
    server_socket.bind(address)
    server_socket.listen(4)
    if address[0] != "0.0.0.0":
        print("server listening on", address[0], "port", address[1])
    else:
        print("server listening on port", address[1])
    print("want", num_clients, "client(s)")
    if num_clients > MAX_PLAYERS:
        print("ERROR: max clients are", MAX_PLAYERS)
    threading.Thread(target=accept_thread, args=(server_socket,)).start()
    t1 = time.time()
    while not game.started:
        time.sleep(0.1)
        if launch_timeout:
            t2 = time.time()
            if t2 - t1 > launch_timeout:
                print("game not started yet, aborting")
                game.stop = True
                return
                #sys.exit()
    print("game started")
    while not game.stop:
        time.sleep(0.1)

def run_server():
    try:
        _run_server()
    except Exception:
        traceback.print_exc()
    except KeyboardInterrupt:
        traceback.print_exc()
    game.stop = True

if __name__ == "__main__":
    run_server()