EX.

NO 3: Demonstrate Applications using TCP sockets using python

i) Echo client and echo server

AIM:

PROCEDURE:

PROGRAM:
Echo Server:
import socket

# Define server host and port

HOST = '127.0.0.1' # Localhost
PORT = 12345 # Port to bind to

# Create a TCP/IP socket

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Bind the socket to the port

server_socket.bind((HOST, PORT))

# Enable the server to accept connections (max 1 connection in the queue)

server_socket.listen(1)
print(f"Server listening on {HOST}:{PORT}")

# Wait for a connection

connection, client_address = server_socket.accept()
print(f"Connected by {client_address}")

try:
# Keep receiving and echoing messages from the client
while True:
data = connection.recv(1024) # Buffer size
if not data:
break # No more data received, exit the loop

print(f"Received: {data.decode()}")

# Echo the received message back to the client

connection.sendall(data)

finally:
# Clean up the connection
connection.close()
server_socket.close()

Echo Client:
import socket

# Define server host and port

HOST = '127.0.0.1' # Localhost
PORT = 12345 # Port to connect to

# Create a TCP/IP socket

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Connect to the server

client_socket.connect((HOST, PORT))

# Send a message to the server

message = "Hello, Server!"
print(f"Sending message: {message}")
client_socket.sendall(message.encode())

# Receive the echoed message from the server

data = client_socket.recv(1024) # Buffer size
print(f"Received from server: {data.decode()}")

# Close the socket

client_socket.close()

Server Output:

Server listening on 127.0.0.1:12345

Connected by ('127.0.0.1', 56789)
Received: Hello, Server!

Client Output:

Sending message: Hello, Server!

Received from server: Hello, Server!
 Evaluation by faculty

Criteria Marks

Preparation /20

Observation /25

Interpretation of Result /20

Viva /10

Total /75

Faculty Signature with Date

RESULT:
3)ii) Chat
AIM:

PROCEDURE

Chat Server (TCP Server)

The server will:
 Listen for incoming connections from clients.
 Accept messages from clients and broadcast them to all connected clients.
Chat Client (TCP Client)
The client will:
 Connect to the server.
 Send messages to the server.
 Display received messages from other clients.
Chat Server Code:
import socket
import threading

# List to keep track of client connections

clients = []

# Broadcast function to send messages to all clients

def broadcast(message, client_socket):
for client in clients:
if client != client_socket:
try:
client.send(message)
except:
 client.close()
clients.remove(client)

# Handle communication with each client

def handle_client(client_socket):
# Welcome message
client_socket.send("Welcome to the chat! Type 'exit' to leave.\n".encode())

while True:
try:
message = client_socket.recv(1024)
if message:
print(f"Received: {message.decode('utf-8')}")
broadcast(message, client_socket)
else:
break
except:
break

# Remove client from the list and close connection

clients.remove(client_socket)
client_socket.close()

# Start the chat server

def chat_server(host, port):
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((host, port))
server_socket.listen(5)
print(f"Server started on {host}:{port}")

while True:
client_socket, client_address = server_socket.accept()
print(f"New connection from {client_address}")
 clients.append(client_socket)

# Start a new thread for each client

thread = threading.Thread(target=handle_client, args=(client_socket,))
thread.start()

if __name__ == "__main__":
chat_server("127.0.0.1", 65432) # Server running on localhost:65432
Chat Client Code:
import socket
import threading

# Function to receive messages from the server

def receive_messages(client_socket):
while True:
try:
message = client_socket.recv(1024)
if message:
print(message.decode('utf-8'))
else:
break
except:
break

# Function to send messages to the server

def send_messages(client_socket):
while True:
message = input()
if message.lower() == 'exit':
client_socket.send("User has left the chat.\n".encode())
break
client_socket.send(message.encode())
# Start the chat client
def chat_client(host, port):
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((host, port))

# Start receiving messages from the server

thread = threading.Thread(target=receive_messages, args=(client_socket,))
thread.start()

# Send messages to the server

send_messages(client_socket)

client_socket.close()

if __name__ == "__main__":
chat_client("127.0.0.1", 65432) # Connect to the server running on localhost:65432

Server Output:
Server started on 127.0.0.1:65432
New connection from ('127.0.0.1', 12345)
New connection from ('127.0.0.1', 12346)
Client 1 Output (After Connecting to Server):
Welcome to the chat! Type 'exit' to leave.
Hello everyone!
Client 2 Output (After Connecting to Server):
Welcome to the chat! Type 'exit' to leave.
Hi, how are you?
 Evaluation by faculty

Criteria Marks

Preparation /20

Observation /25

Interpretation of Result /20

Viva /10

Total /75

Faculty Signature with Date

RESULT:

3)iii) File Transfer

AIM:

PROCEDURE:
Steps for File Transfer:
1. Server Side:
o The server listens on a specific port for incoming connections.

o It accepts the connection, receives the file data in chunks, and writes the data
to a file.
2. Client Side:
o The client connects to the server.

o It reads the file in binary mode and sends the data to the server in chunks

Server Code (File Transfer Server):

import socket

def file_server(host, port):

# Create a TCP/IP socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Bind the socket to the address and port

server_socket.bind((host, port))

# Enable the server to accept connections

server_socket.listen(1)
print(f"Server listening on {host}:{port}")

while True:
# Accept a client connection
client_socket, client_address = server_socket.accept()
print(f"Connection from {client_address} established.")

# Receive the file name

file_name = client_socket.recv(1024).decode()
print(f"Receiving file: {file_name}")

with open(f"received_{file_name}", "wb") as file:

 while True:
# Receive the file data in chunks
data = client_socket.recv(4096)
if not data:
break
file.write(data)

print(f"File '{file_name}' received successfully.")

# Close the connection

client_socket.close()

if __name__ == "__main__":
file_server("127.0.0.1", 65432) # You can use a different port

Client Code (File Transfer Client):

import socket

def file_client(host, port, file_path):

# Create a TCP/IP socket
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# Connect to the server

client_socket.connect((host, port))

# Send the file name

file_name = file_path.split("/")[-1]
client_socket.send(file_name.encode())

# Open the file and send its content in chunks

with open(file_path, "rb") as file:
while True:
data = file.read(4096)
 if not data:
break
client_socket.send(data)

print(f"File '{file_name}' sent successfully.")

# Close the connection

client_socket.close()

if __name__ == "__main__":
file_client("127.0.0.1", 65432, "sample_file.txt") # Path to the file you want to send
Server Output:
Server listening on 127.0.0.1:65432
Connection from ('127.0.0.1', 12345) established.
Receiving file: sample_file.txt
File 'sample_file.txt' received successfully.
Client Output:
File 'sample_file.txt' sent successfully.
 Evaluation by faculty

Criteria Marks

Preparation /20

Observation /25

Interpretation of Result /20

Viva /10

Total /75

Faculty Signature with Date

RESULT: