Sriram Ramanujam on Linuxize

IPv4 vs IPv6

hello@linuxize.com (Linuxize) — Fri, 17 Sep 2021 10:36:37 +0100

In today’s technological era, we are witnessing a massive leap in the usage of the internet and networking devices. Every home has a laptop, smartphone, digital watch, IoT device, home automation component, and other devices that are connected to the home network or the Internet. Devices communicate with each other through various network protocols, with TCP and IP being the most frequently used protocols. Each device connected to the network must have an IP address that identifies the device on the network.

This article explains the Internet Protocol and how IPv6 differs from IPv4.

What is IP (Internet Protocol)?

Being humans, we identify and communicate with each other using our names. Likewise, in the computing world, devices use IP addresses to identify and interact with each other. A common language used by all computing devices to communicate with each other is known as a protocol. Akin to human languages, the protocol also has a set of rules that formats and processes the data.

The Internet Protocol (IP) is a set of rules that specifies addressing and routing the data between computers. It is mostly used with network transport protocols, such as TCP and UDP.

The Internet exists today because of this unique addressing pattern. The IANA manages the IP address ranges for networks/sites that connect to the Internet. However, if we run an isolated local network infrastructure, we can assign numbers according to our preference. Now, let’s get into the nitty-gritty of both architecture and its comparative analysis.

IPv4

The first major version of Internet Protocol (IP) is version 4 (IPv4). It uses a 32-bit network addressing schema that further splits into four 8-bit numbers known as octets. For instance, google.com has an IP address of 141.251.36.46. The format is known as dotted quad notation. These IP addresses can either be configured manually or automatically obtained through a DHCP server.

To check the live status of the remote device, we can do an ICMP probing to that IP using the ping command:

Terminal
ping -c 1 google.com

output

PING google.com (142.251.36.46) 56(84) bytes of data.
64 bytes from ams17s12-in-f14.1e100.net (142.251.36.46): icmp_seq=1 ttl=116 time=247 ms
...

IP addresses are broken into two parts, network, and host addresses for creating sub-networks. The subnet numbers help to decide the network and host parts of the IP. Also, the available IP space is divided into five different classes as tabulated below.

Address Class	IP Ranges	Subnet Mask	No of Networks	No of hosts per Network
Class A	1.0.0.0 to 126.0.0.0	255.0.0.0	126	16,777,214
Class B	128.0.0.0 to 191.255.0.0	255.255.0.0	16,282	65,534
Class C	192.0.0.0 to 223.255.255.0	255.255.255.0	2,097,150	254
Class D	224.0.0.0 to 239.255.255.255	Multicasting
Class E	240.0.0.0 to 255.255.255.255	Research/Reserved/Experimental

The calculation of subnet involves a few mathematical rubrics behind the screen. To ease our computation, we can use tools like ipcalc or subnetcalc for IPv4 subnetting. The below snippets shows how to use the tools:

Terminal
ipcalc 110.0.20.18/24

output

Address: 110.0.20.18 01101110.00000000.00010100. 00010010
Netmask: 255.255.255.0 = 24 11111111.11111111.11111111. 00000000
Wildcard: 0.0.0.255 00000000.00000000.00000000. 11111111
=>
Network: 110.0.20.0/24 01101110.00000000.00010100. 00000000
HostMin: 110.0.20.1 01101110.00000000.00010100. 00000001
HostMax: 110.0.20.254 01101110.00000000.00010100. 11111110
Broadcast: 110.0.20.255 01101110.00000000.00010100. 11111111
Hosts/Net: 254 Class A

Terminal
subnetcalc 192.168.10.15/24

output

Address = 192.168.10.15
11000000 . 10101000 . 00001010 . 00001111
Network = 192.168.10.0 / 24
Netmask = 255.255.255.0
Broadcast = 192.168.10.255
Wildcard Mask = 0.0.0.255
Hosts Bits = 8
Max. Hosts = 254 (2^8 - 2)
Host Range = { 192.168.10.1 - 192.168.10.254 }
Properties =
- 192.168.10.15 is a HOST address in 192.168.10.0/24
- Class C
- Private
GeoIP Country = Unknown (??)
DNS Hostname = (Name or service not known)

Usually, IP addresses are given to the end host machine and router gateway interface, as illustrated below.

Here, the traffic from Machine A (10.235.64.58) hits the router gateway interface (10.235.64.57) at the left side of the internet cloud. It reaches Google Server gateway through Internet routing and finally to the destination server.

To identify the network interface IP you can use commands such ifconfig , hostname or ip .

