Socket Programming

Using Python

About Sockets

Sockets, according to Wikipedia, are internal endpoints for sending or receiving data with a node on a computer network. I'd describe them as channels for sending and receiving data over a networking protocol.

Sockets in Python

You can find the official documentation here. This page will however suffice in getting you started with socket programming and fundamentals.

Installation

Using pip

The command you can run is

pip install sockets

This will install the sockets library in the currently sourced Python interpreter.

Basics

There is a basic diagram that you should remember. It covers about 50% of sockets and is very helpful in understanding the flow. The figure is on the right. So essentially here's the theory you need to understand:

Every connection in sockets has a client and a server. A server is the first thing that must be running first to accept a connection. So a server starts and goes into listening mode. A client is then supposed to connect to the server and then a connection is established.
After a connection is established, a client and server can communicate by sending and receiving messages with each other.

A few extra things that are good to know:

In order to connect, the client and server both acknowledge their unique addresses on a network. On the internet, routing tables and DNS (Domain Name Servers) do the job of routing and getting addresses.
An IP address is to a device. All data is routed to the device through a port. A port is unique and used for a particular purpose.
Every application exchanging data through a port is a node on the network. Even the server being hosted at a particular port is a node on the network.

Courtesy: https://www.techbeamers.com/python-tutorial-essentials-of-python-socket-programming/

Figure 1: Basic workflow of a Python Socket

Creating a socket server

Listener

This will create a server node that after getting initialized will connect to a client node, print whatever is sent, exit when connection is broken and no more data is received. Let me show you the code first, I'll then follow up with an explanation for the code.

Code 1: A server socket that receives data from a client socket

Here's what I've done step by step. Keep Figure 1 in mind and read through:

Import the socket library
Allocate variables for IP address and port number
- 127.0.0.1 is the internal loop back address for many systems. It's basically for communications done within the system. You can use any IP address of a system connected to the network.
- The IP address is for the system, the application must choose a port on the system to exchange data. A port is to route data appropriately, because at the same time there might be several applications using the network, so each has a designated port in the network. I've used port number 50001. You may use any free port.
Initialize the socket variable using the socket() constructor.
- To the constructor which will return the socket object, you have to pass two things:
  - family of the socket: This is the way addressing is done. We've chosen AF_INET (default) which uses addressing as a tuple (ip_address, port_number) for addressing.
  - type of data exchange: This is to specify how you'll be exchanging data over the socket. By default SOCK_STREAM is used (for TCP communication).
  - You can read more about socket() here.
Bind the socket using the bind() function. We pass it the full address (tuple as specified in family during initialization) on which the socket is to be hosted.
- You can read more about bind() here.
Set the socket into listening mode using listen() function. The argument specifies backlog. Basically, how many connections can be handled in a queue before the socket refuses new connections.
- You can read more about listen() here.
Accept an incoming connection using the accept() function. This will wait till a new connection is received and will return a tuple containing a new socket for the connection and the client's address (full address as specified in family during initialization).
- You can read more about accept() here.
Wait for data and get the data received using the recv() function. The argument provided is the buffer size (1024 bytes in this case).
- Then we simply check if any data was received (if the connection has timed out or disconnected, then nothing is received)
- If anything is received, then we print it out
- You can read more about recv() here.

This is pretty much how you create a server that listens to a client.

Creating a socket client

Speaker

Here we'll create a node that will connect to a server, send "Hello World" to the server and then exit (break connection). I'll show you the code first, then follow up with the explanation

Code 2: A client socket that sends data to a server socket

Here's what I've done, step by step:

Just like before, we import and assign variables for addressing.
We create a socket just as we did before
We connect to a server using the connect() function. In the arguments, we provide the full address of the server node.
- You can read more about connect() here.
We then send data through the socket using the sendall() function. The data has to be in the form of bytes, so we parse a string using the utf-8 encoding standard.
- You can read more about sendall() here.
- We can also use a function called send(). But the problem with that function is that we have to manually check the delivery status all the time and handle what happens if delivery is not successful.
  - You can read more about send() here.

This is pretty much how you create a client that sends a message to the server.

Sending and receiving data through a single socket

I'll this time show you the code for both and then follow up with explanation. You're encouraged to understand what's happening first, before reading the explanation

Server

Code 3: A dummy server that sends and receives data

Client

Code 4: A dummy client that sends and receives data

Site under development

Please be patient and wait for more content to be uploaded

Page updated

Google Sites

Report abuse