UNIX/Linux Tutorial

For further information on the Linux operating system, I highly recommend the following:

• Running Linux by Matt Welsh and Lar Kaufman. This book takes you through the setup, management and use of Linux.
• Linux in a Nutshell by Jessica Perry Hekman. This is a good quick reference for commands and environment settings.

Multi-user vs. Single-user

Now, if the system has multiple users, we have to have some way of telling it who we are. We also have to make sure someone can't impersonate someone else and get access to their files. This is accomplished through the login procedure.

Logging In

At this point, depending on how the system administrator has set things up, you may be presented with a windows-like (usually X-windows) environment or a simple terminal. Either way, you should now have a screen where you can type in commands. This is your shell. Your shell is your interface to the operating system (in DOS, your shell was called COMMAND.COM). Since UNIX is a multi-tasking as well as multi-user environment, you can have many shells running at the same time. To further complicate things, there are several different shells you can use. The default shell on Linux is bash (stands for Bourne Again SHell). Others include csh, tcsh, ksh and sh. They all serve the same purpose, but each has different features and syntaxes. As far as this tutorial is concerned, they more or less work the same, however I will assume you are using bash.

Important: When you are all done, remember to log out of the system. This is usually accomplished by typing logout at the prompt. If you are using X-Windows, there will be a large button at the bottom of the screen labeled 'Logout'. You will know you have logged out completely when you see the login prompt. If you forget to log out, someone else could come along and mess with your files, or send email from your account!

Executing commands

Now that everything is nice and secure, let's have a look at what UNIX and bash have to offer us as an environment. When you log in to the system, you are usually deposited in your home directory. As we said above, this is a directory that you own and which you can write to. To find out where this directory is on the system, try using the pwd command. This will output the directory you are currently sitting in. Here's an example for my account on a computer called mandragona:

 mandragona ~ $ pwd
 /u/burns
 mandragona ~ $

The command pwd and passwd are relatively simple commands in that we didn't supply any arguments. Most commands in UNIX need arguments to function. Keeping track of what arguments a command requires takes a very good memory, especially for seldom-used commands or features of a command. That's why UNIX has an on-line summary of each command, called man pages. To access the man page for a particular command, just execute: man [command]. For example:

 mandragona ~ $ man pwd

PWD(1L)                                                   PWD(1L)


NAME
pwd - print name of current/working directory

SYNOPSIS
pwd
pwd {--help,--version}

DESCRIPTION
This  manual  page  documents the GNU version of pwd.  pwd
prints the fully resolved name of the  current  directory.
That is, all components of the printed name will be actual
directory names -- none will be symbolic links.

Note that most Unix shells provide a built-in pwd  command
with  similar  functionality so the unadorned, interactive
pwd command will usually execute the built-in version  and
not this one.

OPTIONS
--help Print  a  usage message on standard output and exit
      successfully.

--version
      Print version information on standard  output  then
      exit successfully.

FSF                    GNU Shell Utilities                      1

 $ man bash

The Filesystem

D:\SUBDIR1\SUBDIR2\FILE.EXT

/cdrom/subdir1/subdir2/file.ext

We said above that each file and directory has an ownership and permissions attached to it. To see what they are, you use the ls command. ls provides the same information as dir in DOS. However, to make ls show us more than just the file names, we need to give it a -l switch. A switch is simply an argument which modifies the behaviour of a command. Switches usually consist of a dash (-), followed by one or more characters. If you execute the following statement:

 $ ls -l .bash_profile

 -rw-r--r--   burns   users   512 .bash_profile

Let's take a look at the permissions. This field consists of 10 characters. The first is reserved for special file attributes, such as "d" to indicate the file is a directory. The next three characters are the permissions associated with the owner of the file. In the above example, rw- means the owner of the file can read, write, but not execute the file. If we wanted the owner to be able to execute the file, we could use the chmod command (more about this later). If we used this command, the permissions of the owner would then be rwx.

The next three characters in the permissions field work the same as for the first three, but they apply to users who are in the group specified by the ls -l command. In the case above, this would be the group users. It is possible for one person to be a member of many groups. To find out which group(s) you belong to, simply invoke the groups command. Having groups as well as simple users can be very useful. Many users may be working on the same bit of code, for example, so they all need read/write access to the source code while making sure no one else can touch it.