Terminal
ifconfig ens160

output

ens160: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
inet 10.235.64.58 netmask 255.255.255.252 broadcast 10.235.64.59
inet6 fe80::fc7f:d8da:a969:1c1d prefixlen 64 scopeid 0x20<link>
ether 00:0c:29:23:6f:30 txqueuelen 1000 (Ethernet)
RX packets 35607241 bytes 34540488400 (34.5 GB)
RX errors 0 dropped 12 overruns 0 frame 0
TX packets 24701952 bytes 15008379564 (15.0 GB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

Terminal
hostname -I

output

10.235.64.58

There are special purposes network IP addresses like 0.0.0.0 or 127.0.0.1. The former is the default route or quad-zero route, whilst the latter is called the loopback address.

In the below snippet, we will use netstat to see the Kernel IP routing table with the default route for that network. The flag ‘U’ represents that the network route is UP, whilst G signifies that the network route is the network gateway.

Terminal
netstat -rn | grep ens160

output

Kernel IP routing table
Destination Gateway Genmask Flags MSS Window irtt Iface
0.0.0.0 10.235.64.57 0.0.0.0 UG 0 0 0 ens160
10.235.64.56 0.0.0.0 255.255.255.252 U 0 0 0 ens160

Usually, the IPv4 datagram consists of a header field with 20 bytes, options field, and data fields with a variable length. The sample packet format is shown below.

Below, Wireshark capture helps to decipher the packet header information from the live traffic.

IPv6

Internet Protocol version 6 is the updated version of Internet Protocol (IP). Version 6 of the Internet Protocol is intended to replace the older version (IPv4), which carries 75% of total internet traffic as of 2018 (Source: Google IPv6 Stats).

The IPv6 address is 128 bits (16 bytes) using 32 hexadecimal digits, whilst these digits are further divided into eight groups of four digits each for ease of management. A brief illustration is shown below.

There are few basic steps involved in the IPv6 naming convention.

Rule 1: All letters are case insensitive. For example, ‘ab41’ equals ‘AB41’ Rule 2: Successive fields with ‘0’ can be visualized as “::”, but only once in an addressing Rule 3: Representing leading zeros in a field are optional. For instance, ‘001a’ equals ‘1a’

For Instance, let’s take the IPv6 address, 45ab:0000:a179:0000:0000:c1c0:abcd:0876

Apply Rule 1 => 45ab:0000:a179:0000:0000:c1c0:abcd:0876 Apply Rule 2 => 45ab:0:a179:0:0:c1c0:abcd:876 Apply Rule 3 => 45ab:0:a179::c1c0:abcd:876

There are three types of IPv6 addresses: Unicast, Multicast, and Anycast. The unicast address is the single network interface and packets delivered to that specific interface. Additionally, unicast addresses have local(link-local) and global scope levels. Multicast address is the group interfaces to which the packets get delivered. Anycast address is the group interface and packet delivered to the nearest interface.

Few well-known addresses are tabulated below.

]::1/128	Loopback address
ff00::/8	Multicast addresses
fe80::/10	Link-local addresses
2001::/16	Regular IPv6 unicast addresses
2002::/16	6to4 Unicast addresses

Terminal
subnetcalc 2001:4860:4860::8888/64

output

Address = 2001:4860:4860::8888
2001 = 00100000 00000001
4860 = 01001000 01100000
4860 = 01001000 01100000
0000 = 00000000 00000000
0000 = 00000000 00000000
0000 = 00000000 00000000
0000 = 00000000 00000000
8888 = 10001000 10001000
Network = 2001:4860:4860:: / 64
Netmask = ffff:ffff:ffff:ffff::
Wildcard Mask = ::ffff:ffff:ffff:ffff
Hosts Bits = 64
Max. Hosts = 18446744073709551616 (2^64 - 1)
Host Range = { 2001:4860:4860::1 - 2001:4860:4860:0:ffff:ffff:ffff:ffff }
Properties =
- 2001:4860:4860::8888 is a HOST address in 2001:4860:4860::/64
- Global Unicast Properties:
+ Interface ID = 0000:0000:0000:8888
+ Sol. Node MC = ff02::1:ff00:8888
GeoIP Country = United States (US)
DNS Hostname = dns.google

Again, the IPv6 packet has both header and payload. The header size is fixed to 40bytes, with source and destination address taking 32bytes. The sample packet format is shown below.

