Name: Sai Sanjay Kamble

Roll no: 322070

PRN: 22220063
Div: B Batch: B3
Subject: Computer Network (CN)

Assignment no. 5

Aim: Socket Programming using TCP/IP.

Objective:
 To study socket creation.
 To study various socket functions like socket( ), bind( ),connect( ),listen(
),accept(
),read( ),write( ),close( ).

Theory:
Sockets in computer networks are used for allowing the transmission of
information between two processes of the same machines or different machines
in the network. The socket is the combination of IP address and software port
number used for communication between multiple processes. Socket helps to
recognize the address of the application to which data is to be sent using the IP
address and port number.
What is socket programming?
Socket programming is a way of connecting two nodes on a network to
communicate with each other. One socket(node) listens on a particular port at an
IP, while the other socket reaches out to the other to form a connection. The server
forms the listener socket while the client reaches out to the server.
State diagram for server and client model

Figure 1: State diagram for server and client model of

Socket
1. Socket creation:
int socket = socket(domain, type, protocol)
 sockfd: socket descriptor, an integer (like a file-handle)
 domain: integer, specifies communication domain. We use AF_ LOCAL
as defined in the POSIX standard for communication between processes
on the same host. For communicating between processes on different hosts
connected by IPV4, we use AF_INET and AF_I NET 6 for processes
connected by IPV6.
 type: communication type
SOCK_STREAM: TCP (reliable, connection oriented)
SOCK_DGRAM: UDP (unreliable, connectionless)
 protocol: Protocol value for Internet Protocol (IP), which is 0. This is the
same number which appears on protocol field in the IP header of a packet.
(man, protocols for more details)

2. Setsockopt:
 This helps in manipulating options for the socket referred by the file
descriptor sockfd. This is completely optional, but it helps in reuse of
address and port. Prevents error such as: “address already in use”.
 int setsockopt(int sockfd, int level, int optname, const void
*optval, socklen_t optlen);

3. Bind:
 int bind(int sockfd, const struct sockaddr *addr, socklen_t
addrlen);
After the creation of the socket, the bind function binds the socket to the
address and port number specified in addr (custom data structure). In
the example code, we bind the server to the localhost, hence we use
INADDR_ANY to specify the IP address.

4. Listen:
 int listen(int sockfd, int backlog);
It puts the server socket in a passive mode, where it waits for the client
to approach the server to make a connection. The backlog, defines the
maximum length to which the queue of pending connections for sockfd
may grow. If a connection request arrives when the queue is full, the
client may receive an error with an indication of ECONNREFUSED.

5. Accept:
 int new_socket= accept(int sockfd, struct sockaddr *addr,
socklen_t *addrlen);
 It extracts the first connection request on the queue of pending
connections for the listening socket, sockfd, creates a new connected
socket, and returns a new file descriptor referring to that socket. At this
point, the connection is established between client and server, and they
are ready to transfer data.
Stages for Client
 Socket connection: Exactly same as that of server’s socket creation
 Connect: The connect() system call connects the socket referred to by
the file descriptor sockfd to the address specified by addr. Server’s
address and port is specified in addr.
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
Socket Programming in TCP
TCP stands for Transmission Control Protocol. TCP is a reliable connection-
oriented protocol of the transport layer. TCP establishes the connection before
data transmission. Steps for TCP socket programming for establishing TCP
socket at the client-side:
 The first step is to create a socket and use the socket() function to create a
socket.
 Use the connect() function for connecting the socket to the server address.
 Transmit data between two communicating parties using read() and write()
functions.
 After data transmission completion close the connection using close()
function.

Following are steps to be followed for establishing a TCP socket on the

server-side:

 Use socket() for establishing a socket.

 Use the bind() function for binding the socket to an address.
 Then for listening client connections use listen() function.
 The accept() function is used for accepting the connection of the client.
  Transmit data with the help of the read() and write() function.

Figure 2: TCP Socket Connection

Socket Programming in UDP

UDP stands for User Datagram Protocol. UDP is a connection-less and unreliable protocol of
transport layer. UDP does not establish a connection between two communicating parties
before transmitting the data. Following are the steps given that is to be followed for
establishing UDP socket connection on the client-side
 Use socket() function for creating socket;
 recvfrom() and sendto() functions are used for transmitting data between two
