We’ve said that Unix offers a huge number of commands and that you can add new ones. This makes it radically different from most operating systems, which contain a strictly limited table of commands. So what are Unix commands, and how are they stored? On Unix, a command is simply a file. For instance, the ls command is a binary file located in the directory bin. So, instead of ls, you could enter the full pathname, also known as the absolute pathname:
This makes Unix very flexible and powerful. To provide a new utility, a system administrator can simply install it in a standard directory where commands are located. There can also be different versions of a command—for instance, you can offer a new version of a utility for testing in one place while leaving the old version in another place, and users can choose the one they want.
Here’s a common problem: sometimes you enter a command that you expect to be on the system, but you receive a message such as “Not found.” The problem may be that the command is located in a directory that your shell is not searching. The list of directories where your shell looks for commands is called your path. Enter the following to see what your path is (remember the dollar sign; otherwise, you won’t see the contents of the environment variable, but only its name, which you know anyway!):
echo $PATH/usr/local/bin:/usr/bin:/usr/X11R6/bin:/bin:/usr/lib/java/bin:\ /usr/games:/usr/bin/TeX:.
This takes a little careful eyeballing. First, the word
PATH is specially recognized by the shell
and is called an environment variable. It’s a
short moniker for useful information—in this case, a list of
directories where the shell should search for commands. There are lots
of environment variables; we saw another one called
SHELL in the section “Shells.” When you
specify an environment variable, include a dollar sign before the
The output of our echo command is a series of pathnames separated by colons. The first pathname, for this particular user, is /usr/local/bin. The second is /usr/bin, and so on. So if two versions of a command exist, one in /usr/local/bin and the other in /usr/bin, the one in /usr/local/bin will execute. The last pathname in this example is simply a dot; it refers to the current directory. Unlike the Windows command-line interpreter, Unix does not look automatically in your current directory. You have to tell it to explicitly, as shown here. Some people think it’s a bad idea to look in the current directory, for security reasons. (An intruder who gets into your account might copy a malicious program to one of your working directories.) However, this mostly applies to root, so normal users generally do not need to worry about this.
If a command is not found, you have to figure out where it is on
the system and add that directory to your path. The manual page should
tell you where it is. Let’s say you find it in /usr/sbin, where a number of system
administration commands are installed. You realize you need access to
these system administration commands, so you enter the following (note
that the first
PATH doesn’t have a
dollar sign, but the second one does):
This command adds /usr/sbin, but makes it the last directory that is searched. The command is saying, “Make my path equal to the old path plus /usr/sbin.”
The previous command works for some shells but not others. It’s fine for most Linux users who are working in a Bourne-compatible shell like bash. But if you use csh or tcsh, you need to issue the following command instead:
set path = ( $PATH /usr/sbin )
Finally, there are a few commands that are not files; cd is one. Most of these commands affect the shell itself and therefore have to be understood and executed by the shell. Because they are part of the shell, they are called built-in commands.