Though IPv6 has umpteen advantages, it cannot supplant IPv4. Both protocol versions have to co-exist for some time for seamless migration. Hence, the service providers are offering a dual-stack support system that possesses a network interface that can understand both IPv4 and IPv6 packets.

There are few smart transition mechanisms, namely IPv6 Tunneling, IPv4 mapped IPv6 addresses, etc. The former encapsulates the IPv6 packet in IPv4, whilst the latter maps the IPv6 to IPv4 addresses in the dual-stack implementations.

IPv4 vs IPv6 - Quick Comparative Analysis

Features	Internet Protocol - Version 4 [IPv4]	Internet Protocol - Version 6 [IPv6]
Deployment & allocation	1981	1999
Length	32-bit	128-bit
Address Space	4.29 x 10^9	3.4 x 10^38
Format	Dotted Decimal / [10.235.64.56]	Hexadecimal / [2400::4]
Number of Octets	4	16
Header Size	Varies from 20 - 60 bytes	40 bytes
Classes	Five classes: Class A, Class B, Class C, Class D, Class E	None
Security Features / Authentication and encryption	Not available	Available
Check sum	Available	Not available
IPSec	External and optional	Inbuilt feature
Hop Count	Indicated by TTL field	Indicated by Hoplimit field
Fragmentation	Performed by sender and forwarding routers	Done by sender only
Option Fields	Provided in the IPv4 header	There are no optional fields, but IPv6 Extension headers are available
Multicast	IGMP manages the multicast group membership	MLD replaces the IGMP
Broadcast message	Available	Not available. Multicast is used
IP to MAC Mapping	Address Resolution Protocol	Neighbour Discovery Protocol

Conclusion

We explored the basics of Internet Protocol and its versions. Along the way, the article elucidates the addressing schema, packet format, functioning of the IPv4 and IPv6 with comparative analysis. Though IPv4 is carrying the majority of Internet traffic today, IPv6 is the future of the networking world.

How to Reverse a String in Python

hello@linuxize.com (Linuxize) — Sun, 01 Aug 2021 12:31:00 +0100

In Python, a string is a sequence of Unicode characters. Though Python supports numerous functions for string manipulation, it doesn’t have an inbuilt function or method explicitly designed to reverse the string.

sh
>>> 'Linuxize'.reverse()

output

Traceback (most recent call last):
File "<input>", line 1, in <module>
AttributeError: 'str' object has no attribute 'reverse'

String reversal is not a common operation in programming and is generally used is in coding interviews.

This article goes through several different ways to reverse a string in Python.

Using Slicing

Understanding how indexing works in Python is crucial for performing the String Slice operation. Generally, Index numbers are used to access specific characters within a string.

There are two types of indexing; positive and negative indexing.

You can access the character n, either through a positive index number of 2 or through a negative index number of -6:

sh
>>> print('Linuxize'[2])

output

sh
>>> print('Linuxize'[-6])

output

We can call out a range of characters from a string through a slicing technique. Slicing is the operation that extracts the sequence of a substring from the given string.

Slice Syntax:

py
string[start:stop:step]

The first argument specifies the index at which the extraction begins. When a negative index is used, it indicates an offset from the end of the string. If this argument is omitted, slicing starts from index 0.
The second argument specifies the index before which to end extraction; the result doesn’t include the stop element. When a negative index is used, it indicates an offset from the end of the string. If this argument is omitted or greater than the length of the string, slicing goes to the end of the string.
The third argument is optional and specifies the step of the slicing. When the step argument is not used, it defaults to 1. When a negative value is used, the slice takes elements in reverse order.

The result of slicing a string is a new string containing the extracted elements, and the original string is not modified.

To reverse a string using slicing, omit the start and stop arguments and use a negative step increment of -1.

The negative step increment of -1 means that the slicing starts at the last element and ends at the first element, resulting in a reversed string.

sh
>>> print('Linuxize'[::-1])

output

ezixuniL

You can also define a custom function and use it to reverse strings:

py
def rev_str_thru_slicing(str_):
 return str_[::-1]

INPUT_STRING = "Linuxize"

if __name__ == '__main__':
 print("INPUT STRING -", INPUT_STRING)
 print("REVERSED STRING -", rev_str_thru_slicing(INPUT_STRING))

output

Input String - Linuxize
Reversed String using Slicing - ezixuniL

Using `reversed()` Function

The built-in reserved() function process the string items in reverse order and returns a reversed iterator.

In the example below, the reversed iterator’s elements are added to an empty string using the join() operator:

py
def rev_str_thru_join_revd(STR):
 return "".join(reversed(STR))

