Basic Unix for Computer Science Students

Basic Unix Commands

To see the contents of your current directory, type
```
	ls
```
To go to a new directory, use the cd command
cd stands for change directory
Follow cd with the name or address of the directory you want to enter
```
	cd  NAME_OR_ADDRESS_OF_DIRECTORY
```
A directory is the same thing as a folder
Whenever you go to a new directory ...
its a good idea to look at the contents of that directory ...
using the ls command
The pwd command will tell you your current directory
Use pwd without any arguments
```
	pwd
```
pwd stands for print working directory
Use pwd whenever you are not sure of your current directory
To create a new directory, use mkdir followed by the directory name
```
	mkdir  DIRECTORY_NAME
```
To remove a file, use rm
```
	rm  FILENAME
```
rm stands for remove
To removed a directory user rmdir
```
	rmdir  DIRECTORY_NAME
```
The directory must be empty or rmdir will not work
To move a file use mv
```
	mv  FILENAME  NEW_DIRECTORY
```
mv stands for move
You also use mv to change the name of a file or directory
```
	mv  CURRENT_NAME  NEW_NAME
```
To see the contents of a file use cat
```
	cat FILENAME
```
cat stands for concatenate
Check the Unix Essentials page for more information

Your Home Directory

Whenever you log in to a Unix host, you will always find yourself in your home directory
This a directory that belongs to your Unix account only
You have full control of permissions within this directory
If you use cd with no arguments, it will take you to your home directory:
```
	$ cd
$ pwd
/home/ghoffman
```
Your home directory contains a number of hidden files which customize your environment, like .forward
On most Unix systems, home directories will be located inside the /home directory
On a Mac, home directories appear inside /Users

Any file or directory in the filesystem will be one of four positions relative to your current directory
It can be inside your current directory
It can be below your current directory
It can be above your current directory
It can be off to the side of your current directory
In this last case, you must go up before you can go down to reach this file

Hidden Filenames

A file whose filename begins with a period (.) is a "hidden" or "invisible" file
ls does not display these files unless you use the -a option
You have already encountered such files in the .forward and .plan files
Two special hidden files . and .. appear in every directory:
```
$ ls -a
.  ..  hw3  work
```
We'll discuss them shortly

The . and .. Directory Entries

Every directory has at least two entries . and ..
When a new directory is created, these are the first two entries
. stands for the current directory
.. stands for the parent directory of your current directory
.. is the directory immediately above your current location:
```
	$ pwd
/home/ghoffman
$ cd ..
$ pwd
/home
```
. is most often used in two circumstances
- To run a program in your current directory
- To move or copy a file to your current directory
```
	$ ls
it244  notes.txt  work  work2
$ cd work
$ ls
bletch.txt  foo.txt
$ cp ../notes.txt .
$ ls
bletch.txt  foo.txt  notes.txt
```

Pathnames

Every file has a pathname which is used to access the file
A pathname has two components: the name of the file and a path to reach the file
A pathname is like an address on a letter: a name and directions to get there
The name of the file is always at the end of a pathname
What comes before the filename is the path to the directory that holds the file
Within a pathname, a slash (/) to the right of a name indicates that the name refers to a directory
When a path consists of several directories, a slash (/) separates the names of each directory
There are two types of pathnames: absolute and relative

Absolute Pathnames

The top of the filesystem is called the root
The root is represented by a single slash character (/)
It can stand alone or appear as the first character before a directory name
An absolute path is a list of directories, starting with the root, and ending with the directory that contains the file
When you add the filename to the end of an absolute path, you have an absolute pathname
For example, the absolute pathname of the .bash_profile file in my home directory is /home/ghoffman/.bash_profile
This means that my home directory, "ghoffman", is under the directory named "home", which, in turn, is under root (/)
The advantage of an absolute pathname is that it can be used from any part of the filesystem
It does not depend on your current directory
The disadvantage is that absolute pathnames tend to be long
It is easy to make a mistake typing an absolute pathname
An absolute pathname always begins with either a slash (/) or a tilde (~)

Tilde (~) in Pathnames

There is one form of absolute path that is very short
This is the tilde character (~)
Tilde stands for your home directory
This means you can use tilde (~) anywhere you would normally use a path to your home directory:
```
	$ pwd
/home/ghoffman/it244
$ cd ~
$ pwd
/home/ghoffman
```
When you put a tilde in front of a Unix ID, it stands for the home directory of that account:
```
	$ cd ~fsayed
$ pwd
/home/fsayed
```

Relative Pathnames

Absolute pathnames are useful because you can use them anywhere
But they are long and easy to mistype
For most purposes, it is easier to use relative pathnames
In a relative pathname, the path starts from your current directory
In an absolute pathname, the path starts from the root (/)
While all absolute pathnames start with a slash (/) or a tilde (~), relative pathnames never do
The absence of a slash (/) or a tilde (~) from a pathname, means it is a relative pathname
As far as Unix is concerned it makes no difference whether you use and absolute or relative pathname
Relative pathnames are more convenient and are most often used
There are four types of relative pathnames:
- When the file is in your current directory
- When the file is in a subdirectory of your current directory
- When the file is in a directory that is an ancestor of your current directory
- When the file is in a directory that is neither an ancestor or descendant of your current directory