communicating parties.
Steps to be followed for establishing UDP socket connection at the server-side.
 Create a socket using the socket() function.
 Use the bind() function for the binding socket to an address.
 Transmit data with the help of the recvfrom() function and sendto().
Below image to show UDP socket connection

Figure 3. Socket Programming in UDP

Socket Programming Interface Types

There are three types of socket programming interface
Stream sockets: Stream socket is the most common type of socket programming
interface. The communicating parties first establish a socket connection between
them, so that any data passed through the connection will arrive in the order in
which it was sent by the sender because of the connection-oriented service.
Datagram sockets: Provides connection-less services. No connection is
established before data transmission. Communicating party transmits the
datagrams as required or waits for the response. Data can be lost during the
transmission or may arrive out of order. Implementing a datagram provides more
flexibility in comparison to using stream sockets.
Raw sockets: This socket interface Bypasses the library’s built-in support for
standard protocols such as UDP (User Datagram Protocol) and TCP
(Transmission Control Protocol). Raw sockets are socket programming interfaces
which are used for custom low-level protocol development.
ALGORITHM:
1) Create socket
int sockfd = socket(domain, type, protocol)
2) Bind:
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
3) Listen:
int listen(int sockfd, int backlog);
4) Accept:
int new_socket= accept(int sockfd, struct sockaddr *addr, socklen_t
*addrlen);
5) Use read and write function
6) Close the socket

Code:
TCP_server.py
import socket

def server_program():
# get the hostname
host = socket.gethostname()
port = 5000 # initiate port no above 1024

server_socket = socket.socket() # get instance

# look closely. The bind() function takes tuple as argument
server_socket.bind((host, port)) # bind host address and port together

# configure how many client the server can listen simultaneously

server_socket.listen(2)
conn, address = server_socket.accept() # accept new connection
print("Connection from: " + str(address))
while True:
# receive data stream. it won't accept data packet greater than 1024 bytes
data = conn.recv(1024).decode()
if not data:
# if data is not received break
break
print("from connected user: " + str(data))
 data = input(' -> ')
conn.send(data.encode()) # send data to the client

conn.close() # close the connection

if __name__ == '__main__':
server_program()

TCP_client.py
import socket

def client_program():
host = socket.gethostname() # as both code is running on same pc
port = 5000 # socket server port number

client_socket = socket.socket() # instantiate

client_socket.connect((host, port)) # connect to the server

message = input(" -> ") # take input

while message.lower().strip() != 'bye':

client_socket.send(message.encode()) # send message
data = client_socket.recv(1024).decode() # receive response

print('Received from server: ' + data) # show in terminal

message = input(" -> ") # again take input

client_socket.close() # close the connection

if __name__ == '__main__':
client_program()
Output:
Server side:

Client side:

UDP_server.py
import socket

localIP = "127.0.0.1"
localPort = 20001
bufferSize = 1024

msgFromServer = "Hello UDP Client"

bytesToSend = str.encode(msgFromServer)

# Create a datagram socket

UDPServerSocket = socket.socket(family=socket.AF_INET,
type=socket.SOCK_DGRAM)

# Bind to address and ip

UDPServerSocket.bind((localIP, localPort))

print("UDP server up and listening")

# Listen for incoming datagrams

while (True):
bytesAddressPair = UDPServerSocket.recvfrom(bufferSize)
message = bytesAddressPair[0]
address = bytesAddressPair[1]
clientMsg = "Message from Client:{}".format(message)
clientIP = "Client IP Address:{}".format(address)

print(clientMsg)
print(clientIP)

# Sending a reply to client

UDPServerSocket.sendto(bytesToSend, address)

UDP_client.py
import socket

msgFromClient = "Hello UDP Server"

bytesToSend = str.encode(msgFromClient)
serverAddressPort = ("127.0.0.1", 20001)
bufferSize = 1024

# Create a UDP socket at client side

UDPClientSocket = socket.socket(family=socket.AF_INET,
type=socket.SOCK_DGRAM)

# Send to server using created UDP socket

UDPClientSocket.sendto(bytesToSend, serverAddressPort)

msgFromServer = UDPClientSocket.recvfrom(bufferSize)

msg = "Message from Server {}".format(msgFromServer[0])

print(msg)
Output:
Server side:

Client side: