part2_server.py

import sys
import socket
import select
import argparse

# Dictionary
registered_clients = {}


def register(client_socket, data):
    lines = data.split("\r\n")
    client_id = None 
    client_ip = None 
    client_port = None

    for line in lines:
        if line.startswith("clientID:"):
            client_id = line.split(":")[1].strip()
        elif line.startswith("IP:"):
            client_ip = line.split(":")[1].strip()
        elif line.startswith("Port:"):
            client_port = line.split(":")[1].strip()

    if client_id and client_ip and client_port:
        sys.stdout.write(f"REGISTER: {client_id} from {client_ip}:{client_port} received\n")
        sys.stdout.flush()

        registered_clients[client_id] = (client_ip, client_port)

        regack_message = f"REGACK\r\nclientID: {client_id}\r\nIP: {client_ip}\r\nPort: {client_port}\r\nStatus: registered\r\n\r\n"
        client_socket.sendall(regack_message.encode())
    else:
        sys.stdout.write("Invalid REGISTER message format\n")
        sys.stdout.flush()

def bridge(client_socket, data):
    requesting_client = None
    requesting_client_ip = None
    requesting_client_port = None

    lines = data.split("\r\n")
    for line in lines:
        if line.startswith("clientID:"):
            requesting_client = line.split(":")[1].strip()

    if requesting_client in registered_clients:
        requesting_client_ip, requesting_client_port = registered_clients[requesting_client]
    else:
        sys.stdout.write(f"Invalid BRIDGE request: Requesting client '{requesting_client}' not found\n")
        sys.stdout.flush()
        return

    peer = None
    for peer_id, (peer_ip, peer_port) in registered_clients.items():
        if peer_id != requesting_client:
            peer = (peer_id, peer_ip, peer_port)
            break

    if peer:
        peer_id, peer_ip, peer_port = peer
        bridgeack_message = (
            f"BRIDGEACK\r\n"
            f"clientID: {peer_id}\r\n"
            f"IP: {peer_ip}\r\n"
            f"Port: {peer_port}\r\n\r\n"
        )
        client_socket.sendall(bridgeack_message.encode())
        sys.stdout.write(f"BRIDGE: {peer_id} {peer_ip}:{peer_port} {requesting_client} {requesting_client_ip}:{requesting_client_port}\n")
        sys.stdout.flush()
    else:
        bridgeack_null = (
            f"BRIDGEACK\r\n"
            f"clientID: \r\n"
            f"IP: \r\n"
            f"Port: \r\n\r\n"
        )
        client_socket.sendall(bridgeack_null.encode())
        sys.stdout.write(f"BRIDGE: {requesting_client} {requesting_client_ip}:{requesting_client_port}\n")
        sys.stdout.flush()


def message(client_socket, data):
    if data.startswith("REGISTER\r\n"):
        register(client_socket, data)
    elif data.startswith("BRIDGE\r\n"):
        bridge(client_socket, data)
    else:
        sys.stdout.write(f"Unknown message received: {data}\n")
        sys.stdout.flush()

def display_clients():
    for client_id, (client_ip, client_port) in registered_clients.items():
        sys.stdout.write(f"{client_id} {client_ip}:{client_port}\n")
        sys.stdout.flush()

def main():
    parse = argparse.ArgumentParser()
    parse.add_argument('--port', type=int)
    args = parse.parse_args()
    try:
        sv_port = args.port
        if not (1<=sv_port <= 65535):
            raise ValueError("Port number must be between 1 and 65535.\n")
    except ValueError as e:
        sys.stdout.write(f"Error: Invalid port number for Server\n")
        sys.stdout.flush()
        sys.exit(1)

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server_socket.bind(('127.0.0.1', sv_port))
    server_socket.listen(5)

    sys.stdout.write(f"Server listening on 127.0.0.1:{sv_port}\n")
    sys.stdout.flush()

    sockets = [server_socket, sys.stdin]

    try:
        while True:
            # Monitor sockets for readability
            readable, _, _ = select.select(sockets, [], [])

            for sock in readable:
                if sock is server_socket:
                    client_socket, addr = server_socket.accept()
                    sockets.append(client_socket)
                elif sock is sys.stdin:
                    command = sys.stdin.readline().strip()
                    if command == "/info":
                        display_clients()
                    else:
                        continue
                else:
                    try:
                        data = sock.recv(1024).decode().strip()
                        if data:
                            message(sock, data)
                        else:
                            sockets.remove(sock)
                            sock.close()
                    except Exception as e:
                        sys.stdout.write(f"Error: {e}")
                        sys.stdout.flush();
                        sockets.remove(sock)
                        sock.close()
    except KeyboardInterrupt:
        sys.stdout.write("select(): Interrupted system call\n")
        sys.stdout.flush()
    finally:
        server_socket.close()

if __name__ == "__main__":
    main()
"""
    Citations
    - Used help from Chatgpt in understanding select() and
      how exactly select works(because I have never used select() before this assignment)
    - Used the Socket Programming in Python(Guide) and the textbook 
      for guidance with understanding how socket programming actually worked, because
      before this class I've also never even heard about socket programming.
    - Used ChatGpt to understand the process of storing items in a dictionary
"""