Socket Programming: Client-Server Model

• Socket programming is connecting two nodes on a network for communication.
• One socket listens on a specific IP port, while the counterpart uses the port to establish a connection.
• The server uses a listener socket, with the client connecting to it.
• The "socket" module is required for socket programming.
• Use "import socket" to include the socket module.

Client-Server Model

• Networking applications typically designate one side as the client and the other as the server. this is called a client to server model.
• Sometimes they both act as a server, called a peer to peer model.
• Servers provide defined application services to clients.
• Servers can be iterative or concurrent.

Iterative Server

• An iterative server processes client requests in a loop:
• Wait for request.
• Process the request.
• Send a response.
• Return to the first step.
• Iterative servers has problems with slow processing, as no other clients can be serviced during step 2.

Concurrent Server

• A concurrent server processes requests as follows:
• Wait for a request.
• Start a new server to handle the request.
• Starting a new server may involve a new task/process depending on OS support.
• After completion, the new server terminates and return to the first step.
• The benefit of concurrent servers is that the server "spawns" other servers to handle client requests.
• Each client has its own server in effect.
• Assuming multiprogramming is working, multiple clients can be serviced simultaneously.
• Servers instead of clients are categorized because clients usually cannot distinguish between iterative and concurrent servers.
• TCP servers are typically concurrent, whereas UDP servers are iterative.
• There are exceptions to this.

TCP Client-Server

• Clients goes through socket, connect, write, read, close to send a server a connection request.
• Servers then bind, listen, and accept the connection, reading and writing the data down the line, and then closing the connection.

Socket Server Methods

• These methods are designed for server-side operations.
• s.bind(): associates an address to the socket including a tuple of hostname (IP address), and port number, formatted as a string, for listening to incoming requests.
• s.listen(): activates listening mode allowing the server to listen to incoming connections.
• s.accept(): passively allows a client connection, blocking until the connection is established, initiating a session with the client.
• c.close(): terminates the connection with the client.

Socket Client Methods

• Used on the client side.
• s.connect(): starts a TCP server connection.

Socket General Methods

• Core methods available in the socket module.
• s.send(): sends TCP messages.
• s.recv(): receives TCP messages.
• s.close(): closes the socket.
• s.sendto(): sends UDP messages.
• s.recvfrom(): receives UDP messages.

Python Socket Programming

• Python offers two levels of access to network programming:
• Low-Level Access: allows access to basic socket support allowing implementation of client and server functionality for both connection-oriented and connectionless protocols.
• High-Level Access: allows the implementation of protocols such as HTTP and FTP.

What are Sockets?

• Sockets form the endpoints of bidirectional communications.
• They facilitate communication within a process, between processes on one machine, or across different machines.
• Sockets utilize different protocols to determine connection type for port-to-port communication between clients and servers.
• Socket parameters include:
• Domain: protocol family for transport mechanisms like AF_INET, PF_INET, AF_UNIX.
• Type: communication type such as TCP or UDP.
• Protocol: protocol type within the domain and type, usually zero.
• Port: the server port used to communicate to a client.
• Hostname: identifies the network interface.

Syntax

• The basic socket creation syntax is: socket.socket(socket_family, socket_type, protocol=0).
• socket family is either AF_UNIX or AF_INET (IPv4).
• socket_type is either SOCK_STREAM (for TCP) or SOCK_DGRAM (for UDP).
• protocol is usually defaulted to zero.

Example Server Code

• To set up a server, the code commonly resembles:
• Start by importing the socket library.
• Next, create a socket object. For example: s = socket(AF_INET,SOCK_STREAM).
• Give it a port 40674.
• Bind the IP address and port number using s.bind((host, port)).
• Set up for listening with the expression s.listen(5).
• The arguments inside bind are in tuple format.
• Establish the connection with a client using c, addr = s.accept().
• Getting the connection from the client.
• Send a message back using c.send(b'Thank you for connecting').
• Close the connection using c.close().

Explanation of Server Code

• Code creates a socket object and reserves a host and port.
• The server is bound to a specific host and port.
• Passing an empty string means that the server listens to incoming connections from any interface.
• Passing 127.0.0.1 results in listening to calls within the local computer.
• Port number accept connections from clients in the range of 1024 to 65535.
• The server is set to listening mode with a backlog parameter.
• If a 6th socket wants to connect, it gets refused by the other clients.
• It then starts to accept all incoming connections.
• When a client connects, a new socket object (session) is returned.
• The listening socket is used to accept new connections.
• Close this connection after you close the socket.

Example Client Code

• A client has the following code:
• Import socket module.
• Create a socket object, for example, s = socket(AF_INET,SOCK_STREAM).
• Have a port to connect to.
• The next step is to connect to the server using s.connect((host, port)).
• Receive data from a host using print(s.recv(1024))
• The final step is to close the connection using s.close().

Explanation of Client Code

• Connect to the localhost on a port by which the server runs.
• Receive data from the server, and then close the connection when finished.