Relative Pathnames in Your Current Directory

Using a relative pathname with a file or directory inside your current directory is easy
The relative pathname simply consists of the name of the file or directory
The "path" part of the relative pathname is empty because what you want to access already inside your current directory:
```
	$ ls
notes.txt  it244  work  work2
$ cat notes.txt 
foo
foo
foo to you
```
Notice that all I need to access the file is the file name
It's the same for directories

Relative Pathnames in a Subdirectory

Things get a little more complicated when you are dealing with a file in a subdirectory
Here, you must list every directory between your current directory and the file you want:
```
	$ ls work
bletch.txt  foo.txt  notes.txt
$ cat work/notes.txt 
foo
foo
foo to you
```
You must use a slash (/) to separate the names of each directory
Notice that there is nothing, no slash (/) or tilde (~) before the name of the first directory in the path

Relative Pathnames above the Current Directory

When the file or directory is above the current directory you can't list the directory names
Instead, you have to use the special .. entry in each directory
Use one .. for each directory up the chain of directories in the path with a slash (..) between each ..
```
	$ pwd
/home/it244gh/work
$ ls ../..
it244gh  jharris  mphamman
```

Relative Pathnames Neither above Nor below the Current Directory

What if the file is neither above nor below?
Here you have to go up to a common ancestor directory and then go down to the directory that holds the file
The path starts with one or more ..
You keep going up until you get to a directory that is an ancestor of your current directory and the file you are trying to reach

Once you get to the common ancestor, you go down to the directory that holds the file:

	$ ls  ../../../courses/it244/f12/ghoffman/
aavelar   dshiels  GROUP     jharris   mascary   rroessne  tpham
akeita    erikb    hstevens  jmit      mng       sarjo     zdedo
clin      estasi   it244gh   justinb1  mphamman  tchonden
cmanuel1  estasio  jasonlam  lvilla    oyagan    tkellz
coreygra  fsayed   jchan91   MAIL	  rnowak	tnguyen

Shell Variables

A variable is a name that has been given a value
Shell variables are variables that can be used in the shell

To get the value of a variable put a dollar sign ($) in front of its name:

	$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

Some variables are set and maintained by the shell itself
They are called keyword shell variables
Or just keyword variables
Most of these variable are defined in /etc/profile
Many of these keyword variables can be changed by the user
Other variables are created by the user
They are called are called user-created variables
The environment in which a variable can be used is called the scope
Shell variables have two scopes:
- Local
- Global

Local Variables

Local variables only exist in the shell in which they are defined
To create a local variable, use the following format:
```
	VARIABLE_NAME=VALUE
```
There cannot be any spaces on either side of the equal sign when setting bash variables
Here is an example:
```
	$ foo=Foo

$ echo $foo
Foo
```
Variables are local unless you explicitly make them global
If the value assigned to a variable has spaces or tabs, you must quote it:
```
	$ hello="Hello there'

$ echo $hello
Hello there
```
Local variables only exist in the shell in which they are created

Global Variables

Global variables defined in one shell maintain their values in all subshells created by that shell
Global variables are defined in bash by preceding the variable definition with the keyword export:
```
	$ echo $foo
Foo

$ export foo=FOO

$ echo $foo
FOO
```
Usually, global variables are declared in a startup file like .bash_profile or .bashrc

The env command, when used without an argument, displays the values of global variables:

	$ env
TERM=xterm-color
SHELL=/bin/bash
SSH_CLIENT=66.92.76.9 53785 22
OLDPWD=/home/it244gh
SSH_TTY=/dev/pts/8
USER=it244gh
...

Keyword Shell Variables

Keyword shell variables, or keyword variables, have special meaning to the shell
They have short, mnemonic names
When you start a shell, that shell inherits several keyword variables from the shell that created it.
By convention, the names of keyword variables are always capitalized
Most keyword variables can be changed by the user
This is normally done in the startup file .bash_profile

User-created Variables

User-created variables are any variables you create
By convention, the names of user-created variables are lower case:
```
	$ foo=Foo

$ echo $foo
Foo
```
User-created variables can be either local or global in scope

The PATH System Variable

When you run a program by entering a pathname, such as /usr/bin/php, the shell has no difficulty finding the executable file
How can the shell know where to find a program file if all it gets is the command name?
Programs can be stored anywhere in the filesystem, so how does the shell find the correct file?
The answer is it checks a system variable called PATH
PATH contains a list of directories to search for an executable file
The shell searches each of these directories in turn until it finds an executable file with the name of the command
PATH always has a default value which is created when the system is installed

Here is the default value on it244a:

	$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

The absolute pathname of each directory is separated from the next by a colon (:)
If the shell reaches the end of the directory listings in PATH without finding the command, it will display an error message
If the shell finds an executable file but you do not have execute privileges, it will tell you this in an error message
You can modify the PATH variable in your own Unix environment

Access Permissions