The last three permission characters work the same as the owner and group ones, but these apply to every user on the system. Consider the command ls. If only one person on the system could execute this command, it would make things very difficult for other users. Also, we wouldn't want anyone to mistakenly delete the ls command (in UNIX, there is generally no undelete!). Therefore we can expect that the executable file ls will have permissions as follows:

 -rwxr-xr-x   root   bin   45984 /bin/ls

User Commands and Environment Variables

Environment variables are just like variables in the sense of programs. In bash, you set an environment variable using the following syntax:

$ [VARIABLE]=[value] 
$ export [VARIABLE]

$ X=.bash_profile      ;#  No spaces before or after the =
$ echo $X
.bash_profile
$ ls -l $X
 -rw-r--r--   burns   users   512  .bash_profile

As an example of how environment variables and commands work together, consider the lpr command. This sends a file to a printer. Since we are most likely set up on a network, there can be many printers to choose from. We select the appropriate printer using a switch:

 $ lpr -P[printer name]

If you want an environment variable to be set every time you log in automatically, you need only edit your .bash_profile file and put the variable assignment statement somewhere in the file on a line by itself. .bash_profile is like AUTOEXEC.BAT in DOS. All the lines in .bash_profile, except those beginning with a '#', are executed at login time.

Now let's look at the most common user commands and what they do. The easiest way to do this is to give you a table containing the name, function and possible DOS equivalents. It is up to you to look at the man pages for the commands to see what more they can do for you.

Command	Function	DOS Equivalent
bash	Run the Bourne Again Shell.	COMMAND.COM
cc	C compiler. This is available on most systems. There are many switches to modify the behaviour of cc. See the man pages for more details.	GCC
cd [directory]	Change to directory [directory].	CD
chfn	Change User Information
chmod [args] [file]	Change permissions of [file].  [args] consists of 3 characters.  The first is u, g or o (user, group or other).   The second is + or -.  The third is r, w or x (read, write or execute).	ATTRIB
chown [user].[group] [file]	Change ownership of [file] to the user [user] and group [group].
clear	Clears the terminal	CLS
cp [file1] [file2]	Copy [file1] to [file2]	COPY
df	Prints out the amount of free disk space on each partition currently mounted	chkdsk
diff [file1] [file2]	Print out the differences between [file1] and [file2]	COMP
echo	Prints out its arguments, doing variable substitution.	ECHO
env	Prints out environment variables	SET
expr [formula]	Performs numerical computation, using numbers, environment variables and operators.   See man pages for syntax.
find [path] [conditions]	Tool to locate files below the [path] subdirectory tree. There are many [conditions], including file names, dates, sizes, etc.
finger [user]	Display information about [user]. Can be a user on the current machine, or on another machine, using the user@hostname syntax
grep [regexp] [file(s)]	grep searches the names [files] for occurrences of [regexp], printing each line containing it.
gzip [file]	Compress [file], renaming it [file].gz.	PKZIP
less [filename]	Print out [filename] one page at a time, prompting the user at the end of each page.	MORE
lpr	Send files to a printer	PRINT
ls [options]	List the contents of a directory. Lots of switches to control information printed out.	DIR
logout	Log out of the current shell. Usually exit will do the same thing.	EXIT
mail	Interactive mail tool. See man pages
man [command]	Print out man pages on specified [command].	HELP
mkdir [name]	Make the subdirectory [name]	MD
passwd	Change your password.
pwd	Show current directory.
rlogin [host]	Log into a remote [host]	TELNET
rm [file]	Remove (delete) a [file]. CAUTION: Once deleted, a file is gone for good (unless it is backed up somewhere). There is no undelete command.	ERASE
rmdir [directory]	Remove (delete) a [directory].	RMDIR
sh	The Bourne Shell. This is the standard shell, of which bash is a derivative.	COMMAND.COM
sort	A very useful utility for sorting files.   See man pages for all the options.
tcsh	A derivative of the csh shell	COMMAND.COM
telnet [host]	TELNET to a remote [host]. Similar to rlogin.	TELNET
top	Displays the most CPU-intensive jobs currently running. Type 'q' to exit.
vi	The Visual Editor. This is the standard editor in UNIX (i.e., it is guaranteed to be available). Emacs is the other commonly used editor. See next section on using vi.	EDIT
w	Displays information about the system, including all currently logged in users.
wc [file]	Word count. Prints the number of characters, words and lines in [file].
write [user]	Initiate a write session to [user]. If [user] is logged in and is accepting messages, whatever you write to your terminal after this command will appear on [user]'s terminal. Type Ctrl-D to terminate the session.

