USING PYTHON 2.7!!! Programming Assignment 2: Socket Programming In this assignm

Question

USING PYTHON 2.7!!! Programming Assignment 2: Socket Programming In this assignment, you'll write a server and client program. There are two clients, X and Y (both essentially identical) that will communicate with a server. Clients X and Y will each open a TCP socket to your server and send a message to your server. The message contains the name of the client followed by your name (e.g., "Client X: Alice", "Client Y: Bob). The server will accept connections from both clients and after it has received messages from both X and Y will print their messages and then send an acknowledgment back to your clients The acknowledgment from the server should contain the sequence in which the client messages were received ("X: Alice received before Y: Bob, or Y: Bob received before X: Alice"). After the server sends out this message it should output a message saying- "Sent acknowledgment to both X and Y". Your server can then terminate. Once your clients receive the message from the server, they should print the message that they sent to the server, followed by the reply received from the server. The following figure explains the problem Server Client Y Client X Client X X: Alice Your program should print out the messages sent by the chent at both the client and server and vice versa for messages sent by the server

Explanation / Answer

creating a socket server and client in python. In this post we are going to write a very simple chat application in python that is powered by sockets.

The chat application we are going to make will be more like a chat room, rather than a peer to peer chat. So this means that multiple users can connect to the chat server and send their messages. Every message is broadcasted to every connected chat user. The construction is as simple as the theory.

Code
The code consists of 2 python scripts. First is the server and the other is the chat client.

Chat server
The chat server does the following things

1. Accept multiple incoming connections for client.
2. Read incoming messages from each client and broadcast them to all other connected clients.

Here is the code of the chat server. It server opens up port 5000 to listen for incoming connections. The chat client must connect to this same port. You can change the port number if you want.

The server handles multiple chat clients with select based multiplexing. The select function monitors all the client sockets and the master socket for readable activity. If any of the client socket is readable then it means that one of the chat client has send a message.

# Tcp Chat server

import socket, select

#Function to broadcast chat messages to all connected clients
def broadcast_data (sock, message):
#Do not send the message to master socket and the client who has send us the message
for socket in CONNECTION_LIST:
if socket != server_socket and socket != sock :
try :
socket.send(message)
except :
# broken socket connection may be, chat client pressed ctrl+c for example
socket.close()
CONNECTION_LIST.remove(socket)

if __name__ == "__main__":

# List to keep track of socket descriptors
CONNECTION_LIST = []
RECV_BUFFER = 4096 # Advisable to keep it as an exponent of 2
PORT = 5000

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# this has no effect, why ?
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(("0.0.0.0", PORT))
server_socket.listen(10)

# Add server socket to the list of readable connections
CONNECTION_LIST.append(server_socket)

print "Chat server started on port " + str(PORT)

while 1:
# Get the list sockets which are ready to be read through select
read_sockets,write_sockets,error_sockets = select.select(CONNECTION_LIST,[],[])

for sock in read_sockets:
#New connection
if sock == server_socket:
# Handle the case in which there is a new connection recieved through server_socket
sockfd, addr = server_socket.accept()
CONNECTION_LIST.append(sockfd)
print "Client (%s, %s) connected" % addr

broadcast_data(sockfd, "[%s:%s] entered room " % addr)

#Some incoming message from a client
else:
# Data recieved from client, process it
try:
#In Windows, sometimes when a TCP program closes abruptly,
# a "Connection reset by peer" exception will be thrown
data = sock.recv(RECV_BUFFER)
if data:
broadcast_data(sock, " " + '<' + str(sock.getpeername()) + '> ' + data)   

except:
broadcast_data(sock, "Client (%s, %s) is offline" % addr)
print "Client (%s, %s) is offline" % addr
sock.close()
CONNECTION_LIST.remove(sock)
continue

server_socket.close()

Now lets code the chat client that will connect to the above chat server. The client is based on the telnet program in python. It connects to a remote server, sends messages and receives messages.

Here is the python code that implements the above logic using select function

# telnet program example
import socket, select, string, sys

def prompt() :
sys.stdout.write('<You> ')
sys.stdout.flush()

#main function
if __name__ == "__main__":

if(len(sys.argv) < 3) :
print 'Usage : python telnet.py hostname port'
sys.exit()

host = sys.argv[1]
port = int(sys.argv[2])

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(2)

# connect to remote host
try :
s.connect((host, port))
except :
print 'Unable to connect'
sys.exit()

print 'Connected to remote host. Start sending messages'
prompt()

while 1:
socket_list = [sys.stdin, s]

# Get the list sockets which are readable
read_sockets, write_sockets, error_sockets = select.select(socket_list , [], [])

for sock in read_sockets:
#incoming message from remote server
if sock == s:
data = sock.recv(4096)
if not data :
print ' Disconnected from chat server'
sys.exit()
else :
#print data
sys.stdout.write(data)
prompt()

#user entered a message
else :
msg = sys.stdin.readline()
s.send(msg)
prompt()
  

Related Questions

Navigate

• Browse (All)
• Browse U
• Subjects

---

---

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.