All Unix files and directories have access permissions
The access permissions allow the owner of a file or directory ...
to decide who gets to do what with that file or directory
By default, the owner of a file or directory is the user account that created it
Every file, directory or device on a Unix filesystem has three types of permissions:
- Read
- Write
- Execute
If you have read permission on a file you can look at the data in the file
You can run cat, more or less on these files
If you only have read permission, you cannot change a file
To change a file you need write permission
To run a program you must have execute permission
Each of the three permissions are set either on off to three classes of users:
- The owner
- The group
- Every other Unix account
Every file or directory has an owner
A group is a collection of Unix accounts
A group can only be setup by a system administrator
Every file or directory is assigned to a group
The last class of users is any account that is not the owner or a member of the group
Unix calls this class of users "other"

Viewing Permissions

To view the permissions of a file or directory use ls -l:

	$ ls -l
total 5
-rw------- 1 it244gh libuuid 316 2011-09-20 21:32 dead.letter
lrwxrwxrwx 1 it244gh libuuid  34 2011-09-06 13:21 it244 -> /courses/it244/s12/ghoffman/it244gh
drwx------ 2 it244gh libuuid 512 2011-09-07 15:03 mail
drwxr-xr-x 2 it244gh libuuid 512 2011-09-25 15:48 test
-rw-r--r-- 1 it244gh libuuid  15 2011-09-20 16:18 test.txt

The character in the first column indicates the type of file
A dash (-) means an ordinary file
The letter "d" indicates a directory
The letter "l" indicates a link, which we will discuss in the next class
The next three characters indicate the permission of the owner
"r" means the owner has read permission
"w" means the owner has write (change) permission
"x" means the owner has execute (run) permission
"-" means the owner does not have the permission that would normally appear in this column
The next three characters indicate the permissions of the group
The last three characters are the permission of all other accounts
After the permissions is a number that indicates the number of links to the file or directory
The following column is the owner of the file or directory
Next, you will find the group assigned to the file or directory
Following this is the size of the file in bytes
Next is the date and time the file or directory was created or last modified
The last column is the name of the file or directory

`chmod`

When a file is created, is has certain default permissions:

	$ touch test.txt
$ ls -l test.txt 
-rw-r--r-- 1 it244gh libuuid 0 2012-09-17 14:40 test.txt

To change these permission, you need the chmod (change mode ) command
Only the owner of a file can do this
chmod requires two arguments
- The permissions you want to grant
- The name of the file(s) or directory(s) to which the change will be applied
The permission can be specified in two ways
- Symbolically
- Numerically
Symbolic permissions use letters and the plus and minus signs
The numeric form uses three digits running from 0 to 7
Though the symbolic format seems simpler ...
I have found most students do better with the numeric format
The numeric format is initially confusing
But in my experience, it is the better way to go

Using `chmod` with Numeric Arguments

The numeric permissions format uses three digits
Each digit is a number from 0 to 7
The first digit gives the permission of the owner
The second digit gives the permissions assigned to the group
The third digit gives the permissions for every other account
Each of these classes of users must be assigned values for read, write and execute permissions
How do you get three pieces of information out of one number?
By adding powers of two
Each digit is the sum of three other numbers
When constructing the number you add:
- 4 if you want to give read permission
- 2 if you want to give write permission
- 1 if you want to give execute permission
Notice that all the number are powers of two
If we write these values in binary notation:
- 100 represents 4
- 010 represents 2
- 001 represents 1
A single decimal digit from 0 to 7 is represented by 3 binary digits
This is how we get three pieces of information out of one digit
For example, to give full permissions I would add
- 4 for read permission
- 2 for write permission
- 1 for execute permission
So the total, 7, represents all three permissions
Let's look at some other digits
6 in binary is 110
The leftmost digit is 1 indicating read permission
The center digit is 1 indicating write permission
The last digit is 0 indicating that execute permission is not granted
5 in binary is 101
The first digit is 1 so read permission is granted
The second digit is 0 so write permission is not granted
The last digit is 1 so execute permission is granted
This scheme is confusing when you first encounter it
But it becomes easier as you use it

Try to remember this chant:

	4 2 1
read  write execute
owner group everyone

Repeat this to yourself several times and it should sink in
Remember that you need three of these digits to specify the full permissions for a file or directory
Let's look at some examples

When you create a new file, it will have certain default permissions

	$ touch foo.txt
$ ls
foo.txt
$ ls -l
total 0
-rw-r--r-- 1 it244gh libuuid 0 2012-02-09 15:51 foo.txt

The owner can read and write the file, but not execute it
The group and everyone else can only read the file

To make the file unreadable to everyone except the owner:

	$ ls -l
total 0
-rw-r--r-- 1 it244gh libuuid 0 2012-02-09 15:51 foo.txt
$ chmod 600 foo.txt 
$ ls -l
total 0
-rw------- 1 it244gh libuuid 0 2012-02-09 15:51 foo.txt

To change the file back to its default permissions:

	$ ls -l
total 0
-rw------- 1 it244gh libuuid 0 2012-02-09 15:51 foo.txt
$ chmod 644 foo.txt 
$ ls -l
total 0
-rw-r--r-- 1 it244gh libuuid 0 2012-02-09 15:51 foo.txt