Working with Commands

Chapter 05

Working with Commands Lecture Video

So far, we have witnessed a sequence of enigmatic directives, each accompanied by its own perplexing choices and parameters. In this chapter, our aim is to unveil some of that enigma and even forge our own directives. The directives presented in this chapter include:

• type – Indicate how a command name is interpreted

• which – Display which executable program will be executed

• help – Get help for shell builtins

• man – Display a command's manual page

• apropos – Display a list of appropriate commands

• info – Display a command's info entry

• whatis – Display a very brief description of a command

• alias – Create an alias for a command

What Exactly Are Commands?

A command can be one of four different things:

1. An executable program falls under the same category as those files we encountered in /usr/bin. Within this classification, programs can exist as compiled binaries, such as those coded in C and C++, or as programs written in scripting languages like shell, perl, python, ruby, and more.

2. A command integrated directly into the shell itself is referred to as a shell builtin. bash, specifically, provides support for several such commands internally. An illustration of a shell builtin is the cd command, which is directly embedded within the shell.

3. A shell function is a small-scale shell script that is integrated into the environment. In upcoming chapters, we will delve into configuring the environment and crafting shell functions. However, for the time being, it is important to acknowledge their existence.

4. An alias refers to custom commands that we can personally define, constructed using other existing commands.

Identifying Commands

Having a clear understanding of the specific type of command being utilized is frequently beneficial, and Linux offers a few methods to determine this information.

type – Display A Command's Type

The type command, which is a shell builtin, showcases the type of command that will be executed by the shell when provided with a specific command name. Its usage follows this pattern:

 type command

where command represents the name of the command you wish to inspect. Here are a few examples:

[me@linuxmachine ~] type type
type is a shell builtin
[me@linuxmachine ~] type ls
ls is aliased to `ls --color=auto'
[me@linuxmachine ~] type cp
cp is /usr/bin/cp

Below are the outcomes displayed for three distinct commands. Observe the particular case of ls (taken from an Ubuntu system) and how it is actually an alias for the ls command with the additional --color=auto option. This clarifies why the output of ls appears in color!

which – Display An Executable's Location

Occasionally, multiple versions of an executable program may be installed on a system. While this occurrence is infrequent in desktop systems, it is not uncommon in large servers. To ascertain the precise location of a particular executable, the which command is employed:

[me@linuxmachine ~] which ls
/usr/bin/ls

The which command exclusively functions for executable programs and does not apply to builtins or aliases that serve as substitutes for actual executable programs. If which is used on a shell builtin, such as cd, either no response or an error message will be returned.

[me@linuxmachine ~] which cd
[me@linuxmachine ~]

Getting A Command's Documentation

Armed with this understanding of what constitutes a command, we can proceed to explore the available documentation for each type of command.

help – Get Help For Shell Builtins

The bash shell provides an intrinsic help feature accessible for each of the shell builtins. To utilize it, simply enter help followed by the name of the shell builtin. Here's an example:

[me@linuxmachine ~] help cd
cd: cd [-L|[-P [-e]] [-@]] [dir]
    Change the shell working directory.
    
    Change the current directory to DIR.  The default DIR is the value of the
    HOME shell variable.
    
    The variable CDPATH defines the search path for the directory containing
    DIR.  Alternative directory names in CDPATH are separated by a colon (:).
    A null directory name is the same as the current directory.  If DIR begins
    with a slash (/), then CDPATH is not used.
    
    If the directory is not found, and the shell option `cdable_vars' is set,
    the word is assumed to be  a variable name.  If that variable has a value,
    its value is used for DIR.
    
    Options:
      -L	force symbolic links to be followed: resolve symbolic
    		links in DIR after processing instances of `..'
      -P	use the physical directory structure without following
    		symbolic links: resolve symbolic links in DIR before
    		processing instances of `..'
      -e	if the -P option is supplied, and the current working
    		directory cannot be determined successfully, exit with
    		a non-zero status
      -@	on systems that support it, present a file with extended
    		attributes as a directory containing the file attributes
    
    The default is to follow symbolic links, as if `-L' were specified.
    `..' is processed by removing the immediately previous pathname component
    back to a slash or the beginning of DIR.
    
    Exit Status:
    Returns 0 if the directory is changed, and if $PWD is set successfully when
    -P is used; non-zero otherwise.

