aws_client.py

import socket
import threading
import sys
import os

#write here aws server public ip address
SERVER_HOST = 'x.x.x.x'
SERVER_PORT = 5500


def handle_incoming_messages(sock, is_receiver=False):
    """
    Continuously read incoming data from the server
    and handle messages such as 'RECEIVER_LIST|...', 'FILE|...', or 'ERROR|...'.
    If 'is_receiver' is True, we also handle incoming file data.
    """
    while True:
        try:
            header = sock.recv(1024)
            if not header:
                print("[!] Lost connection to the server.")
                break

            msg = header.decode('utf-8')
            parts = msg.split("|")

            if parts[0] == "RECEIVER_LIST":
                # Format: "RECEIVER_LIST|receiver1,receiver2,receiver3"
                if len(parts) == 2:
                    receiver_list = parts[1].split(",") if parts[1] else []
                    #print("[*] Updated receiver list:", receiver_list)

            elif parts[0] == "ERROR":
                # Example: "ERROR|Receiver not found"
                print("[!] Error from server:", msg)



            elif parts[0] == "FILE" and is_receiver:

                # Expected format: "FILE|sender_name|filename|filesize"

                if len(parts) == 4:
                    _, sender_name, filename, filesize = parts
                    filesize = int(filesize)
                    print(f"[+] Incoming file '{filename}' ({filesize} bytes) from {sender_name}")

                    # Ask the user if they want to rename the file
                    new_filename = input(
                        f"[?] Enter a new name for the file (press Enter to keep '{filename}'): ").strip()

                    if new_filename == "":
                        new_filename = filename  # Use the original filename if no new name is provided

                    # Read the actual file data in a loop until we get 'filesize' bytes
                    file_data = b""
                    bytes_received = 0

                    while bytes_received < filesize:
                        chunk = sock.recv(4096)
                        if not chunk:
                            print("[!] Connection lost while receiving file data.")
                            return

                        file_data += chunk
                        bytes_received += len(chunk)

                    # Construct the path to the Desktop
                    desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
                    file_path = os.path.join(desktop_path, new_filename)

                    # Save the file to the Desktop
                    with open(file_path, 'wb') as f:
                        f.write(file_data)
                    print(f"[+] File '{new_filename}' received and saved to Desktop. ({len(file_data)} bytes)")

                else:
                    print("[!] Invalid FILE header format.")

            else:
                # You can implement other message types or simply ignore
                pass

        except ConnectionResetError:
            print("[!] Connection reset by server.")
            break
        except Exception as e:
            print(f"[!] Error reading server messages: {e}")
            break

    print("[*] Incoming messages thread exiting.")


def sender_mode(name):
    """
    Sender mode.
    1. Connect to the server and identify as "SENDER|<name>".
    2. Start a thread to continuously handle incoming messages (e.g., RECEIVER_LIST).
    3. Prompt user to send files to a specific receiver.
    """
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((SERVER_HOST, SERVER_PORT))
    s.sendall(f"SENDER|{name}".encode('utf-8'))
    print("[*] Connected to server as a sender.")

    # Listener thread (not handling FILE downloads, so is_receiver=False)
    listener_thread = threading.Thread(target=handle_incoming_messages, args=(s, False), daemon=True)
    listener_thread.start()

    try:
        while True:
            command = input("Enter command (e.g., send bob sample.txt): ").strip()
            if not command:
                continue

            parts = command.split()
            if len(parts) == 3 and parts[0] == "send":
                _, target_receiver, filename = parts
                if not os.path.isfile(filename):
                    print(f"[DEBUG] Filename provided: {filename}")
                    print("[!] File not found.")
                    continue
                filesize = os.path.getsize(filename)

                # Send the header: "SEND|receiver_name|filename|filesize"
                header = f"SEND|{target_receiver}|{filename}|{filesize}"
                s.sendall(header.encode('utf-8'))

                # Send file data in chunks
                with open(filename, 'rb') as f:
                    while True:
                        chunk = f.read(4096)
                        if not chunk:
                            break
                        s.sendall(chunk)

                print(f"[+] Sent file '{filename}' ({filesize} bytes) to {target_receiver}")

            else:
                print("[!] Invalid command. Example: send bob sample.txt")

    except KeyboardInterrupt:
        print("[!] Sender shutting down via Ctrl+C.")
    finally:
        s.close()
        print("[*] Socket closed.")


def receiver_mode(name):
    """
    Receiver mode.
    1. Connect to the server and identify as "RECEIVER|<name>".
    2. Start a thread to continuously handle incoming messages (including FILEs).
    """
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((SERVER_HOST, SERVER_PORT))
    s.sendall(f"RECEIVER|{name}".encode('utf-8'))
    print("[*] Connected to server as a receiver.")

    # Listener thread that *can* receive files, so is_receiver=True
    listener_thread = threading.Thread(target=handle_incoming_messages, args=(s, True), daemon=True)
    listener_thread.start()

    print("[*] Press Ctrl+C to exit.")
    try:
        while True:
            # Typically, a receiver just waits for incoming files or messages
            pass
    except KeyboardInterrupt:
        print("\n[!] Receiver shutting down.")
    finally:
        s.close()
        print("[*] Socket closed.")


if __name__ == "__main__":
    # Usage:
    #   python aws_client.py RECEIVER alice
    #   python aws_client.py SENDER bob
    if len(sys.argv) != 3:
        print(f"Usage: python {sys.argv[0]} <ROLE> <NAME>")
        sys.exit(1)

    role = sys.argv[1].upper()
    name = sys.argv[2]

    if role == "RECEIVER":
        receiver_mode(name)
    elif role == "SENDER":
        sender_mode(name)
    else:
        print("[!] Invalid role. Please enter RECEIVER or SENDER.")