There are many other commands besides the ones mentioned above. If you need to get something done that seems non-standard, before you go and write a C program to do it, poke around and make sure there isn't a command that will do the same thing!

Job Control

find / -name "ls" -print -xdev > stdout.txt 2> stderr.txt

$ find / -name "ls" -print -xdev > /dev/null 2> /dev/null &
[1] 4564
$ 

If you don't remember what id number your process has, simply use the ps command, which gives you information about your running jobs, including their process id numbers (PID). top is also a useful command: it lists the most CPU-intensive jobs currently running. Hit 'q' to exit from top.

If you've started a job without using the ampersand (&), you can still put it in the background. To do this, first you suspend the job by hitting < CTRL-Z >. This suspends the job and returns control to you. You then type the bg command, which will let the job resume in the background.

If you have written a lengthy bit of code (which you will be doing later on) that will take a long time to run, you can run it in the background and then logout of the system. Your job will continue to run without you. However, if it is a particularly intensive job, you will likely inconvenience other users, since the system will be more sluggish. To get around this, you use the nice command. This tells the system that your job should have less priority. Simply type nice -# followed by your command. # indicates the priority level you wish to assign to your job. On Linux, # ranges from 0 (highest priority) to 19 (lowest priority).

I/O Redirection

The first thing to realize is that although the standard output and error messages are both being written to the screen, they are not the same output stream; therefore it is possible to differentiate them. We've seen a glimpse of this already with the find command:

find / -name "ls" -print -xdev > stdout.txt 2> stderr.txt

While output redirection is very nice, UNIX also allows for input redirection as well. Consider the command wc. If we create a simple file (here we get to use output redirection):

$ echo "This is a simple text file" > simple.txt 

$ wc simple.txt
      1       6      27 simple.txt
$ wc < simple.txt
      1       6      27

'So what?', you might ask. By itself, this does not seem like such a great thing. However, it gives us considerable power when you want to do complicated things. Suppose (for some reason) I wanted to know how many files there are in the directory /usr/bin which contain the string 'ls' in their names. I could go and count them by hand. Or I could use the commands which are already available to me. However, there is no one program which will do this. But if I could somehow redirect the output of one command to the input of another, maybe several small programs can do the job together. The command ls will list all files. The command grep [string] will only print out lines which contain [string] and the command wc will count up lines. So, we can do the following:

$ ls /usr/bin | grep ls | wc
      6       6     106 

The vi Editor

Vi has essentially 2 modes. When you enter vi, you are usually in the command mode. In this mode, you can enter commands, move around, or enter one of the input modes. You can't start typing away, as you might expect, because in command mode, the letters you type are actaully commands.  For instance, typing dd will delete one entire line of text.

To move around in command mode, you can usually use the cursor keys the way you would expect. If this doesn't work, you can fall back on the h, j, k and l keys. Use h and l to go left and right, respectively. Use k and j to move up and down, respectively. Here are some more movements you can do in command mode:

h,j,k,l         Left, up, down, right one character
w, b            Forward, back one word
), (            Go to beginning of next, current sentence
0, $            Go to beginning, end of the current line
^               First non-blank character
Ctrl-F, Ctrl-B  Scroll forward, backward one screen
Ctrl-D, Ctrl-U  Scroll forward, backward half a screen

a               Append after the cursor position
A               Append at the end of the line
i               Insert before cursor
I               Insert at beginning of line
o               Open a line below cursor
O               Open a line above cursor
R               Begin overwriting at cursor position.

:#              Go to line #
:e [file]       Edit [file]
:help           Get help (only in vim)
:r [file]       Read in [file] and insert it at the cursor
:w [file]       Write to [file].  :w saves to the current file
:wq             Save the current file and exit
:q!             Do not save the current file and exit

Putting it all Together

~ $ mkdir src
~ $ cd src
~/src $ mkdir first
~/src $ cd first
~/src/first $

/*  A simple program which prints out a message  */

#include <stdio.h>

main()
{
   printf("Goodbye World!\n");
}

~/src/first $ ls
first.c
~/src/first $

 ~/src/first $ cc -o first first.c

Let's suppose you really like the executable file you've just produced and would like to be able to run the file from no matter what directory you are currently in. All you have to do is make sure that the file is somewhere in your path. Your path is a list of directories where the shell will look for executable files. To see what your path is currently set to, just type echo $PATH. The elements in the list are seperated by colons (:). You can add a directory to the path by typing:

 $ export PATH="$PATH:[new directory]"

If everything works, congratulations! Go have a coffee. You're on your way to becoming a UNIX guru.