Regarding notation, when you encounter square brackets in a command's syntax description, they signify optional components. On the other hand, a vertical bar character denotes mutually exclusive items. In the case of the aforementioned cd command:

cd [-L|[-P [-e]] [-@]] [dir]

The provided notation indicates that the cd command can be followed by either the optional -L or -P options. Additionally, if the -P option is specified, the -e option may also be included, followed by the optional argument dir.

Although the help output for the cd commands is concise and accurate, it does not serve as a tutorial. Moreover, it may reference several aspects that have not yet been discussed. However, there is no need to worry as we will cover those topics in due course.

--help – Display Usage Information

Numerous executable programs offer a --help option, which presents a description of the supported syntax and available options for the command. Here's an example:

[me@linuxmachine ~] mkdir --help
Usage: mkdir [OPTION]... DIRECTORY...
Create the DIRECTORY(ies), if they do not already exist.

Mandatory arguments to long options are mandatory for short options too.
  -m, --mode=MODE   set file mode (as in chmod), not a=rwx - umask
  -p, --parents     no error if existing, make parent directories as needed
  -v, --verbose     print a message for each created directory
  -Z                   set SELinux security context of each created directory
                         to the default type
      --context[=CTX]  like -Z, or if CTX is specified then set the SELinux
                         or SMACK security context to CTX
      --help     display this help and exit
      --version  output version information and exit

GNU coreutils online help: <https://www.gnu.org/software/coreutils/>
Full documentation <https://www.gnu.org/software/coreutils/mkdir>
or available locally via: info '(coreutils) mkdir invocation'

While certain programs do not support the --help option, it is still worth attempting. In many cases, it will generate an error message that discloses the same usage information.

man – Display A Program's Manual Page

The majority of executable programs designed for command line usage come with a formal documentation known as a manual or man page. To view these pages, a dedicated paging program called man is utilized. Here's how to use it:

man program

where program is the name of the command to view.

Man pages exhibit slight variations in format, but typically encompass a title, a synopsis outlining the command's syntax, a description clarifying the command's purpose, and a listing with explanations of each available option. It is important to note that man pages usually lack examples and are primarily designed as a reference rather than a tutorial. Let's try viewing the man page for the ls command as an illustration:

[me@linuxmachine ~] man ls

In the majority of Linux systems, the man command utilizes less to present the manual page, allowing you to employ all the familiar less commands while viewing the page.

The "manual" displayed by the man command is organized into sections, encompassing not only user commands but also system administration commands, programming interfaces, file formats, and more. The table below elucidates the structure of the manual:

Section	Contents
1	User commands
2	Programming interfaces kernel system calls
3	Programming interfaces to the C library
4	Special files such as device nodes and drivers
5	File formats
6	Games and amusements such as screen savers
7	Miscellaneous
8	System administration commands

There are instances when we specifically need to search within a particular section of the manual to find the information we seek. This is particularly relevant if we are searching for a file format that shares its name with a command. By omitting the section number, we will typically retrieve the first matching instance, usually in section 1. To specify a section number, we utilize the man command in the following manner:

man section search_term

For example:

[me@linuxmachine ~] man 5 passwd

This will display the man page describing the file format of the /etc/passwd file.

apropos – Display Appropriate Commands

Furthermore, it is possible to conduct a search within the list of man pages to identify potential matches based on a search term. Although rudimentary, this feature can be quite useful. Here's an example of performing a search for man pages using the search term "disk":

