Table of Contents for

Ubuntu: Up and Running

By default, the prompt you see when you first open a Terminal window will be something like this:

user@computer:~$

In my case, my username is robin and the computer I am using is called linux-box, so the prompt I see is:

robin@linux-box:~$

The idea behind this is to remind you of the username and computer you are using, so you don’t have to remember those details yourself, which is especially useful when managing multiple computers or logins.

Now let’s look at some commands, starting with the cd command, which is used to change directory (or folder). In its simplest form, you just enter something like the following:

cd /home

This command makes the home folder the default working folder. Enter the text shown and press the Return or Enter key, and the Terminal prompt will change to show something like the following:

user@computer:/home$

Remember that the actual prompt you see will have your username and computer name in place of user and computer. Now try entering the following two commands:

cd /home
pwd

Ubuntu should report that you are now in the home folder by displaying the following:

/home
user@computer:/home$

You can try navigating back up a level to the / directory by entering this:

cd ..

The .. is a shorthand you use to represent the parent folder. Whatever the parent of the current folder is, Ubuntu will go to it automatically when this command is issued. Now try the following command to select your home folder:

cd ~

I have no way of knowing what your username is, but Ubuntu does, and when you use the ~ symbol, it is substituted with your home folder. So, enter the following to see which folder is now the working directory:

pwd

Now type the following to view the contents of this folder:

ls

The result should look something like Figure 7-2. Although you may have more or less items, you should have a very similar collection of subfolders, and unless you have deleted any of your default folders, you will at least see Desktop, Documents, Downloads, example.desktop, Music, Pictures, Public, Templates, Ubuntu One, and Videos.

Figure 7-2. Listing the contents of the home folder

You can also use -a option with the ls command to show all the files in the current folder, like this:

ls -a

You will then be presented with a long list of files and folders that looks something like the following:

.                   .gnome2              .profile
..                  .gnome2_private      Public
.adobe              .gnupg               .pulse
.apport-ignore.xml  .gstreamer-0.10      .pulse-cookie
.bash_history       .gtk-bookmarks       .qt
.bash_logout        .gvfs                .quicksynergy
.bashrc             .hplip               .recently-used
.cache              .ICEauthority        .recently-used.xbel
.compiz             .icons               .ssh
.config             .kde                 .sudo_as_admin_successful
.dbus               .local               Templates
Desktop             .macromedia          test
   (etc...)

All the items beginning with a period are normally hidden, but the -a option has revealed them. Generally, though, you don’t need to see these files.

To display the output in long form you can use another option, like this:

ls -l

And the result will then look something like this:

drwxr-xr-x  3 robin robin 4096 2009-10-05 14:12 Desktop
drwxr-xr-x  2 robin robin 4096 2009-09-07 15:29 Documents
drwx------  2 robin robin 4096 2009-09-02 10:15 Downloads
lrwxrwxrwx  1 robin robin   26 2009-04-16 17:56 Examples
                            -> /usr/share/example-content
drwxr-xr-x 12 robin robin 4096 2009-06-16 00:45 firefox
drwxr-xr-x  2 robin robin 4096 2009-04-16 18:07 Music
drwxr-xr-x  2 robin robin 4096 2009-10-05 13:45 My Projects
drwxr-xr-x  2 robin robin 4096 2009-04-16 18:07 Pictures
drwxr-xr-x  2 robin robin 4096 2009-04-16 18:07 Public
drwxr-xr-x  2 robin robin 4096 2009-09-23 15:13 Templates
drwxr-xr-x  2 robin robin 4096 2009-10-05 14:47 test
drwxr-xr-x  2 robin robin 4096 2009-04-16 18:07 Videos

You can also combine the switches like this:

ls -al

Anyway, getting back to the cd command, for the next example you should now change your working folder to Pictures by entering the following:

cd Pictures

Now enter pwd to verify that this has worked; you should see that you have switched to the Pictures folder.

So, let’s see the .. shortcut in action by changing up a level and back down again to the Downloads folder, all in a single command, like this:

cd ../Downloads

What you have given the cd command is a relative path, which will work no matter what your username is; see Absolute and Relative Paths.

The cp command takes two arguments: an existing file to copy and a destination. So, for example, if you have the file accounts.txt and would like to make a backup file, you can issue this command:

cp accounts.txt accounts.bak

This will create the new file accounts.bak, which will be an identical copy of the original file. You can also use this command to copy folders, and even entire filesystems and subsystems. If the second argument is a folder instead of a file, the files you copy go directly under the folder and are given the source file’s filename.

For example, to create a copy of the /boot folder within your home folder, you could ensure that you are in that folder and create a new one in which to copy the files by entering the following commands (the mkdir command standing for make directory):

cd ~
mkdir test

Then you would enter the following to perform the copy:

cp /boot/* test

What this does is tell Ubuntu to copy all the files it finds in the /boot folder—achieved by use of the * wildcard character, which used this way means “any file at all”—into the test folder. It does not, however, copy any subfolders, and if there are any (such as the grub subfolder in this case), it will issue a message telling you that it has omitted them. To copy a folder and all its subfolders, you would add the -r argument for recursive copying, like this:

cp -r /boot/* test

Ubuntu considers renaming and moving items to be equivalent. If you rename a file, Ubuntu treats it as if you have moved it to a new location comprising the current folder and the new filename. Therefore, unlike DOS, instead of having both a MOVE and a RENAME command, Ubuntu provides just the mv command.

mv accounts.txt accounts.old

mv accounts.txt backups

mv oldfolder newfolder

mv accounts.txt backups

mv accounts.txt backups/accounts.old

mv oldfolder otherfolder

mv *.txt textfolder

mv *.txt *.jpg readme.doc destination

Using diff, you can quickly get a glimpse of the differences between two document files. The syntax to use is like this:

diff file1 file2

The program loads in the two files it is passed, synchronizes all the parts of text that are the same in each file, and then discards them. Whatever text remains from each file must be different from the other one. Then it is displayed, as shown in Figure 7-3.

Figure 7-3. Displaying the differences between two files

Any text that exists in the first file but is not present in the second one is shown first, prefaced by a < symbol to remind you that the text is unique to the first file. Likewise, the text that occurs only in the second file comes next, but this time prefaced by a > symbol.

The screen grab shows that there are two extra lines in the file review1.txt and four in review2.txt. Using diff, it’s clear to see that each file has been separately edited, with an extra paragraph added (or removed).

Programmers often use this program to highlight changes between various different versions of a program. You could use it to see changes made between versions of a report, a recipe, or anything that you save copies of as you go along.

There are thousands of files in an Ubuntu installation (if not hundreds of thousands), so locating individual ones could be a nightmare without the find command. But with it, you can find almost any file within a few seconds.

The program supports many options, but at its most basic you use it by entering a command such as this:

find / -name blackjack

This command searches the entire filesystem for any files called blackjack. However, as you will see from Figure 7-4, folders that you do not have permission to access are skipped, with the error message “Permission denied.”

At the top of the screen grab, you’ll see that six files with the name blackjack have been found, and plenty of folders have not been searched due to permission settings. If you want to be given access to these folders, you can use the sudo command to temporarily become the root user (see the section Using sudo for more information), like this (entering your password when prompted):

sudo find / -name blackjack

Either way, from the information returned, we can see that the likely location of the blackjack program is /usr/games/blackjack, shown in the fourth line in the screenshot.

Of course, the default Ubuntu games are all available from the Applications → Games submenu, but if you ever delete any of these (or other) entries, this is how you can find out where the programs are located. And, indeed, if you type the following into the Terminal, the Blackjack game will open, as shown in Figure 7-5.

/usr/games/blackjack

Figure 7-4. Searching for programs named blackjack

Figure 7-5. Running a program after determining its location

If you only know part of a file’s name, you can also use the * and ? wildcard symbols. For more on this subject, see the section later in this chapter called Wildcards, Sets, and Brace Expansion. But for now all you need to know is that a ? represents a single wildcard character, and * represents zero or more unknown characters.

So, for example, all the following will locate the blackjack program file (and many others):

find / -name black*
find / -name *jack
find / -name bl?ck*

In fact, there may be so many entries that you want to page through them all, which you can do using the more command, explained in the next section.

You don’t have to always search from the root folder. You can, for example, search for files only in the current folder and its subfolders, which you can do using the period character, like this:

find . -name invoice*

or starting from your home folder, like this:

find ~ -name invoice*

The cat command takes a file and outputs it to the screen. To use it, enter a command such as the following:

cat chapter7.txt

However, if there are more lines than will fit in the window, the text will scroll, which is where the more program comes in.

On its own, the more command is very useful for paging through text files that have more lines than can be displayed in the Terminal window. To use it, you enter the command’s name followed by the name of the file to view, like this:

more chapter7.txt

See Figure 7-6 for the result of using the program on an early draft of this chapter.

Figure 7-6. Using the more command to display a text file

As you can see, this is easier than loading the file into a text editor just for viewing it. You can scroll though the file a line at a time by pressing the Enter key, or a page at a time by pressing the space bar. To quit, press the q key.

The more command is, however, far more powerful than you might think, thanks to Ubuntu’s ability to use pipes—a method by which the output from one program is passed as the input to another—which is fully explained later on in the sections Using Redirection and Using Pipes. But more is such a useful feature that it’s worth a quick look at now.

For example, in the previous section on using the find command, I promised we would see how we can combine it with more to page the output. And here’s how you would do it:

find / -name bl?ck* |more

At the end of this command, I have added a | (pipe) symbol followed by a call to the more program. As you’ll learn later, the | takes the output that would have been displayed and passes it to the more program to deal with instead.

What happens is that all the output (except for any error messages) is stored up, and when find exits, the more program takes over, displaying the stored-up output a page at a time. The first page displayed by more looks like Figure 7-7.

Figure 7-7. Using the more program to page the output from find

You can add the more command this way to almost any other Bash command where there is more output than will fit in the Terminal window. An odd little side effect of the pipe improves the value of the output from more: all the “Permission denied” error messages from find are displayed before more runs so that you get only the useful output all at the end. There are also ways to completely suppress error messages altogether, which I’ll show later.

Using the grep command, you can take your searches a step further and look inside files for text to match. It is a very powerful command with some quite sophisticated features, such as choosing (or ignoring) case-sensitivity, matching only whole words, and much more. In fact, entire books have been written about the program. But most of us will generally use grep in its simplest form, in which a given set of files is searched for a particular word or phrase.

For example, to locate every file in your Documents folder containing the word invoice, you could issue the following command:

grep invoice ~/Documents/*

You should remember the ~ character from the earlier section on the cp command; it represents your home folder. Using it this way cuts out a step because you don’t have to use cd to change to the home folder. Instead, by prefacing a file or folder name with ~, you tell Ubuntu to start a relative path from that point.

Therefore, if you have the username fred, then ~/Documents/* will refer to all the documents within the folder /home/fred/Documents.

So the previous command calls up the grep command, asking it to search for the word invoice in all the files within the given folder, and then displays those that match. To illustrate this, here’s a command you can type in right now:

grep -r videos /usr/share/doc

This command specifies the -r option to search the /usr/share/doc folder and all its subfolders for any files whose contents contain the word videos. (The option used is -r because programmers use the word recursive to describe a task that keeps on drilling down through levels, such as in this case of folders within folders within folders, and so on.)

If you don’t care about the case of a match, you can use the -i option to choose a case-insensitive search, which will return even more results (but will take longer to perform):

grep -ri videos /usr/share/doc

And to only return documents where the word videos appears on its own and not, for example, as part of the string videosettings, you can use the -w option as follows, the result of which will look like Figure 7-8.

grep -rw videos /usr/share/doc

Figure 7-8. Searching for files containing the word videos

As with the more command, you can also use grep in conjunction with a pipe. So, for example, to narrow down the output from an ls command to display only certain files, such as those containing the sequence Do within your home folder, you could enter this command:

ls ~ |grep Do

This will list at least your Documents and Downloads folders, as well as any others you have created that match the specified pattern.

To delete a file or folder, use the rm command, which stands for remove. For example, to erase the file tempfile in the current folder, use this command:

rm tempfile

Or to erase a file in your home folder, you could enter a command such as:

rm ~/oldfile

You can also delete an empty folder using rmdir, like this:

rmdir EmptyFolder

However, to remove a folder containing any files or subfolders, you need to use the rm command with the argument -rf, like this:

rm -rf FolderWithStuffIn

Using this command, you can quickly summarize the number of lines, words, and characters in a text file. You use it like this:

wc document

The program will then display a result such as this:

  10  234 1319 document

This tells you that document has 10 lines, 234 words, and 1,319 characters. Actual lines within the document are counted, not the number of lines the file would use if displayed in the Terminal window. The character count will include one character for each end-of-line character, so it will be higher than the number of visible characters.

Now let’s look at a possibly confusing situation by assuming you have entered cd ~ to set your home folder as your working directory, and have saved into it a program called find. In this case you might think you can now enter find and the program will run, but actually it won’t, because there’s a program with the name find located in the /usr/bin folder, and Ubuntu will execute that file by default because it is in the path, and that gets searched before the current folder.

One solution is to reference the program with either an absolute or a relative path and filename, such as this:

~/find

However, when a program is in the current directory, you can use the single period operator to run it, like this:

./find

This turns the command into a relative pathname and tells the system to run the program exactly where you say it is, not to first search for the program in the path.

Alternatively, if you tried to run a program in your home folder (or any other not in the path) that didn’t have a counterpart file with the same name somewhere in path, you would just receive a “command not found” error message, unless you properly identified the program’s location with a ~, a ., or another relative or absolute prefix.

The following command creates a file called files.txt in your home folder containing the output from ls -al:

ls -al > ~/files.txt

If files.txt already exists, it will be overwritten; otherwise, it will be created.

When you issue that command, you won’t see anything on the screen, because the output that would have been displayed has been redirected to a file. But you can verify that the command worked by entering the following, which displays the file’s contents:

cat ~/files.txt

The result of issuing this command will look something like Figure 7-15.

Figure 7-15. The result of displaying files.txt

But what if you want to know which files and folders were created first? The answer would be to sort them by column 6, and you could use this command to do it:

ls -al | sort -k6 > ~/files.txt

If you need to keep the file sorted alphabetically but still wish to sometimes view the lines in date order, you can issue the following command on it instead:

sort -k6 < ~/files.txt

This opens up files.txt, reads it in, and passes its contents to the command immediately preceding the < symbol.

You could even extend that to use the less command by adding the | operator:

sort -k6 < ~/files.txt | less

This works because the > and < operators work on files and devices, whereas the | operator creates pipes between commands. Therefore, sort -k6 < ~/files.txt is seen as a complete command in its own right, the output of which can be displayed or, as in this case, piped to another command.

You should now see that a pipe is the equivalent of combining two separate redirection commands. For example, take a look at the following simple command, which pages the output from a file listing:

ls -al | more

This is actually equivalent to these two lines:

ls -al > tempfile
more < tempfile

Actually, to make these commands fully identical in action, you should also add the following command afterward to remove the temporary file:

rm tempfile

So, all told, each pipe can represent the equivalent of three separate commands.

./install-program >/dev/null

You can also append to an existing file by stringing two > symbols together, like this:

ls -al >> ~/files.txt

If files.txt already exists, the output is appended to the end of it; otherwise, the file is created first.

The answer is that Ubuntu uses three different streams for input, output, and error messages, and when you use a > or | for redirection or piping, it affects only standard output, not standard error. This means that when you type this:

find / -name blackjack | more

only the standard output is redirected; the standard error stream is still displayed by the initial find command. However, after displaying the errors, the more program then pages through the standard output. So, although the display is a little untidy because the errors are still shown, at least the matching results are all shown together.

But you can clear up any messiness by telling Ubuntu exactly what should be redirected or piped by using stream handles. Table 7-4 lists the three streams, along with their handles and their short names, stdin, stdout, and stderr, which I’ll use from now on.

The way we force a particular stream to be used is to place it directly before a redirection or pipe operator. So, for example, we could send all the stderr error messages from a command directly to a different file like this:

find / -name blackjack 2> ignoreme.txt

However, this is not an optimal solution, because we end up creating a useless file that’s not actually wanted or needed. But as I mentioned in the section Using Redirection, this scenario has already been covered by the operating system’s programmers, who created an imaginary device called /dev/null, which acts as a black hole for unwanted output. Therefore, a much more elegant solution would be to redirect all the output from stderr into that abyss, like this:

find / -name blackjack 2> /dev/null

If you try out this improved version, you’ll have to wait before you see anything while all the various folders are searched. But sure as eggs are eggs, your patience will be rewarded, as one by one, matches for the search term blackjack are displayed. The output also can be piped to more or less if you like.

Error messages can be very useful, though, so suppose you have decided you actually do want them included in a file created from a redirect. You can achieve this by merging the stderr and stdout streams like this:

find / -name blackjack > ~/results.txt 2>&1

This command redirects stdout using the default > operator to the file ~/results.txt, and then redirects stderr, using its stream number of 2, to the unlikely looking recipient of &1. Note that there must be no space between the > and the &.

What the 2>&1 says to the operating system is “redirect the output for stderr, sending it to stdout,” because stdout has the stream number 1.

./install-program >/dev/null

./install-program >/dev/null 2>&1

There’s also a convenient shortcut that combines > with 2>&1; simply use >& instead:

find / -name blackjack >& ~/results.txt

Also, if you really want to get fancy, you can use the shortcut |& to pipe standard error and standard output together.

There are times when you want output to be sent to a file and also to the Terminal window, both at the same time. The way to do this is to pipe whichever output you desire (stdout or stderr, or even both if you create the proper redirects) to the tee command, and then supply the recipient filename, like this:

ls -al | tee ~/files.txt

This lists all the files in the current folder both to the screen and to ~/files.txt. You can also use tee with the merged streams in the previous section, like this:

find / -name blackjack | tee ~/results.txt 2>&1

A set of characters placed within a pair of rectangular brackets can match a single character in a file or folder name. This is a more precise version of the ? single-character wildcard. For example, the set [abcdef] will match any of the six characters shown so that [abcdef]ark.txt will match the filenames bark.txt and dark.txt, as long as they both exist. You can also save on typing by using a hyphen to indicate a range of characters so that [a-f] is equivalent to [abcdef].

Another neat thing you can do with a set is force all upper- or all lowercase matches using the ranges [A-Z] or [a-z]. Or you can limit the matching to only alphabetical characters of either case (excluding digits and other characters) by using the set [a-zA-z]. And you can also use numbers in a range, as in [0-9].

Alternatively, you can exclude characters from matching by using the ^ operator. In this case, [^b]ark.txt would prevent the file bark.txt from being matched, but would let through dark.txt, lark.txt, and so on.

You can also use ranges with the ^ operator so that [^a-l]ark.txt will allow through only filenames starting from mark.txt onward, as all the first letters prior to m are excluded.

With brace expansion you can offer sets of alternatives strings of any length, so you aren’t limited to the single characters of sets. For example, all three terms in the expression ca{ree,mpe,tere}rs.txt will be expanded, allowing all of the files careers.txt, campers.txt and caterers.txt through the filter (if they exist), with the matching portions shown in bold.

Unlike sets and wildcards, brace expansions are also supported in other parts of the command line, so the following echo command will show you the result of using the expression just shown:

echo ca{ree,mpe,tere}rs

The following is the displayed result:

careers campers caterers

By the way, did you notice that there are no quotation marks around the argument to the echo command (unlike previous examples in this chapter)? That’s because quotation marks tell Ubuntu to use the exact contents of the string, rather than supporting brace expansion and other features. Therefore the following command results in displaying only the expression itself, so make sure you know when you do and when you don’t need quotation marks:

echo "ca{ree,mpe,tere}rs"

The displayed result of entering this command is simply:

ca{ree,mpe,tere}rs

To extract files from a gzip archive, enter a command such as the following:

gunzip finances.doc.gz

This extracts the file finances.doc and then removes the archive file. You can similarly extract files from a bzip2 archive using a command such as this:

bunzip2 finances.doc.bz2

This will restore the compressed original file and remove the archive.

You can also use these and many other compression and decompression programs to manage multiple files and folders and provide a range of other archiving features. For example, you may come across .tar archive files, which combine multiple files or directories into a single file to facilitate backup and copying. The tar program is often combined with other compression programs to create .tar.gz or .tar.bz2 files.

A beginner to Ubuntu really doesn’t need to explore the intricacies of archive and compression utilities, thanks mainly to the GNOME desktop and the Nautilus file browser’s ability to handle everything for you automatically. But if you wish to access advanced command-line file compression features, you should read the manpages by entering man followed by the compression program in question, such as man tar.

With eight possible permutations of permissions (and three sets of them), there are 512 different possible permissions per file. So, how on earth does anyone, or even the computer, keep track of all this? Well, it’s actually quite simple, as illustrated by Table 7-8, in which each of the owner, group, and world columns can have a value between 0 and 7, giving possible values between 000 and 777 in octal (the 0 through 511 permutations in decimal being the same as 0 through 777 in octal).

Let’s look at the most commonly used permission setting, which is 644. The value 644 corresponds to an owner setting of 6, and group and world settings of 4, such that a file with attributes set to this value can be written to and read from by the file’s owner, but people in the file’s group or anyone else (the world) can only read the file. This is the default setting applied to new files you create.

To see how this works, look at Table 7-8 and reference row 6, and then look up the checkmarks for this value in the owner column; both read and write are checked. Then look at the row where the value is 4, and you’ll see that only read is checked.

An executable program file that you want to protect in a manner similar to a document should have permission settings of 755. This is the same as 644, except that the exec column is checked for each type of user (in other words, a 1 has to be added to each of the three parts).

Or, as another example, if you want to make a file so that only you can access it, but can do anything you want to it—write to, read from, or execute—you would set its permission value to 700. Any file with attributes ending in 00 is therefore 100% private to you—except that the superuser account, root, can also do anything it wants with such a file.

The chmod command is used to change a file or folder’s attributes (the name refers to another term, mode, which is sometimes used for the set of attributes), as long as you are its owner. So, to set the file filename to readable and writable for yourself but only readable by all others, you would need to use a setting of 644, like this:

chmod 644 filename

If you don’t want to be bothered with working out the octal number, you’ll be glad to hear you can also use the following shorthand options:

The first four options specify which users (out of the owner, group, world, or all) the permission change should apply to, the default being a for all users. The final three are the permission(s) to change.

Therefore, to force a setting of 644 (regardless of a file’s previous permissions), you could use these two commands:

chmod a+r-w-x filename
chmod u+w filename

The first command sets all of user, group, and others (a) as allowed to read but not to write or execute (+r-w-x) the file. The second enables the user (u) to write (+w) to the file.

To find out what the current attributes are, type:

ls -l filename

This will display a long line containing the meta information the system knows about the file. The first column will contain the attributes and will look like this:

-r--r--r--

The very first character on the line indicates whether an item is a file, a directory, or a symbolic link. Files show up as a hyphen (-), directories display the letter d, and links are represented by the letter l. So, ignoring that first character, there are nine remaining: three triplets of three, representing in turn the permissions for each of the owner, group, and world.

Therefore we can see from the example just shown that filename offers only read access to the owner, the group, and the world. To change this file so it is writable by the owner, all that needs to be done is add that one attribute, like this:

chmod u+w filename

For another example, if the file you are accessing needs to be set to executable so that it can be run by everyone, you could use this command:

chmod a+x filename

Alternatively, because the default always applies to all users, you could simply enter:

chmod +x filename

When you view a folder using the ls -l command, the output will look something like this:

drwxr-xr-x 2 robin robin 4096 2009-11-30 10:38 Desktop
drwxr-xr-x 2 robin robin 4096 2009-11-27 04:48 Documents
drwxr-xr-x 2 robin robin 4096 2009-11-27 04:48 Downloads
-rw-r--r-- 1 robin robin  167 2009-11-27 04:38 examples.desktop
drwxr-xr-x 2 robin robin 4096 2009-11-27 04:48 Music
drwxr-xr-x 2 robin robin 4096 2009-11-27 04:48 Pictures
drwxr-xr-x 2 robin robin 4096 2009-11-27 04:48 Public
drwxr-xr-x 2 robin robin 4096 2009-11-27 04:48 Templates
drwxrwxr-x 2 robin robin 4096 2009-11-27 12:49 Ubuntu One
drwxr-xr-x 2 robin robin 4096 2009-11-27 04:48 Videos

In turn, each of these columns displays the following information:

The chown command allows the ownership of a file or folder to be changed. This is such a powerful command that it can be used only by the root user, which means you must preface it with a sudo command and will be prompted for your password.

So, for example, to change the ownership of a file to the user mary, you would use a command such as this (as long as the user mary already exists):

sudo chown mary filename

If you then perform an ls -l command on the file, you’ll see that the file has changed ownership. If the file was one that you previously owned, changing its attributes now will require using sudo, unless you change the ownership back again.

Ubuntu comes with the ready-created user called nobody, so you can easily test this command out using the following sequence of instructions:

echo > testfile
ls -l testfile
sudo chown nobody testfile
ls -l testfile
sudo rm testfile

These lines create an empty file called testfile by redirecting a blank echo command. Then the file’s attributes are viewed using the ls command, before then changing its ownership with chown. After that, the ownership is again displayed, showing that it has indeed changed, and finally, the test file is removed with the rm command. Figure 7-16 shows what you should see on your display if you enter these lines.

Figure 7-16. A test of changing a file’s ownership

On the sixth line down in the screenshot you’ll see that robin is no longer the owner of the file, as that privilege now belongs to nobody, although the group called robin retains its ownership.

This command is similar to chown except that it works for groups. With it the group assigned to a file or folder can be changed to another one, and with the sudo command, you can do this without assuming the root user—as long as you are the owner of the item and also a member of new group that you wish to assign.

So, for example, if you are a member of the group accounts, you could change the group associated with a file to that group with this command:

chgrp accounts filename

When you are not already a member of the group that you wish to change a file or folder to, or if you need to change the file of another user or group, you will need to assume root for the command with sudo, like this:

sudo chgrp accounts filename

You can change owner and group in a single chown command by specifying the owner followed by a colon and group name:

sudo chown mary:accounts filename

That said, if you ever have a lot of work to perform as root or have a specific reason to do so, you can actually log in as root (and also bypass typing all the sudo commands) by entering the following:

sudo -i

This will log you in as the root user with all the dangers previously discussed, so don’t do this unless you know exactly what you are up to. To log back out again, enter the command exit.

For more information on sudo, as with all commands, enter the following:

man sudo

You can also search through the running processes using the ps command (generally using the options -ax to display all processes) and can terminate any of them using the kill command. For example, to kill a process with the process ID of 7662, you would enter:

kill 7662

This sends the process a signal requesting it to terminate. However, some processes may refuse (or be unable) to act on this signal, in which case wait a few seconds and try it again. If it still fails, you may need to reboot your computer. But before you give up and reboot your computer, try using a more powerful kill signal:

kill -9 7662

Again, please be aware that you should not issue such commands lightly, and ought to do so only if you know what you are up to or if a bona fide expert has suggested you do so.