INPUT_STRING = "Linuxize"

if __name__ == '__main__':

 print("INPUT STRING -", INPUT_STRING)
 print("RESERVED STRING THROUGH JOIN & REVERSED", rev_str_thru_join_revd(INPUT_STRING))

output

Input String - Linuxize
Reserved String Through Join & Reserved Methods - ezixuniL

Using List `reverse()`

To reverse a string with the list reverse() method, first, the string needs to be converted to a list using the list constructor. Then the list items are reversed in place with the reverse() method, and finally, the list items are joined into a string using the join() method.

Here is an example:

py
def rev_str_thru_list_reverse(STR):
 lst = list(STR)
 lst.reverse()
 return(''.join(lst))

INPUT_STRING = "Linuxize"

if __name__ == '__main__':
 print("Input String -", INPUT_STRING)

print("Reserved String Through List", rev_str_thru_list_reverse(INPUT_STRING))

output

Input String - Linuxize
Reserved String Through List Reverse Method - ezixuniL

Using Recursive Function

In Python, a recursive function is a function that calls itself until some condition is met.

In the code snippet below, the rev_str_thru_recursion function calls itself until the string length is greater than zero. On each call, the string is sliced, leaving only the first character. Later on, it is concatenated with the sliced characters.

py
def rev_str_thru_recursion(STR):
 if len(STR) == 0:
 return STR
 else:
 return rev_str_thru_recursion(STR[1:]) + STR[0]

INPUT_STRING = "Linuxize"

if __name__ == '__main__':
 print("INPUT STRING -", INPUT_STRING)

print("RESERVED STRING THROUGH RECURSION", rev_str_thru_recursion(INPUT_STRING))

Comparative Analysis

In this section, we’ll perform a simple comparison between these four defined methods to identify their efficiency. We’ll analyze the performance using a Python module called “timeit”. It provides the time taken for the execution of the code snippets. “repeat” option of the “timeit” module helps to repeat the code execution one million times. We can comprehend the output as an average time taken by executing the code snippet one million times.

Methods	Execution Time	Comparison Ratio Calc.
Slicing	0.23	1x
List Reverse	1.63	7x
Join & Reserved	1.73	7.5x
Recursion	19.19	83x

The table above shows that the Slicing method is seven times faster than the List Reverse approach, 7.5 times faster than the Join & Reserved approach, and 83 times faster than the recursion approach. So Slicing is the quickest and best way to reverse the string.

Info

The above results are the comparative analysis of discussed methods to reverse the string in the same environment. Numbers might vary in different computing environments, but the ratio will probably remain the same.

py
if __name__ == "__main__":

 ## Performance Calculation

 import timeit
 from statistics import mean

 s = INPUT_STRING * 10
 repeatCount = 100

 SLICING_PERF = timeit.repeat(lambda: rev_str_thru_slicing(s), repeat=repeatCount)
 print(min(SLICING_PERF), mean(SLICING_PERF), max(SLICING_PERF), SLICING_PERF)

 J_R_PERF = timeit.repeat(lambda: rev_str_thru_join_revd(s), repeat=repeatCount)
 print(min(J_R_PERF), mean(J_R_PERF), max(J_R_PERF), J_R_PERF)

 LIST_PERF = timeit.repeat(lambda: rev_str_thru_list_reverse(s), repeat=repeatCount)
 print(min(LIST_PERF), mean(LIST_PERF), max(LIST_PERF), LIST_PERF)

 RECUR_PERF = timeit.repeat(lambda: rev_str_thru_recursion(s), repeat=repeatCount)
 print(min(RECUR_PERF), mean(RECUR_PERF), max(RECUR_PERF), RECUR_PERF)

Conclusion

Python doesn’t have any built-in functions to reverse the string, but we can use other methodsto reverse the string. The regression test analysis showed that the slicing method is the fastest way to reverse a string.

Sriram Ramanujam on Linuxize

IPv4 vs IPv6

What is IP (Internet Protocol)? #

IPv4 #

IPv6 #

IPv4 vs IPv6 - Quick Comparative Analysis #

Conclusion #

How to Reverse a String in Python

Using Slicing #

Using reversed() Function #

Using List reverse() #

Using Recursive Function #

Comparative Analysis #

Conclusion #

What is IP (Internet Protocol)?

IPv4

IPv6

IPv4 vs IPv6 - Quick Comparative Analysis

Conclusion

Using Slicing

Using `reversed()` Function

Using List `reverse()`

Using Recursive Function

Comparative Analysis

Conclusion