[me@linuxmachine ~] apropos disk
arm_sync_file_range (2) - sync a file segment with disk
baobab (1)           - A graphical disk usage analyzer for the GNOME desktop
biotop-bpfcc (8)     - Block device (disk) I/O by process top.
cfdisk (8)           - display or manipulate a disk partition table
cgdisk (8)           - Curses-based GUID partition table (GPT) manipulator
cryptdisks_start (8) - wrapper around cryptsetup that parses /etc/crypttab.
cryptdisks_stop (8)  - wrapper around cryptsetup that parses /etc/crypttab.
df (1)               - report file system disk space usage
fdisk (8)            - manipulate disk partition table
gdisk (8)            - Interactive GUID partition table (GPT) manipulator
git-count-objects (1) - Count unpacked number of objects and their disk consumption
git-credential-store (1) - Helper to store credentials on disk
gnome-disk-image-mounter (1) - Attach and mount disk images
gnome-disks (1)      - the GNOME Disks application
hd (4)               - MFM/IDE hard disk devices
initrd (4)           - boot loader initialized RAM disk
lvmdiskscan (8)      - List devices that may be used as physical volumes
pam_setquota (8)     - PAM module to set or modify disk quotas on session start
partx (8)            - tell the kernel about the presence and numbering of on-di...
quotactl (2)         - manipulate disk quotas
ram (4)              - ram disk device
sd (4)               - driver for SCSI disk drives
selinux_file_context_verify (3) - Compare the SELinux security context on disk t...
sfdisk (8)           - display or manipulate a disk partition table
sgdisk (8)           - Command-line GUID partition table (GPT) manipulator for L...
sync (2)             - commit filesystem caches to disk
sync_file_range (2)  - sync a file segment with disk
sync_file_range2 (2) - sync a file segment with disk
syncfs (2)           - commit filesystem caches to disk
systemd-cryptsetup (8) - Full disk decryption logic
[email protected] (8) - Full disk decryption logic
systemd-machine-id-commit.service (8) - Commit a transient machine ID to disk
systemd-veritysetup (8) - Disk verity protection logic
[email protected] (8) - Disk verity protection logic
udisks (8)           - Disk Manager
udisks2.conf (5)     - The udisks2 configuration file
udisksctl (1)        - The udisks command line tool
udisksd (8)          - The udisks system daemon
umount.udisks2 (8)   - unmount file systems that have been mounted by UDisks2

In the output, the first field of each line represents the name of the man page, while the second field indicates the corresponding section. It is important to note that the man command with the -k option fulfills the same purpose as the apropos command.

whatis – Display A Very Brief Description Of A Command

The whatis program exhibits the name and provides a brief one-line description of a man page that matches a given keyword:

[me@linuxmachine ~] whatis ls
ls (1)               - list directory contents

info – Display A Program's Info Entry

The GNU Project offers an alternative to man pages for their programs known as info. Info pages are presented using a reader program aptly named info, and they feature hyperlinks similar to web pages. Here is an example:

Next: dir invocation,  Up: Directory listing

10.1 ‘ls’: List directory contents
==================================

The ‘ls’ program lists information about files (of any type, including
directories).  Options and file arguments can be intermixed arbitrarily,
as usual.

   For non-option command-line arguments that are directories, by
default ‘ls’ lists the contents of directories, not recursively, and
omitting files with names beginning with ‘.’.  For other non-option
arguments, by default ‘ls’ lists just the file name.  If no non-option
argument is specified, ‘ls’ operates on the current directory, acting as
if it had been invoked with a single argument of ‘.’.
...

The info program is designed to read info files that possess a tree structure, consisting of individual nodes, each dedicated to a specific topic. Info files incorporate hyperlinks that enable navigation from one node to another. Hyperlinks are indicated by a leading asterisk and can be activated by placing the cursor on them and pressing the enter key.

To launch the info program, simply enter info followed by the optional name of a program. Presented below is a table of commands utilized to navigate and control the reader while viewing an info page:

Command	Action
?	Display command help
PgUp or Backspace	Display previous page
PgDn or Space	Display next page
n	Next - Display the next node
p	Previous - Display the previous node
u	Up - Display the parent node of the currently displayed node, usually a menu.
Enter	Follow the hyperlink at the cursor location
q	Quit

