The program is a simple real-time chat application implemented in Python. It has two parts:
1. Server: Manages the communication between clients.
2. Client: Allows users to connect to the server and exchange messages.
The communication happens over a TCP connection using the socket module.
Server Code
The server listens for incoming client connections and handles their communication. Each client runs in a separate thread for simultaneous interactions.
Key Features:
1. Broadcasting Messages: When a client sends a message, the server broadcasts it to all other connected clients.
2. Threaded Connections: Each client is managed by a dedicated thread for handling its messages.
Code Walkthrough:
import socket
import threading
# Server configuration
HOST = '127.0.0.1' # Localhost
PORT = 12345 # Port for the server to listen on
clients = [] # List to store connected clients
def broadcast(message, current_client):
"""Send a message to all connected clients except the sender."""
for client in clients:
if client != current_client:
client.send(message)
def handle_client(client):
"""Handle communication with a single client."""
while True:
try:
message = client.recv(1024)
if message:
print(f"Received: {message.decode('utf-8')}")
broadcast(message, client)
except:
print("Client disconnected.")
clients.remove(client)
client.close()
break
def start_server():
"""Start the server and accept client connections."""
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((HOST, PORT))
server.listen(5) # Allow up to 5 pending connections
print(f"Server is running on {HOST}:{PORT}...")
while True:
client, address = server.accept()
print(f"Connected: {address}")
clients.append(client)
thread = threading.Thread(target=handle_client, args=(client,))
thread.start()
if __name__ == "__main__":
start_server()
Client Code
The client connects to the server and enables the user to send and receive messages.
Key Features:
1. Receive Messages: Continuously listens for messages from the server in a separate thread.
2. Send Messages: Sends user input to the server.
Code Walkthrough:
import socket
import threading
# Server configuration
HOST = '127.0.0.1' # Server's IP address
PORT = 12345 # Port to connect to
def receive_messages(client):
"""Receive messages from the server."""
while True:
try:
message = client.recv(1024).decode('utf-8')
print(message)
except:
print("Connection to the server lost.")
client.close()
break
def send_messages(client):
"""Send messages to the server."""
while True:
message = input()
client.send(message.encode('utf-8'))
def start_client():
"""Connect to the server and start communication."""
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((HOST, PORT))
print("Connected to the server.")
# Start threads for receiving and sending messages
threading.Thread(target=receive_messages, args=(client,)).start()
threading.Thread(target=send_messages, args=(client,)).start()
if __name__ == "__main__":
start_client()
How to Run the Program
1. Start the Server: Save the server code in a file named server.py and run it:
python server.py
2. Start the Clients: Save the client code in a file named client.py. Run multiple instances of it to simulate multiple users:
python client.py
3. Chatting:
Each client can type a message, and it will be broadcast to all connected clients.
Possible Enhancements
1. Usernames: Add support for usernames or nicknames.
2. Encryption: Secure the communication using SSL/TLS.
3. GUI: Use tkinter or PyQt for a graphical user interface.
4. Persistence: Store chat history in a file or database.
5. Multi-room Chat: Allow users to join different chat rooms.