Tag Archives: linux

Chakra Linux: Its Own Beast, Its Own Beauty | Linux.com


There are so many Linux distributions available—so many, in fact, that it can become a bit of a challenge to find the one right for you. After you’ve looked at them enough, it seems the variations tend to blur together, such that one flavor of Linux is only a slight shift away from another.

Perhaps your distribution of choice may have a sweet-looking desktop, but it might be the standard Ubuntu underneath. Or, maybe you’ve found that a distro is using the same GNOME as everyone else, with the slightest variation under the hood. That’s how it goes in the selection of Linux. The good news is that, even with that familiarity, there are some truly brilliant distributions available. Some of them advance the desktop interface well beyond the standard, while others go out of their way to be familiar.

Chakra Linux is a combination of the above descriptions. What initially started out as a variation on Arch Linux, with the name KDEmod, the distribution used a “lightified and modular” version of the KDE desktop, built exclusively for Arch Linux. This take on KDE offered a significant performance increase and improved customizations over the standard KDE installation, and it quickly gained a following.

After a while, however, it was determined that the LiveCD Project would be a much better fit and Chakra was born. Since then, the environment has slowly morphed into its own beast, a unique merging of ideologies and designs that deliver a solid and beautiful experience.

Chakra’s main vision is to provide a pure KDE/Qt desktop, with a nod to simplicity and transparency. Of course, simplicity is in the eye of the beholder. Even though KDE makes for an incredibly user-friendly environment, a new-to-Linux user will find themselves a bit confused when it comes to certain tasks. Let’s dive in and see what Chakra’s all about.

At first blush

Chakra is a beautiful desktop—if you’re okay with flat themes (Figure 1).

Check out the Chakra menu, and you’ll find just about every piece of software you need. The one caveat to this is the choice of office suit. Instead of the more popular LibreOffice, Chakra installs the KDE-specific Calligra. As long as you don’t need to interact with MS Office, that’s not completely a bad thing. If, however, you have to open any MS Office document (later than Office 2007), you’re out of luck. As much as I respect what Calligra is doing, without the ability to interact with the likes of .docx, it simply will not do (especially in a business environment).

Of course, that’s not really too much of an issue, as you can open up the Octopi software installer and install LibreOffice. Unfortunately, the version available is a bit out of date. Currently, the latest release of LibreOffice is 5.4.0.3 and the version available to Chakra (after an initial update) is 5.3.5-1. Unfortunately, there is no latest version of the office suite to be downloaded for the platform, so users would have to wait until the developers make it available for update.

Speaking of which…

Another issue new users will find with Chakra is the update process. With most Linux distributions, you can head to the desktop menu and find an entry for updating software. Not so with Chakra. Any updating to be done, must be handled through the command line. So to upgrade your system, you must open up the terminal window and issue the command:

sudo pacman -Syu

After running the command, you must okay every single one of the updates, before the process will continue (do note, the first run will take considerable time).

Speaking of which…

A unique aspect of Chakra is that it is a half-rolling release distribution. This means that Chakra works with a stable core and rolling applications on top. With this idea, you will always have the latest desktop software, running on top of a not-so-latest release of the core. This forms a solid foundation for which to run software. For instance, after an initial update, Chakra was using KDE 5.10.4-1 (the latest release) and kernel is 4.8.6-1. The mainline kernel is currently at 4.13-rc4, so this is certainly a stable kernel.

Fortunately, you do not have to install applications from the command line (you certainly can, if you choose). If you prefer a GUI for installing software, Chakra includes the Octopi front end for that particular task (Figure 2).

It is very important that you run the sudo pacman -Syu command before first using Octopi—otherwise, you’ll have out of date packages available for installation.

Some nice choices

Looking beyond the Calligra over LibreOffice issue, some nice choices have been made for default software. Take, for instance, the selection of Clementine as the default music player. This happens to be my favorite of all the available players on the market. It offers an amazing array of features, with a great user interface. Good choice. Another solid choice is Qupzilla, a lightweight web browser that uses the Qt webengine. This browser is faster to open that Firefox, offers more features than Midori, and renders as well as Chrome.

Another nice touch is the addition of the Yakuake drop-down terminal. I like a good terminal that is quick to open and quick to get out of the way; Yakuake does this with ease.

Who should be using Chakra