The majority of command line programs we have discussed thus far are included in the GNU Project's coreutils package. Therefore, if you type:

[me@linuxmachine ~] info coreutils

will display a menu page with hyperlinks to each program contained in the coreutils package.

README And Other Program Documentation Files

On your system, numerous software packages are installed, and their corresponding documentation files are located in the /usr/share/doc directory. Most of these files are stored in plain text format, accessible for viewing using the less command. However, some files are in HTML format and can be opened with a web browser. It is possible to come across files with a ".gz" extension, indicating that they have been compressed using the gzip compression program. For viewing the contents of such gzip-compressed text files, the gzip package includes a specialized version of less called zless.

Creating Your Own Commands With alias

Now, let's embark on our first programming endeavor! We will construct our own command using the alias command. However, before we begin, let's unveil a handy command line technique. You can execute multiple commands on a single line by separating each command with a semicolon character. Here's how it functions:

command1; command2; command3...

Here's the example we will use:

[me@linuxmachine ~] cd /usr; ls; cd -
bin  games  include  lib  lib32  lib64  libexec  libx32  local  sbin  share  src
/home/me

As observed, we have merged three commands into a single line. Initially, we switch to the /usr directory, followed by listing its contents. Finally, we return to the original directory using cd - to ensure we end up where we began. Now, let's transform this sequence into a new command using the alia feature. The first step is to come up with a suitable name for our command. Let's try test. However, before proceeding, it is wise to determine whether the name "test" is already in use. We can verify this by utilizing the type command once again:

[me@linuxmachine ~] type test
test is a shell builtin

Oops! The name test is already taken. Let's try foo:

[me@linuxmachine ~] type foo
bash: type: foo: not found

Great! foo is not taken. So let's create our alias:

[me@linuxmachine ~] alias foo='cd /usr; ls; cd -'

Notice the structure of this command:

alias name='string'

Following the alias command, we provide a name for the alias, immediately followed (without any whitespace) by an equals sign. Subsequently, we enclose the assigned meaning within quotes. Once the alias is defined, it can be employed anywhere the shell anticipates a command. Let's put it into practice:

[me@linuxmachine ~] foo
bin  games  include  lib  lib32  lib64  libexec  libx32  local  sbin  share  src
/home/me

We can also use the type command again to see our alias:

[me@linuxmachine ~] type foo
foo is aliased to `cd /usr; ls; cd -'

To remove an alias, the unalias command is used, like so:

[me@linuxmachine ~] unalias foo
[me@linuxmachine ~] type foo
bash: type: foo: not found

Although we intentionally refrained from assigning our alias a name that matches an existing command, it is not uncommon to do so. This practice is frequently employed to apply commonly desired options to every invocation of a widely used command. As we saw earlier, the ls command is frequently aliased to include color support:

[me@linuxmachine ~] type ls
ls is aliased to `ls --color=auto'

To view all the aliases defined in the environment, you can execute the alias command without any arguments. Below are some of the aliases that come pre-defined on an Ubuntu system. Take a moment to decipher their functionalities:

[me@linuxmachine ~] alias
alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'
alias egrep='egrep --color=auto'
alias fgrep='fgrep --color=auto'
alias grep='grep --color=auto'
alias l='ls -CF'
alias la='ls -A'
alias ll='ls -alF'
alias ls='ls --color=auto'

There is a minor inconvenience when defining aliases directly on the command line—they disappear once your shell session concludes. However, in a subsequent chapter, we will explore how to add our own aliases to the files responsible for setting up the environment each time we log on. For now, let's appreciate the fact that we have taken our initial, albeit small, stride into the realm of shell programming!

Summary

Now that we have acquired the knowledge of locating command documentation, I encourage you to explore the documentation for all the commands we have encountered thus far. Delve into the details of additional options that are available and feel free to experiment with them!