Chakra is a unique distribution that offers an interface and stability that begs for new users to come play, but with just enough added complexity that might challenge them to learn a bit more (or make them slightly hesitant). On the other hand, Chakra does deliver serious performance and plenty of tools (such as Package Changelogs, Chakra Bug Tracking System, Qt Designer, Vim text editor, and more) that will make more hard-core users quite happy.

If you’re a new user, who doesn’t mind working at the command line now and then, Chakra will serve you well. If you’re already well versed in Linux, Chakra will give you just enough to keep you curious and happy, while remaining stable underneath.

Manipulate IPv6 Addresses with ipv6calc | Linux.com


Last week, you may recall, we looked at calculating network addresses with ipcalc. Now, dear friends, it is my pleasure to introduce you to ipv6calc, the excellent IPv6 address manipulator and query tool by Dr. Peter Bieringer. ipv6calc is a little thing; on Ubuntu /usr/bin/ipv6calc is about 2MB, yet it packs in a ton of functionality. 

Here are some of ipv6calc’s features:

  • IPv4 assignment databases (ARIN, IANA, APNIC, etc.)
  • IPv6 assignment databases
  • Address and logfile anonymization
  • Compression and expansion of addresses
  • Query addresses for geolocation, registrar, address type
  • Multiple input and output formats

It includes multiple commands. We’re looking at the ipv6calc command in this article. It also includes ipv6calcweb and mod_ipv6calc for websites, ipv6logconv log converter, and ipv6logstats log statistics generator.

If your Linux distribution doesn’t compile all options, it’s easy to build it yourself by following instructions on The ipv6calc Homepage.

One useful feature it does not include is a subnet calculator. We’ll cover this in a future article.

Run ipv6calc -vv to see a complete features listing. Refer to man ipv6calc and The ipv6calc Homepage to learn all the command options.

Compression and Decompression

Remember how we can compress those long IPv6 addresses by condensing the zeroes? ipv6calc does this for you:

$ ipv6calc --addr2compaddr 2001:0db8:0000:0000:0000:0000:0000:0001
2001:db8::1

You might recall from Practical Networking for Linux Admins: Real IPv6 that the 2001:0DB8::/32 block is reserved for documentation and testing. You can uncompress IPv6 addresses:

$ ipv6calc --addr2uncompaddr 2001:db8::1
2001:db8:0:0:0:0:0:1

Uncompress it completely with the --addr2fulluncompaddr option:

$ ipv6calc --addr2fulluncompaddr 2001:db8::1
2001:0db8:0000:0000:0000:0000:0000:0001

Anonymizing Addresses

Anonymize any address this way:

$ ipv6calc --action anonymize 2001:db8::1
No input type specified, try autodetection...found type: ipv6addr
No output type specified, try autodetection...found type: ipv6addr
2001:db8::9:a929:4291:c02d:5d15

If you get tired of “no input type” messages, you can specify the input and output types:

$ ipv6calc --in ipv6addr --out ipv6addr  --action anonymize 2001:db8::1
2001:db8::9:a929:4291:c02d:5d15

Or use the “quiet” option to suppress the messages:

$ ipv6calc -q --action anonymize 2001:db8::1
2001:db8::9:a929:4291:c02d:5d15

Getting Information

What with all the different address classes and sheer size of IPv6 addresses, it’s nice to have ipv6calc tell you all about a particular address:

$ ipv6calc -qi 2001:db8::1
Address type: unicast, global-unicast, productive, iid, iid-local
Registry for address: reserved(RFC3849#4)
Address type has SLA: 0000
Interface identifier: 0000:0000:0000:0001
Interface identifier is probably manual set

$ ipv6calc -qi fe80::b07:5c7e:2e69:9d41
Address type: unicast, link-local, iid, iid-global, iid-eui64
Registry for address: reserved(RFC4291#2.5.6)
Interface identifier: 0b07:5c7e:2e69:9d41
EUI-64 identifier: 09:07:5c:7e:2e:69:9d:41
EUI-64 identifier is a global unique one

One of these days, I must write up a glossary of all of these crazy terms, like EUI-64 identifier. This means Extended Unique Identifier (EUI), defined in RFC 2373. This still doesn’t tell us much, does it? EUI-64 addresses are the link local IPv6 addresses, for stateless auto-configuration. Note how ipv6calc helpfully provides the relevant RFCs.

This example queries Google’s public DNS IPv6 address, showing information from the ARIN registry:

$ ipv6calc -qi 2001:4860:4860::8844
Address type: unicast, global-unicast, productive, iid, iid-local
Country Code: US
Registry for address: ARIN
Address type has SLA: 0000
Interface identifier: 0000:0000:0000:8844
Interface identifier is probably manual set
GeoIP country name and code: United States (US)
GeoIP database: GEO-106FREE 20160408 Bu
Built-In database: IPv6-REG:AFRINIC/20150904 APNIC/20150904 ARIN/20150904 
IANA/20150810 LACNIC/20150904 RIPENCC/20150904

You can filter these queries in various ways:

$ ipv6calc -qi --mrmt GEOIP 2001:4860:4860::8844
GEOIP_COUNTRY_SHORT=US
GEOIP_COUNTRY_LONG=United States
GEOIP_DATABASE_INFO=GEO-106FREE 20160408 Bu

$ ipv6calc -qi --mrmt  IPV6_COUNTRYCODE 2001:4860:4860::8844
IPV6_COUNTRYCODE=US

Run ipv6calc -vh to see a list of feature tokens and which ones are installed.

DNS PTR Records

Now we’ll use Red Hat in our examples. To find the IPv6 address of a site, you can use good old dig to query the AAAA records:

$ dig AAAA www.redhat.com
[...]
;; ANSWER SECTION:

e3396.dscx.akamaiedge.net. 20   IN      AAAA    2600:1409:a:3a2::d44
e3396.dscx.akamaiedge.net. 20   IN      AAAA    2600:1409:a:397::d44

And now you can run a reverse lookup:

$ dig -x 2600:1409:a:3a2::d44 +short
g2600-1409-r-4.4.d.0.0.0.0.0.0.0.0.0.0.0.0.0.2.a.3.0.a.
 0.0.0.deploy.static.akamaitechnologies.com.
g2600-1409-000a-r-4.4.d.0.0.0.0.0.0.0.0.0.0.0.0.0.2.a. 
 3.0.deploy.static.akamaitechnologies.com.

As you can see, DNS is quite complex these days thanks to cloud technologies, load balancing, and all those newfangled tools that datacenters use.

There are many ways to create those crazy long PTR strings for your own DNS records. ipv6calc will do it for you:

$ ipv6calc -q --out revnibbles.arpa 2600:1409:a:3a2::d44
4.4.d.0.0.0.0.0.0.0.0.0.0.0.0.0.2.a.3.0.a.0.0.0.9.0.4.1.0.0.6.2.ip6.arpa.

If you want to dig deeper into IPv6, try reading the RFCs. Yes, they can be dry, but they are authoritative. I recommend starting with RFC 8200, Internet Protocol, Version 6 (IPv6) Specification.

Learn more about Linux through the free “Introduction to Linux” course from The Linux Foundation and edX.

Linux cksum Command Explained for Beginners (with Examples) | Linux.com


There are times when we download a file (say an ISO image) hosted somewhere on the Internet only to find that it’s not working as expected (or, at all). There could be multiple reasons behind this, with one among them being file corruption (the file got corrupted during the download process, or the original, hosted file itself was corrupt). But how to confirm that such a corruption has occurred?

In Linux, there’s a command line tool that you can use to create/verify checksum. It’s dubbed cksum. Most vendors offer a checksum (or a checksum-like code) corresponding to the file(s) being downloaded. If the file doesn’t behave in an expected way, user’s can recompute the file’s checksum and compare it with the original checksum provided by the vendor to see if the file is intact or got corrupted.

Well, there does exist a solution to this problem. In most cases, what’s done is, when the file is originally created, a checksum is computed which is unique to that file. Even if there’s a slight change in the file, the checksum – when computed again – changes.

So most vendors offer a checksum (or a checksum-like code) corresponding to the file(s) being downloaded. If the file doesn’t behave in expected way, user’s can recompute the file’s checksum and compare it with the original checksum provided by the vendor to see if the file is intact or got corrupted.

Read more at HowtoForge

How to Integrate Git into Your Linux Desktop | Linux.com


Ask a developer to name their most important tools and very often the reply will include Git. There’s a good reason for that: Git is one of the most widely used distributed version control systems. Git can be set up as a local repository, used on a LAN, or used via the official, global service. With Git you can do things like add access control to your code, display the contents of a Git repository (via the web), and manage multiple repositories.

Most users (especially of the Linux variety) work with Git through the command line—with good reason. The Git command-line tools are second nature to Linux users; and considering that most developers working on the Linux platform are already acclimated to the command line, it’s efficient. However, not every user wants to spend all of their Git time working within the terminal. Fortunately, for those users, there are plenty of various GUI tools that can help you get your Git on. Not all of these tools are created equal, so what you use will depend upon your needs.

I want to highlight three such tools—centered on file manager/desktop integration. How you use Git (and how you need it integrated into your desktop) will determine what tool is best for you.

First, we’ll talk about tools that integrate into your file manager. For this, I’m going to focus on the GNOME and KDE desktops (as these two offer the best integration environments). Next, we’ll discuss a very powerful tool that does a great job of integrating into the Linux desktop and connecting with your remote Git account.

With that said, let’s take a look at two very handy tools that integrate into file managers.

RabbitVCS-git

If you use GNOME, chances are you use Nautilus. If you use Nautilus and work with Git, you’re going to want to install one of the best Linux desktop integration tools for Git—RabbitVCS-git. RabbitVCS-git is an SCM client that integrates itself with the Nautilus file manager to manage local Git or SVN repositories.

To install RabbitVCS-git on Ubuntu (or a Ubuntu derivative), issue the following commands from the terminal window:

sudo add-apt-repository ppa:rabbitvcs/ppa
sudo apt-get update
sudo apt-get install rabbitvcs-nautilus 

Once installed, logout of GNOME and log back in. Open up Nautilus and navigate to any project folder, and right-click a blank spot to reveal the RabbitVCS-git contextual menu (Figure 1).

At this point, you can begin to work with a very well done bit of Git integration with Nautilus.

Git in KDE

The KDE file manager, Dolphin, offers Git integration by way of a plugin. Before you attempt to use the plugin, you might have to install it. Open up a terminal window and issue the command:

sudo apt-get install dolphin-plugins

Once that command completes, open up Dolphin and then click the Control button > Configure Dolphin. Click on the Services tab, scroll down until you find Git, and click to enable (Figure 2).

With Git checked, click OK and then, when prompted, click to restart Dolphin. There is one thing to note: Installing the Dolphin plugins package does not install git. If you haven’t installed the git package (which I assume you already have), you’ll need to do so before Dolphin can actually work with Git. You will also have had to create a new repository from the command line and do a first commit. Once you’ve taken care of that, you will see the Git-related right-click context menu entries in Dolphin (Figure 3).

From that context menu, you can checkout, show local changes, commit, create tags, push, and pull.

SparkleShare

Now we’re going to venture into the realm of something a bit more powerful than simple file manager integration. The tool I want to demonstrate is SparkleShare, a unique self-hosted service that allows you to do file syncing/sharing, as well as version control, client-side encryption, and (to the point) connect and sync with your GitHub account.

SparkleShare is available from within the standard repositories, so to install (I’ll be demonstrating this on Linux Mint, using the Cinnamon desktop), the following steps will do the trick:

  1. Open a terminal window.

  2. Update apt with the command sudo apt-get update.

  3. Type your sudo password and hit Enter.

  4. Once the update completes, issue the command sudo apt-get install -y sparkleshare.

  5. Allow the installation to finish.

Once the installation is done, go to your desktop menu and search for the SparkleShare entry. Upon first run, you will be prompted for a name and email address (Figure 4).

Click Continue and then either view the tutorial or click to skip. You will be given a unique Client ID (an ssh-rsa key). Copy and save that key. Click the Finish button. Before you continue on with the SparkleShare GUI setup tool, you need to configure your GitHub account with your SparkleShare ssh-rsa pub key. To do this, follow these steps:

  1. Open a terminal window.

  2. Issue the command cd ~/.config/sparkleshare.

  3. Find the name of your .pub key with the command ls (it will end in .pub).

  4. Open the pub key with a text editor and copy the contents.

  5. Open your GitHub account in your desktop browser.

  6. Go to Settings | SSH and GPG keys.

  7. Click New SSH Key.

  8. Title the key SparkleShare.

  9. Copy the contents of your SparkleShare pub key into the Key text area (Figure C).

  10. Click Add SSH Key.

With the key in place, you can finish up the SparkleShare GitHub connection. You will see a new icon in your system tray; click that icon and then select SparkleShare > Add Hosted Project. Select GitHub from the list and then fill out the Remote Path section in the form /gitusername/repository (Figure 5).

SparkleShare will automatically sync the repository to your desktop, where you can start to work locally on your project, knowing the files will seamlessly sync back to your GitHub account.

Git integration made easy

And there you have it, Git integration into your Linux desktop made easy. If you’re a developer who works on the Linux desktop, and you use Git, you’ll want to try one of these three tools. Yes, there are full-blown Git GUIs for Linux (such as Giggle, Git GUI, Git-Cola, Smart Git, and many more), but if you’re looking for easy file manager or desktop integration, look no further than these options.

Learn more about Linux through the free “Introduction to Linux” course from The Linux Foundation and edX.

How to Calculate Network Addresses with ipcalc | Linux.com


The math behind IP addresses is convoluted. Our nice IPv4 addresses start out as 32-bit binary numbers, which are then converted to base 10 numbers in four 8-bit fields. Decimal numbers are easier to manage than long binary strings; still, calculating address ranges, netmasks, and subnets is a bit difficult and error-prone, except for the brainiacs who can do binary conversions in their heads. For the rest of us, meet ipcalc and ipv6calc.

ipcalc is for IPv4 networks, and ipv6calc is for IPv6 networks. Today, we’ll play with IPv4, and next week IPv6.

You must understand Classless Inter-Domain Routing (CIDR) as this is fundamental to IP addressing; if you don’t, please look it up. (See Practical Networking for Linux Admins: Real IPv6 for a concise description.)

ipcalc

Run ipcalc with your IP address to see everything you need to know:

$ ipcalc 192.168.0.135
Address:   192.168.0.135        11000000.10101000.00000000. 10000111
Netmask:   255.255.255.0 = 24   11111111.11111111.11111111. 00000000
Wildcard:  0.0.0.255            00000000.00000000.00000000. 11111111
=>
Network:   192.168.0.0/24       11000000.10101000.00000000. 00000000
HostMin:   192.168.0.1          11000000.10101000.00000000. 00000001
HostMax:   192.168.0.254        11000000.10101000.00000000. 11111110
Broadcast: 192.168.0.255        11000000.10101000.00000000. 11111111
Hosts/Net: 254                   Class C, Private Internet

What I especially like about ipcalc is seeing the binary form of IP addresses, which clearly shows what netmasks do. These don’t make much sense in dotted decimal notation, but in binary they are as clear as can be. A mask covers things, and in this example it’s plain that the 24-bit netmask covers the first three quads. The first three quads make up the network ID, and the final quad is the host address.

ipcalc tells us the network range (192.168.0.0/24), the first and last available host addresses (192.168.0.1 and 192.168.0.254), and that it’s a Class C private network. Each 8-bit field contains values ranging from 0-255. The very first value in the host field, 0, is always reserved as the network address, and the last value, 255, is always reserved for the broadcast address, so you cannot use these as host addresses. ipcalc reports only available addresses, so in this example, that is 254 instead of 256.

Classful Networking

IPv4 networks have five classes: A, B, and C, which we use all the time, D, the multicast class, and E, which is experimental and reserved for future use. With the advent of IPv6, it’s likely class E will never be used. A picture is worth a thousand words, and this table from Classful network on Wikipedia shows the relationship from decimal to binary.

In the following table:

  • n indicates a bit used for the network ID.
  • H indicates a bit used for the host ID.
  • X indicates a bit without a specified purpose.
Class A
  0.  0.  0.  0 = 00000000.00000000.00000000.00000000
127.255.255.255 = 01111111.11111111.11111111.11111111
                  0nnnnnnn.HHHHHHHH.HHHHHHHH.HHHHHHHH

Class B
128.  0.  0.  0 = 10000000.00000000.00000000.00000000
191.255.255.255 = 10111111.11111111.11111111.11111111
                  10nnnnnn.nnnnnnnn.HHHHHHHH.HHHHHHHH

Class C
192.  0.  0.  0 = 11000000.00000000.00000000.00000000
223.255.255.255 = 11011111.11111111.11111111.11111111
                  110nnnnn.nnnnnnnn.nnnnnnnn.HHHHHHHH

Class D
224.  0.  0.  0 = 11100000.00000000.00000000.00000000
239.255.255.255 = 11101111.11111111.11111111.11111111
                  1110XXXX.XXXXXXXX.XXXXXXXX.XXXXXXXX

Class E
240.  0.  0.  0 = 11110000.00000000.00000000.00000000
255.255.255.255 = 11111111.11111111.11111111.11111111
                  1111XXXX.XXXXXXXX.XXXXXXXX.XXXXXXXX

In the first three classes, note the leading bits, which are the most significant bits. Class A has a leading bit of 0, which means the following 7 bits comprise the network ID, 0-127. Class B has 10, which converts to 128-191, and Class C is 110, 192-223.

You can calculate the total size of each class from the number of leading bits:

$ ipcalc 0.0.0.0/1 
[...]
Hosts/Net: 2147483646  Class A, In Part Private Internet

$ ipcalc 128.0.0.0/2
[...]
Hosts/Net: 1073741822  Class B, In Part APIPA

$ ipcalc 192.0.0.0/3
[...]
Hosts/Net: 536870910   Class C, In Part Private Internet

APIPA is Automatic Private IP Addressing, the range from 169.254.0.1 through 169.254.255.254. This is used primarily in Windows networks; DHCP clients automatically assign themselves one of these addresses when there is no DHCP server.

Private Networks

Most of us are familiar with the private IPv4 network ranges, because we can use these freely on our LANs without requesting globally unique address allocations from a service provider.

Class A  10.0.0.0/8
Class B  172.16.0.0/12
Class C  192.168.0.0/16

Plug any of these into ipcalc and see what it tells you.

Subnetting

Thanks to CIDR, we can finely slice and dice A, B, or C networks into multiple subnets, and ipcalc makes subnetting easy. Suppose you want to make two Class B subnets; just tell ipcalc the network segment you want to divide and how many hosts in each segment. In this example we want 15 hosts in each subnet:

$ ipcalc 172.16.1.0/24 -s 15 15
Address:   172.16.1.0           10101100.00010000.00000001. 00000000
Netmask:   255.255.255.0 = 24   11111111.11111111.11111111. 00000000
Wildcard:  0.0.0.255            00000000.00000000.00000000. 11111111
=>
Network:   172.16.1.0/24        10101100.00010000.00000001. 00000000
HostMin:   172.16.1.1           10101100.00010000.00000001. 00000001
HostMax:   172.16.1.254         10101100.00010000.00000001. 11111110
Broadcast: 172.16.1.255         10101100.00010000.00000001. 11111111
Hosts/Net: 254                   Class B, Private Internet

1. Requested size: 15 hosts
Netmask:   255.255.255.224 = 27 11111111.11111111.11111111.111 00000
Network:   172.16.1.0/27        10101100.00010000.00000001.000 00000
HostMin:   172.16.1.1           10101100.00010000.00000001.000 00001
HostMax:   172.16.1.30          10101100.00010000.00000001.000 11110
Broadcast: 172.16.1.31          10101100.00010000.00000001.000 11111
Hosts/Net: 30                    Class B, Private Internet

2. Requested size: 15 hosts
Netmask:   255.255.255.224 = 27 11111111.11111111.11111111.111 00000
Network:   172.16.1.32/27       10101100.00010000.00000001.001 00000
HostMin:   172.16.1.33          10101100.00010000.00000001.001 00001
HostMax:   172.16.1.62          10101100.00010000.00000001.001 11110
Broadcast: 172.16.1.63          10101100.00010000.00000001.001 11111
Hosts/Net: 30                    Class B, Private Internet

Needed size:  64 addresses.
Used network: 172.16.1.0/26
Unused:
172.16.1.64/26
172.16.1.128/25

I think that is pretty darned fabulous. Why does the example use 172.16.1.0/24? Trial and error: I ran ipcalc with different CIDR ranges until I found one close to the size I needed. 172.16.1.0/24 = 254 hosts per subnet, leaving room to grow.

16,777,214 Loopback Addresses

Did you know that the loopback address range is an entire Class A 8-bit range?

$ ipcalc 127.0.0.0/8
Address:   127.0.0.0            01111111. 00000000.00000000.00000000
Netmask:   255.0.0.0 = 8        11111111. 00000000.00000000.00000000
Wildcard:  0.255.255.255        00000000. 11111111.11111111.11111111
=>
Network:   127.0.0.0/8          01111111. 00000000.00000000.00000000
HostMin:   127.0.0.1            01111111. 00000000.00000000.00000001
HostMax:   127.255.255.254      01111111. 11111111.11111111.11111110
Broadcast: 127.255.255.255      01111111. 11111111.11111111.11111111
Hosts/Net: 16777214              Class A, Loopback

Try it for yourself — you can ping any address in this range. ping localhost returns 127.0.0.1 because most Linux distributions configure this in /etc/hosts.

Sorry, but that’s all the fun we can have today. Come back next week to learn how to tame those massive unwieldy IPv6 addresses with ipv6calc.

Learn more about Linux through the free “Introduction to Linux” course from The Linux Foundation and edX.