Learning Linux

Linux - Changing Directories with the 'cd' Command

2009-10-16T10:56:00.001-07:00

Linux – Changing Directories with ‘cd’ Command

Changing directories is likely the second most common command in Linux aside from ‘ls’. Using the ‘cd’ command, you can change your current working directory.

Recall the ‘pwd’ command prints your current working directory.

Also, it is important that you understand the use of the following,

· ‘..’- Parent directory

· ‘.’- Current directory

· ‘~’- Home directory

Examples

Change to your home directory using ‘cd’,

$ pwd

/home/fred/folder1

$ cd

$ pwd

You can also use ‘cd ~’ to change to your home directory,

$ pwd

/home/fred/folder1

$ cd ~

$ pwd

/home/fred

Change to a subdirectory,

$ pwd

/home/fred

$ cd folder1/myfiles

$ pwd

/home/fred/folder1/myfiles

The above cd command is the same as ‘$ cd ./folder1/myfiles’, however the ‘./’ is not necessary.

Change to the parent directory using ‘cd ..’,

$ pwd

/home/fred/folder1/myfiles

$ cd ..

$ pwd

/home/fred/folder1

Change to a directory in the parent directory,

$ pwd

/home/fred/folder1

$ cd ../folder2

$ pwd

/home/fred/folder2

Linux Commands - Viewing the Current Directory 'pwd' and 'ls' | Linux - Finding A File

Linux - File Permissions and the 'chmod' Command

2009-10-11T02:46:00.000-07:00

Linux – File Permissions and the ‘chmod’ Command

Linux was designed to be a multi-user operating system. So there must be a way to limit who has access to what files, and how much access.

There are three sets of users in linux,

· User-this is an individual, such as yourself, that has login credentials to the system. Each user has their own home directory where they have full access to the files.

· Group-this is a set of multiple users. A group is typically created by the system admin. For instance, at a university, there could be a group setup for each course, where the professor is the group leader, and students are group members.

· Other-this refers to individuals that are not the user and not in the group being discussed.

Linux uses file permission attributes to set who has access to what files. Type in 'ls -l' in any directory with at least one file in it. This will show you all the information about each file/directory.

$ ls -l
drwxr-x--- 1 jdoe jane 4096 Dec 28 04:09 tmp
-rw-r--r-- 1 jdoe jdoe 969 Dec 21 02:32 foo

Column	Value	Meaning
1	drwxr-x---	File Permissions
2	1	Forget this one!
3	Jdoe	Owner
4	Jane	Group owner
5	4096	Size in bytes
6	Dec	Last Modified Month
7	28	Last Modified Day
8	04:09	Last Modified Time
9	tmp	File Name

File Permission Attribute

Let's break down the 10 character file permission attribute in Column 1:

Special	User	Group	other
-	---	---	---

· Special attribute- This is blank(-) for normal files, but it is set to d for directories. This can be other letters for other devices etc, but do not worry about that now.

· 'user' permission- The user refers to the person who owns the file. So if you own the file, these characters apply to you.

· 'group' permissions- These apply to any user who is in the group owned by the group owner.

· 'other' permissions- These apply to any one who is not the owner, and who is not in the group owned by the group owner.

Read, Write and Execute

The user, group, and other permissions can have read(r), write(w), and or execute(x) permissions. The order of the permissions is 'rwx' for each permission set. Each permission attribute can either be on(r,w, or x) or off(-).

What does read, write and execute mean?

· Read(r)-the contents of the file/directory can be viewed.

· Write(w)-the file can be modified or deleted.

· Execute(x)-the file can be executed, or run. This only makes sense if the file is a program or script that does something. Also, having the execute permission for a directory means the directory can be cd'd into(eg. cd directoryName)

Examples

-rwxrwxrwx

All users have full access to this file.

-rw-r--r--

Owner has read, write access to the file. All other users have read access.

drwx------

This is a directory that the user has full access, while all other users have no access.

Changing the Permissions with 'chmod' Command

There are several ways to change the attributes with the chmod command. In my opinion, the easiest way to use chmod is as follows (you would insert file permissions after the equals sign, see examples below),

chmod u=,g=,o= fileName

Fittingly, u, g and o are as follows,

· u-user

· g-group

· o-other

If you leave out u,g or o, that attribute will not be modified.

chmod u=,g= fileName

Note: An error will occur if you put spaces between u=,g=.

Examples

$ chmod u=rwx,g=r,o=w foo
$ ls -l
-rwxr---w- jdoe jdoe 969 Dec 21 02:32 foo

Not including g will keep it the same as before,

$ chmod u=x,o=r foo
$ ls -l
---xr--r-- jdoe jdoe 969 Dec 21 02:32 foo

A blank after o will clear all attributes,

$ chmod u=rx,g=w,o= foo
$ ls -l
-r-x-w---- jdoe jdoe 969 Dec 21 02:32 foo

Using + and – to add and remove attributes

You can also use + and – to add and subtract attributes.

Examples

$ chmod u=wx,g=w,o= foo
$ ls -l
--wx-w---- jdoe jdoe 969 Dec 21 02:32 foo
$ chmod u+r-w,g-w+r,o+r foo
$ ls -l
-r-xr--r-- jdoe jdoe 969 Dec 21 02:32 foo

Using 3-digit octal value to set attributes

Lastly, you can specify the attributes with a 3 digit octal. Each of the user, group and other permissions have 3 attributes(rwx) that can be on or off, and as such can be thought of as a 3 bit word which is easily converted to an octal digit(0-7),

chmod (u#)(g#)(o#) fileName

· 0='---'

· 1='--x'

· 2='-w-'

· 3='-wx'

· 4='r--'

· 5='r-x'

· 6='rw-'

· 7='rwx'

Example

$ chmod 764 foo
$ ls -l
-rwxrw-r-- jdoe jdoe 969 Dec 21 02:32 foo

Previous - Finding A File | Next - Creating and Deleting Files and Directories

Linux - Bash Shell Scripting - Expressions and Substrings

2009-10-09T19:46:00.000-07:00

Linux - Bash Shell Scripting - Expressions and Substrings

Expressions

Sometimes in a script, you would like to evaluate an expression. For example, to find the sum of two variables. The expr command can be used to do this,

$ cat testsum.sh

#!/bin/bash

v1=12

v2=39

v3=`expr $v1 + $v2`

echo $v3

$ ./testsum.sh

Note that the expr command must be enclosed in backquotes `…` for this to properly work. Typing ‘man expr’ will display a help screen about the expr command.

Substrings

The expr substr command can be used to extract a substring from a string variable, e.g., this program prints the individual characters of a string stored in a variable v,

v="foobar"

len=`expr length $v`

for i in `seq 1 1 $len`; do

echo -n `expr substr $v $i 1`

done

echo

The syntax of expr substr is, 'expr substr string pos len' which will extract len characters from the string string starting at position pos. Note that the first character of the string string is at position 1.

Previous - For and While Loops

Linux - Bash Shell Scripting - For and While Loops

2009-10-09T19:26:00.000-07:00

Bash implements for, while, and until loops(not discussed).

For Loop
The basic syntax of the for loop is:

for var in list; do
   some commands
done

Note the semicolon; it is important to not omit it. The commands are executed once for every item in the list. The current item is accessed through the variable $var, e.g.,
Use VI to edit for.sh
--------------------------------
for i in 1 2 3 4 5 6 7 8 9 10; do
   echo -n "$i "
done
echo
--------------------------------
$ chmod 755 for.sh
$ ./for.sh
1 2 3 4 5 6 7 8 9 10

The option -n to echo means do not print a newline character after outputting the text.
Another example,

for i in $(ls); do
   echo $i
done

This script display the name of each of the files in the current directory one per output line. Another example,
Use VI to edit ls-dirs.sh
--------------------------------
for i in *; do
   if [ -d "$i" ]; then
      echo "$i [dir]"
   else
      echo $i
   fi
done
--------------------------------
$ mkdir foo1
$ mkdir foo2
$ chmod 755 ls-dirs.sh
$ alias ls-dirs=./ls-dirs.sh
$ ls
foo1 foo2 for.sh if.sh ls-dirs.sh
$ ls-dirs
foo1 [dir]
foo2 [dir]

The seq command (type man seq for help) can be used to generate an integer sequence. The syntax is, seq first increment last which will generate an integer sequence starting at first, incrementing by increment, and stopping at last. For example, Here is a loop which displays the first 100 odd integers,

for i in `seq 1 2 100`; do
   echo -n $i " "
done

Note that the seq command must be enclosed in backquotes `seq…` so the shell will execute it to generate the desired output. This loop prints the first 100 odd integers in reverse order,

for i in `seq 99 -2 1`; do
   echo -n $i " "
done

While Loops
The basic syntax of the while loop is,

while [ conditional-expression ]; do
   statements
done

I have ommitted examples as the while loop is used in a similar context to the for loop.

Previous - If Statements | Next - Shell Scripting Expressions/Substrings

Linux - Bash Shell Scripting - If Statements

2009-10-09T19:18:00.000-07:00

The syntax of the if statement is,

if [ conditional-expression ]; then

   some commands

fi

if [ conditional-expression ]; then
   some commands
else
   some other commands
fi

The character "[" actually refers to a built-in Bash command—it is a synonym for another command named test. The result of the conditional expression is 0 or nonzero with 0 being false and nonzero being true. Some examples,

Use VI to edit if.sh
--------------------------------
today=0
if [ $today = 1 ]; then
   echo "today = 1"
else
   echo "today <> 1"
fi
--------------------------------
$ chmod 755 if.sh
$ ./if.sh
today <> 1

Since using [ ] is equivalent to using test,

today=0
if test $today = 1; then
   echo "today = 1"
else
   echo "today <> 1"
fi

The test command has command line options for checking the status of files, e.g.,

test -d file

True if file is a directory

test -e file
True if file exists

test -r file

True if file exists and is readable

test -s file

True if file exists and has size > 0

test -w file

True if file exists and is writable.

test -x file

True if file exists and is executable

Multiple conditions can be checked using -a (and) and -o (or), e.g.,

if test -e if.sh -a -x if.sh; then
echo "if.sh is an executable"
else
echo "if.sh either does not exist or it is not an executable"
fi

In a schell script, the ! symbol is used as the NOT logical operator, e.g.,

if [ ! -d src ]; then
   echo '"'src'"' does not exist, creating directory.
   mkdir src
fi

To learn more about conditional expressions I suggest you try $ man test.

Previous - Variables in Output | Next - For and While Loops

Linux - Bash Shell Scripting - Variables in Output

2009-10-09T19:08:00.000-07:00

The output of a command can be assigned to a variable,

VarName=$(command)

#!/bin/bash
LS_OUT=$(ls)
echo $LS_OUT

Or

#!/bin/bash
#the 'date' command retrieves the current date(many options)
DOW=$(date +%a) #get day of week
MONTH=$(date +%b)
DAY=$(date +%d)
YEAR=$(date +%Y)
echo "Today is ${DOW} ${MONTH}-${DAY}-${YEAR}"
$ alias today="./today.sh"
$ today
Today is Wed Oct-17-2007

Previous - Reading From Keyboard | Next - If Statements

Linux - Bash Shell Scripting - Reading From the Keyboard

2009-10-09T19:04:00.001-07:00

To read a string from the keyboard and store it in a shell variable use the read command, e.g.,

#!/bin/bash
echo "Enter your name: "
read name
echo "Pleased to meet you $name."

Previous - A Simple Backup Script | Next - Variables in Output

Linux - Bash Shell Scripting - A Simple Backup Script

2009-10-09T19:03:00.000-07:00

This script will tar and compress the files in the specified directory which is located beneath the current directory,

#!/bin/bash
# usage: bu dir
tar cvf $1.tar $1a
bzip2 $1.tar
mv $1.tar.bz2 mybackups
echo "$1 backed up."
$ bu src
src backed up.
$ ls mybackups
src.tar.bz2

Previous - Displaying Text | Next - Reading From Keyboard

Linux - Bash Shell Scripting - Displaying Text from a Shell Script

2009-10-09T19:01:00.000-07:00

An executing script can display text on the console window using the echo command. For example,

#!/bin/bash
# usage: rmwild dir pattern
dirname=$1
pattern=$2
echo "Removing all $2 files from $1..."
cd $dirname
rm $pattern 2> /dev/null
echo "Done."
$ ls tmp
file1.c file1.o file2.c file2.o
$ rmwild tmp *.o
Removing all *.o files from tmp...
Done.
$ ls tmp
file1.c file2.c

Previous - Aliases | Next - A Simple Backup Script

Linux - Bash Shell Scripting - Aliases

2009-10-09T18:57:00.000-07:00

An alias is another name for something. In Bash, you can define aliases for commands using the syntax alias name=command. In this example, assume rmwild is a user-created program,

$ alias rmwild="./rmwild"
$ rmwild tmp *.o
$ alias gohome=cd ~
$ pwd
/usr/bin
$ gohome
$ pwd
/home/fredf

Aliases defined on the command line only exist for the current Bash session. If you want the alias name to be available every time you log in, define the alias in your .bashrc file. To delete an alias that was defined at the command prompt, use the unalias command, e.g., unalias rmwild. To delete all of your aliases, type unalias -a.

Pre vious - Command Line Arguments | Next - Displaying Text from Shell Script

Linux - Bash Shell Scripting - Command-Line Arguments

2009-10-09T18:50:00.000-07:00

When a Bash shell script is launched, arguments may be passed to the script, e.g., as in $ ./mymake.sh foo bar install. Here mymake.sh is the name of the shell script file, and foo, bar, and install are arguments. Special shell variables, $0, $1, $2, …, are used to refer to the command line arguments. The variable $0 refers to the name of the shell script (./mymake.sh), $1 the first argument (foo), $2 the second argument (bar) and so on. $# is the number of command line arguments following the script filename. Our script above can be rewritten,

#!/bin/bash

# usage: rmwild dir pattern

dirname=$1

pattern=$2

cd $dirname

rm $pattern

$ ./rmwild tmp *.o

Previous - An Example | Next - Aliases 

Linux - Bash Shell Scripting - An Example

2009-10-09T18:44:00.000-07:00

A script file can contain regular Bash commands, e.g., rm, cp, mv, ls, etc. A script file can also define variables and assign them values. As we will see shortly, the Bash shell programming language is quite sophisticated and allows if statements, loops, and procedures. Here is a sample shell script which moves to directory tmp and deletes all of the .o files (the script file is named rmo.sh),

#!/bin/bash
# usage: rmo
mv tmp
rm *.o
$ ./rmo.sh
./rmo.sh: Permission denied

The shell script failed to run because shell scripts are not executable files by default. To make the shell script file executable, you must change the permissions using the chmod command to add x,

$ ls -l rmo.sh
-rw-r--r-- 1 jdoe jdoe 122 Oct 17 11:35 rmo.sh
$ chmod 744 rmo.sh
$ ls -l rmo.sh
-rwxr--r-- 1 jdoe jdoe 122 Oct 17 11:35 rmo.sh
$ ./rmo.sh

A slightly more sophisticated program might use variables,

#!/bin/bash
# usage: rmo
dirname=tmp
pattern=*.o
cd $dirname
rm $pattern

Here dirname and pattern are variables. Note that when the variable is assigned to (using =), we do not put a $ in front of the variable name, but we do use a $ when referring to the variable later on. If you don't, the shell will think that the variable name is the filename of a program to be executed and it will probably fail with an error message.

Previous - Arithmetic and Relational Operators | Next - Command Line Arguments

Linux - Bash Shell Scripting - Arithmetic and Relational Operators

2009-10-09T18:38:00.000-07:00

The standard operators are available as shown in the table (note: there are more operators than those shown here; read the Bash man page for more information about the complete set of operators).

Within an expression, the normal precedence rules are applied; in the table precedence is from highest (unary minus, plus) to lowest (logical or).

- +
Unary minus, plus

! ~
Logical negation, bitwise negation

**
Exponentiation

* / %
Multiplication, division, remainder

+ -
Addition, Subtraction

<< >>
Left and right bitwise shifts

> < >= <= Greater than, less than, greater than or equal, less than or equal

== !=
Equal, not equal

&
Bitwise and

^
Bitwise exclusive or

|
Bitwise or

&&
Logical and

||
Logical or

Variables can be assigned integer values using normal assignment, or using let, e.g.,

x=33

let y=12

let z = 95 # error

The last statement will cause the shell script to fail; there should be no spaces to
the left and right of the = operator. Expressions are evaluated by enclosing them
in $[ … ], e.g.,

x=33

let y=12

z=$[x/y]

echo $z

The above displays 2 (note integer division is performed).

Previous - Variables | Next - An Example

Linux - Bash Shell Scripting - Variables

2009-10-09T18:32:00.000-07:00

Shell variables are used to store values. A variable can be defined at the same time it is assigned by the = operator, e.g.,

LONG_NAME="Flintstone Fred"
SHORTNAME=Fred

Note in the first case that quotation marks are required because the string contains spaces. The backquote operator will execute the enclosed command and assign the output to the designated variable, e.g.,

LS_OUT=`ls`

When referring to the variable, its name must be preceded by $, e.g.,

X1=$Y2

Here we are assigning the value of Y2 to X1. Note that Y2 is preceded by $ whereas X1 is not.

You can declare numerical values too,

intA=5

Summary

Declare string

string1="string text"

Declare command

command1='ls'

Declare numerical value

intA=5
floatB=.5

Previous - Introduction | Next - Arithmetic and Relational Operators

Linux - Bash Shell Scripting - Introduction

2009-10-09T18:29:00.000-07:00

One of the more powerful features of Unix systems and the shells is the ability to write shell programs, i.e., programs which are executed by the shell interpreter in order to perform useful commands or perform some task. These programs are called shell scripts, scripts, or script files. Shell scripts are a way of automating commonly performed commands or a complex set of commands.

Complete books have been written about shell scripting, and it is not something we can cover in a few blog posts. This will be a basic introduction, and you are referred to the online guides and tutorials for more information.

A script file is a text file, and the first line is usually supposed to be

#!/usr/bin/env bash

if the shell script is designed to be executed by the Bash shell. If you are using a different shell to write your script (e.g., the Korn shell), then set the first line to point to the Korn shell's binary image (usually it is in the /bin directory; e.g., /bin/ksh). This will ensure that the correct shell is loaded and used to execute the shell script regardless of what particular shell the user may be running.

Note that in shell scripts, # lines are comments, just as // are comments in C++. Any character from the # symbol to the end of the line is ignored by the shell interpreter. Typically shell scripts are given a .sh extension to let the user know it is a shell script, but this is not necessary for it to run.

Summary

Shell scripts are text files that automate tasks. You can put any command in it that you can type in the shell prompt.
The commands will execute sequentially, just as in most programming languages.
All shell scripts must start with the location of the bash install, "#!/usr/bin/env bash, as the first line.
Lines beginning with # are comments.
Typically shell scripts are given a .sh extension to let the user know it is a shell script, but this is not necessary for it to run.

Next - Variables

Linux - Editing Files - Painless Introduction to VIM (vi)

2009-10-08T22:26:00.000-07:00

The VI editor60 is the standard editor available on most *nix systems. Some people who know it very well, love it. I don't know it very well; I don't love it. I've never taken the time to learn it very well because I would rather gouge my eyes out with infected hypodermic syringes found in the dumpster behind the plasma donation center until bloody pus oozes out of them than learn VI61; I simply do not have the time for it. Nonetheless, learning a bit of VI can be useful, if for nothing else, you may find yourself in a situation where it is the only editor that is available on the system you are on. At the least, knowing how to load a file, make some simple changes to it, and save it can be useful. The version of VI found on most GNU/Linux systems is Vim (VI Improved).

Starting VI

At the Bash command prompt, type vim or vim some-filename. VI is a modal editor in which you are either in editing mode(--insert--) or command mode().
$ vi filename

Getting out of VI

This is the most important thing you need to know about VI: how to get out of it. If you are in editing mode, hit ESC to enter command mode. Enter :wq to write your file and quit. To quit without writing the file, hit :q. If you really want to quit without saving the file you have made changes to hit :q!. To save the file under a different name, try :wq new-filename. You can also press ctrl-z to suspend the process

Switching Between Editing Mode and Command Mode

If you are in editing mode, hit ESC to enter command mode. If you are in command mode hit i to enter insert (editing) mode. If you cannot tell which mode you are in, trying hitting ESC several times to make sure you are in command mode, then type :set showmode. This may tell VI to let you know when you are in insert
mode (it depends on the version of VI you are using).

Other Useful Settings

All of these are recommended in addition to :set showmode. In command mode, type :set nocompatible to enable advanced VIM features. Type :set ruler to tell VI to display your current cursor position. Type :set number to display line numbers. It would be preferable if I were also on fire and being eaten alive by rabid hyenas at the same time. That would still be more pleasurable than using VI.

Moving Around a Character at a Time

The original VI was written by Bill Joy (at UC Berkeley) using a computer system and keyboard that lacked arrow, page up, and page down keys. This is the reason for the stupid assignment of the keys for moving around: h (move left one character), j (move down one line), k (move up one line), and l (move right one character). On Joy's terminal, these four keys also had arrow keys on them and that is the historical reason they are still mapped that way today.

Moving Around a Word at a Time

Forget about your Del and Backspace keys. They may or may not work. Switch to command mode. Press w to move forward one word. Press b to move backward one word. Press nw to move forward n words, e.g., 3w to move forward three words. Press nw to move backward n words.

Moving Around the File

Switch to command mode. To move to the end of the line, hit $. To move to the beginning, hit 0. Hit 1G to go the first line of text. hit nG to go line number n. Hit G to go to the end of file. To display line numbers, in command mode type :set number. Note that :13 is equivalent to, e.g., 13G. To page down, hit Ctrl+F. To
page up hit Ctrl+B.

Deleting Characters

Switch to command mode, move to the character you want to delete, and hit x to delete that character. To delete n characters hit nx, e.g., 17x to delete 17 characters. To delete all the characters from the cursor position to the end of the line hit D.

Copying a Line of Text

To copy a line of text from one place in the file to another, switch to command mode. Move to the line you want to copy. Hit yy (yank something or other, I dunno). Move the cursor to the location where you want to make the copy. Hit p (lowercase p) to put the copied line after the current line. Hit P (uppercase P) to put
the copied line before the current line.

Moving a Line of Text

To move a line of text from one place in the file to another, switch to commandmode. Move to the line you want to copy. Hit dd. Move the cursor to the location where you want to make the move. Hit p (lowercase p) to move the line after the current line. Hit P (uppercase P) to move the line before the current line.

Deleting a Line of Text

Switch to command mode. Move to the line you want to delete. Hit dd.

Cutting, Copying, Pasting Multiple Lines of Text

Use nyy to copy n lines of text to the copy buffer. Move to where you want the lines to be and hit p or P to copy them. Use ndd to move n lines of text somewhere. Hit ndd to delete n lines of text, e.g., 3dd will delete the line of text the cursor is on and the next two lines.

Moving and Copying Text in Visual Mode

To cut, copy, and paste text that is not an entire line, enter visual mode by hitting v in command mode. Use the h, j, k, l keys to move around and select the text you want to copy or move. Once selected, hit y to copy the text to a buffer or d to delete the text to the buffer. Once copied (with y) or deleted with (with d) move to
where you want the text to be. Hit p to paste the text.

Finding Text

Switch to command mode. Hit / (forward slash) and enter the string you are searching for, e.g., /cookies. The cursor will be placed on the first occurrence of cookies following the current location. Hitting n over-and-over will continue searching.

Find and Replace

Switch to command mode. To replace all occurrences of homer by bart, try something like :1,100 s/homer/bart/g. The 1,100 part means search from line 1 to line 100 inclusive (I think 1,$ will search the entire file). The s stands for search. We are searching for homer and replacing all occurrences by bart. The g stands for global which means it will replace all occurrences without prompting you for each one. If you want to be prompted for each one, use c instead (for confirmation).

Undo and Redo

Since you will use it the most because of VI's horrible user interface the most useful command in VI (other than :q!) is the undo command. Hitting u will undo your last change. Hitting u multiple times will undo all of your changes back to the last time you saved the file (only if you are in :set nocompatible mode). Redo
is Ctrl+R.

More Help

Let's say you're either insane or a masochist and want to learn more about VI. In command mode, hit :h to bring up help. The most useful thing you need to know here is how to get out of help, hit :q (like in less).

Linux - Processes

2009-10-08T22:16:00.000-07:00

When you run a program in *nix, the OS loads it into memory and sets up some other information concerning your program. The loaded and running program is called a process. When the program terminates, so does the process.

Every process has a system-wide unique identifier called the process id, or pid; it is just an integer. The process is owned by the user who launched it. The ps command will show you a list of the running processes of which you are the owner.

$ ps
PID TTY TIME CMD
17776 pts/18 00:00:00 bash
19041 pts/18 00:00:00 ps

I am running two programs right now: bash and the ps program itself. The PID of each process is shown. The time column is the cumulative amount of CPU time the process has consumed—this is not the same as wall time, i.e., how many seconds it has been since you ran the program. To see all of the processes running on the system, type ps -A or ps -e. The command ps -f will display full process information including the user id of the process owner. It can be combined with -A or -e. To sort this list by user id and view it in less, use

$ ps -ef | sort | less.

When you run a program (i.e., a process) you can ask the OS to run it in the background. Do this by putting a & on the end of the command line,

$ some-program &
$ now-you-can-type-another-command

Now some-program will run in the background and you can get back to work typing commands. To bring a running program back into the foreground, type the fg command,

$ fg

Now some-program would be running and if it is displaying output, the output would be going to the console window. To put the program back into the background, hit Ctrl+Z to pause it, and then type bg to send it back to the background.

To see a list of your processes running in the background use the jobs command. If you have more than one background job they will be numbered with a job number 1, 2, 3, .... To bring job number 3 to the foreground, type fg %3. To send this job back to the background, hit Ctrl+Z, and type bg.
To terminate a runaway process, use the kill command. The syntax is kill pidnumber. You cannot kill processes that you do not own. To kill a process running in the background, issue a jobs command to see your running processes and the determine the job number. Then use kill job number to kill the job; e.g., kill %3 to kill job number 3.

The top command will display a table of the processes which are currently using the most CPU time. It is a highly configurable program; try man top. (Be aware that top is a fairly resource-intensive program; it's not cool or nice to run top alot).

The nice command was designed to allow a user to run a program with lower than normal priority, so it will not hog the CPU as much. The idea is that other people may be peeved if you're sucking up too much CPU time, so you can be nice about it and still run your program. The syntax is nice -n adjust command where command is the program you want to run (e.g., it could be a big make process). Adjust is an integer which determines the adjusted process priority: -20 is highest, to 19 lowest. No one ever uses nice.

Linux - Piping

2009-10-08T21:59:00.000-07:00

Linux - Piping

To connect the stdout of one program to the stdin of anotherprogram, in *nix we use a pipe (the output flows out one program through the pipeto the input of the other program). The pipe symbol is | and the way tosend the output of one program to the input of another program is program1 |program2. For example, to display a long listing of the files in a directoryand sort them based on the time the file was last modified,

$ ls -l | sort +7

The program sort sorts its input and sends the sortedoutput to stdout. The option +7 tells sort to sort the input file based on thedata in field 7 which in the ls -l output is the column which contains thetimestamp. To sort on size try ls -l | sort + 4. To display the contents of adirectory and display the output using less,

$ ls -l | less

As you can see, this is similar to I/Oredirection, but we are not dealing with reading and writing to files, butrather with programs that interact in some way. IO redirects and piping can beused in conjunction in the same command as well.

$ func1 < file1.txt | less

The above command will take file1.txt as input to func1 andthen pipe the output of func1 to less to display to the screen.

Previous- Concatenating and Appending Files | Next- Info Command

Linux - Changing Your Prompt String

2009-10-08T21:55:00.000-07:00

The prompt is the string that is displayed by Bash when it is waiting for your input. By default your prompt may be some string ending with a $. You can change the prompt. The file .bash_profile contains commands that are executed when you log in to the *nix system. It differs from .bashrc in that the commands in .bash_profile are only executed once, during log in. On the other hand the commands in .bashrc are executed by the shell every time a new shell is started.

Personally, my prompt string is defined in my .bashrc file as PS1='\[\033[1;32m\]\w $\[\033 [0m\] '. The environment variable PS1 is your main prompt string. This funky-looking command sets my prompt to display the current directory (the \w part) followed by a $ in bright green.

Here is a list of all the escape characters you can use:

              \a     ASCII bell character (07)
              \d     Day Month Year
              \e     ASCII escape character (033)
              \h     host base name
              \H     hostname
              \j     # of jobs
              \l     shell terminal device base name
              \n     newline
              \r     carriage return
              \s     shell name
              \t     24 hour HH:MM:SS 
              \T     12 hour HH:MM:SS
              \@     12 hour am/pm time
              \u     current user
              \v     bash version
              \V     bash version + patch
              \w     current directory
              \W     current directory base name
              \!     command history #
              \#     command #
              \$     #(UID 0) or $(UID not 0)
              \nnn   octal nnn(ex \854)
              \\     backslash
              \[     begin of embedded control sequence
              \]     end sequence

Example

$PS1="[\T][\u][\w]$ "

The prompt string may look like this,

[5:45:45][username][~/documents]$

To permanently change your prompt in Bash, edit .bashrc and enter a line such as,

PS1=desired-prompt-string; export PS1

You may need to create the .bashrc file in your home directory if it does not exist. After you add that line, your prompt string should permanently be set. If this does not work, try adding the above in your .bash_profile in you home directory(once again, if it does not exit, create it).

Linux - Concatenating and Appending Files

2009-10-07T15:23:00.000-07:00

Linux - Concatenating and Appending Files

Concatenating Files

Cat can read input from multiple input files and it will send its output to stdout,

$ cat file1
cookies
pizza
$ cat file2
dogs
cats
$ cat file3
red blue
$ cat file1 file2 file3 > file4
$ cat file4
cookies
pizza
dogs
cats
red blue

Here, the contents of the files file1, file2, and file3 have been concatenated together when creating the new file file4. Now you can see where the name cat came from (it is short for concatenate)

Appending to a File

To append a file to another file use the >> symbol,

$ cat file1
cookies
pizza
$ cat file2
dogs
cats
$ cat file1 file2 >> file1
$ cat file1
cookies
pizza
cookies
pizza
dogs
cats

The above program is adding the contents of file1 and file2 to the end of file1.

The notation >> is equivalent to 1>> and the notation 2>> can be used to concatenate to stderr.

Previous - I/O and Redirection | Next - Piping

Linux - A Brief History

2009-10-05T20:14:00.000-07:00

A good history of the Unix operating system is available at Wikipedia1. UNIX wasan operating system originally written at AT&T Bell Labs in the late 1960's by Ken Thompson, Dennis Ritchie, and others. Thompson had been working on an earlier operating system project named Multics (Multiplexed Information and Computing Service) in conjunction with MIT and General Electric. While working on the project, Thompson had written a game called Space Travel for the GE mainframe being used for Multics development.

After AT&T Bell Labs withdrew from the Multics project, Thompson began porting his Space Travel game to a DEC PDP-7 minicomputer at Bell Labs, and in the process began work on a new
operating system he named Unics (for Uniplexed Information and Computing Service); the spelling was later changed to Unix and when it was owned by AT&T was written in all capitals as UNIX.

Over time, Thompson, Ritchie, and others at Bell Labs continued developing UNIX. In 1973 the entire operating system was rewritten in Ritchie's new C programming language, and during this time AT&T began giving the operating system to universities, research institutions, and the US government under licenses, which included all source code. In 1982, when AT&T realized that they had an OS on their hands that was worth something, they changed their licensing model and began selling UNIX as a commercial product without source code.

Meanwhile, at the University of California, Berkeley, Bill Joy and others had begun to develop BSD5 Unix as an alternative to the now-commercialized AT&T Unix. BSD Unix went on to become immensely popular, especially in the academic world, and Bill Joy eventually left Berkeley to go to work for a small startup named Sun Microsystems where he created the SunOS version of Unix which eventually became Sun Solaris.

Throughout the next two decades, many companies and organizations produced their own versions of Unix, usually under license from AT&T or from the Berkeley branch. This led to a proliferation of differing operating systems that were called Unix. For example, at one time, one could acquire "Unix" from various entities such as: AT&T (System V), UC-Berkeley (BSD Unix), IBM (AIX), SGI (IRIX), Microsoft (Xenix), SCO, HP (HP-UX), and others. During the late 1980's, it was thought that Unix would become the dominant operating system among PC users, but the divisions among the participants and the wrangling for control of Unix created an opportunity for Microsoft Windows NT to fill the gap in the market, and for Microsoft Windows to, instead, dominate the industry.

Eventually, while getting out of the computer business, AT&T washed their hands of Unix and sold all rights to Novell, which eventually transferred control to the Open Group. The Open Group is not a company, but rather is an industry consortium which sets standards for Unix. The Open Group published the Single Unix Specification (SUS) in 2002 which is a family of standards that defines what Unix is, is not, and what OS's qualify for the name. The SUS is now maintained by the Austin Group for the Open Group.

Next - The Linux/Unix File System

Learning Linux -- Article Directory

2009-10-05T19:10:00.000-07:00

Introduction

Linux Commands

Shell Scripting

Introduction
Variables
Arithmetic and Relational Operators
An Example
Command Line Arguments
Aliases
Displaying Text from Shell Script
A Simple Backup Script
Reading From Keyboard
Variables in Output
If Statements
For and While Loops
Shell Scripting Expressions/Substrings

Handy Things to Know

Linux - I/O and Redirection

2009-10-05T13:07:00.000-07:00

Linux - I/O and Redirection

Unix was created in the days of text-based computing before graphical user interfaces were common. One of the design philosophies was that users would interact with the system through small programs which performed some simple command or purpose. Dennis Ritchie and Ken Thompson designed these simple programs so they would accept input from the keyboard, a file, or as the output of another program. Thus, there was a need to be able to direct the output of a program to either a file or some other program and to also specify where a program was to get its input.

In *nix, the kernel opens and makes available three files for every program that is executed. These three files are called standard input, standard output, and standard error, usually abbreviated to stdin, stdout, and stderr. By default, stdin is attached to the keyboard, and stdout and stderr to the console window. If a program prints something to stdout, then it will be displayed on the console window. If it reads something from stdin, the program will wait for input from the keyboard.

Stdin and stdout can be changed so that rather than reading input from the keyboard, the program will read input from a file. Traditionally in other operating systems of that era, this was done by changing the source code to read the data from a file rather than from the keyboard. One of the most beautiful things about Unix was that this could be accomplished without changing the source code. Rather, the user would redirect stdin from the keyboard to a data file when invoking the program and the source code would remain unchanged. The same could be done for stdout: rather than sending the output of a program to the console window it could be redirected to a file.

· stdin-'<' OR '0<'

· stdout-'>' OR '1>'

· stderr-'2>'

Redirection Example 1

An example may be helpful. The program cat normally reads a file and sends the output to the console window. When invoking cat we can redirect its output to a file rather than the console window,

$ cat file01.c > fooie

The > symbol is used to send cat's output to the file fooie rather than to the console window. Note that we have just made a copy of file01.c.

The following c program reads two integers from stdin and outputs the larger of the two to stdout,

/* larger.c */

#include <stdio.h>;

int main() {

int n1, n2;
fprintf(stdout,"Enter an integer: "); fscanf(stdin,"%d",&n1);
fprintf(stdout,"Enter an integer: "); fscanf(stdin,"%d",&n2);
fprintf("The largest integer was the ");
if (n1 > n2) fprintf(stdout,"first one: %d\n",n1);
else fprintf(stdout,"second one: %d\n",n2);
return 0;

}

Since this program reads its input from stdin and writes its output to stdout, we can redirect its input and output so it reads its input from a file and sends its output to a file. For example, suppose we create a text file named larger.in which has two lines, the first with a 2 and the second with a 4. The following command will execute our program and send its output to larger.out.

$ cat larger.in
2
4
$ larger < larger.in > larger.out
$ cat larger.out
Enter an integer: Enter an integer: The largest integer was the second
one: 4

Redirection Example 2

For a different example, consider that cat normally sends its output to the console window. We can redirect cat's output to a file,

$ cat > larger.in
2
4
(^+D)-ctrl + d
$ cat larger.in
2
4

This is a commonly used quick-and-dirty way to create a small, simple text file without invoking a text editor.

Redirecting Stderr

Stderr can be redirected as well,

$ larger < larger.in > larger.out 2> larger.err

Note that > is really 1>, so the above command is equivalent to,

$ larger 0< larger.in 1> larger.out 2> larger.err
ctrl+d

Stderr is not used in C and C++ programs as much as stdout is. The idea with stderr is that error messages—which are special in that they are not part of the normal program output—can be sent to a different location than the normal output. For example, when running a program, you might send stdout to an output file and stderr to the console window,

$ blobx 2> data.out

Since the normal connection for stderr is to the console window, we only need to redirect stdout to the output data file. Any error messages printed to stderr will appear on the console window.

Sending Output to /dev/null

*nix interfaces to "devices" through files, e.g., the CD-ROM drive, the mouse, etc.

A special device named /dev/null is created at startup. Anything written to /dev/null simply "goes away". So, we can use /dev/null and redirect stdout when, for example, we don't want to see the output of a program on the terminal window,

$ prog
output is displayed on the terminal
$ prog > /dev/null

No output to the console.

Anything written to stdout within the program will be redirected to /dev/null and will not be displayed. Stderr can also be redirected to /dev/null. You can think of /dev/null as a black hole, anything that goes in is never seen again.

Previous - Compressing Files With gzip and bzip2 | Next - Concatenating and Appending Files

Linux - Environment Variables

2009-10-05T10:57:00.000-07:00

The shell maintains several environment variables which are used to store information used by the shell. The PATH environment variable lists the directories in the order that the shell will search when trying to locate an executable file. You can display the environment variables with the set command (the env and printenv commands do the same thing),

$ set
a lot of stuff scrolls by
$ set | less

In the second set command, the output is being piped through the less program. To change the value of an environment variable, use varname=value,

The following example changes MYNAME variable as well as the PATH variable. The PATH variable designates where BASH looks when it runs commands. For instance, the /bin directory is in the PATH variable, so when commands are run, it will look in that directory for the command. If you are creating executables and would like bash to look in the current directory for commands you type, you can add '.' to the PATH (remember '.' represents the current directory).

$ MYNAME=Kevin
$ set | grep MYNAME
MYNAME=Kevin
To add . and sbin to your path,
$ PATH=/sbin:$PATH:.
$ set | grep PATH
PATH='/sbin:/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:.'

Setting an environment variable at the Bash command prompt only changes the value of the environment variable for this session. To make the change permanent (so the variable will be defined when you log in again), edit your .bashrc file in your home directory, and add the lines,

MYNAME=Kevin; export MYNAME
PATH=/sbin:$PATH:.; export PATH

The special file .bashrc contains commands that are executed whenever a "new environment" is created, i.e., whenever a new shell is started. The next time you log in the environment variables will be updated. To delete an environment variable, use the unset command, e.g., unset MYNAME.

Linux - Info Command

2009-10-05T10:46:00.000-07:00

Linux - Info Command

Info is an onlinehelp system, separate from the *nix manual, that is used to document GNUutilities. To get help on the bzip2 command you would type info bzip2. Whereinfo differs from man is that info documentation is organized into ahierarchical document of nodes (it's a tree structure) and the user useskeypresses to navigate around the document. Info is, like the Emacs editor,incredibly complicated to use at first. Important info commands are summarizedbelow.

General Commands

Command	Function
q	Quit
z	Start help tutorial
?	Display command summary
^0	Exit command summary

Reading a Node

Command	Function
Pg Dn	Display next screen of text
Pg Up	Display previous screen of text
b	Jump to first line of text in node
Up Arrow	move cursor up one line of text
Down Arrow	move cursor down one line of text
Left Arrow	move cursor one char to the left
Right Arrow	move cursor one char to the right

Moving Around Nodes

Command	Function
n	jump to next node in document
p	jump to previous node in document
t	jump to the top node in the document
u	move up from this node to the parent node
Home	move to top line of node
End	move to bottom line of node

Jumping From Node File to Another

Command	Function
Tab	move cursor to next hyperlink in current node
Return	follow hyperlink to a new node
I	jump to previously displayed node
d	jump to directory node (the root node of info)

Previous- Piping

Linux - Man Pages

2009-10-05T09:28:00.000-07:00

Linux - Man Pages

Historicallythe online Unix manual was divided into eight sections:

1. Commands

2. SystemCalls

3. LibraryFunctions

4. SpecialFiles

5. FileFormats

6. Games

7. MiscellaneousInformation

8. SystemAdministration

Theman (manual) command can be used in *nix to get help on many commands. Forexample, type man cd to display the "man page" for the cd command.Typing man kill would display information on the kill command from section 1 ofthe manual. However, if there is also information about "kill" insection 2, one could type man 2 kill to display that entry (on some systems youmay have to enter man -s 2 kill instead).

Whenreading man pages you may see a command or phrase followed by a number inparentheses, such as chmod(2). This tells you that man information about chmodcan be found in section 2. Man output is displayed with less so you can use thePage Up and Page Down keys to scroll through the manual page (or use the b andf keys; b for backward; f for forward). Hit q to get out of less.

Reading a Man Page

Manpages can be difficult to read sometimes because of the complexity of thecommands and the various options and arguments. Nonetheless, if you really wantto become a proficient *nix user, you will have to learn how to read them.There is no standard format for a man page, but many of them are organized in aa similar format:

Section	Description
Name	name and purpose of the command
Synopsis	syntax of the command; shows whether it accepts options or args
Description	full description of the command; may be quite lengthy (e.g., bash)
Environment	environment variables used by the command
Author	the person or persons who wrote the program
Files	list of important files to this command
Copyright	who holds the copyright to the program
See Also	where to look for related information
Diagnostics	possible errors and warnings
Bugs	known mistakes or shortcomings

Previous- Commands, Arguments, and Options | Next- Viewing the Current Directory 'pwd' and 'ls'

Linux - Compressing Files With gzip and bzip2

2009-10-04T13:28:00.000-07:00

Linux - Compressing Files With gzip and bzip2

Compressing files is a mean of reducing the size of a file. The most common file compression programs in *nix are gzip and bzip2.

'bzip2' usually compresses files a bit better than 'gzip' due to a different algorithm, but they are used in exactly the same manner.

Compress a File

Using gzip,

$ gzip file1.c
$ ls
a.out file1.c.gz file3 src

This compresses the file and leaves file1.c.gz in the current directory; the original file file1.c is replaced by the .gz file.

Using bzip2,

$ bzip2 file2.c

$ ls

a.out file1.c.gz file3 src

Decompress a File

Using gzip, the -d option decompresses a .gz file,

$ gzip -d file1.c.gz
$ ls
a.out file1.c file3 src

This decompresses the file and leaves file1.c in the current directory; the .gz file is removed.

Using bzip2, which also uses the -d option,

$ bzip2 -d file1.c.gz
$ ls
a.out file1.c file3 src

Examples

To compress every .c file in a directory,

$ cd
$ ls src
file01.c file02.c file03.c file01.o file02.o file03.o
$ cd src
$ gzip *.c
$ ls

file01.c.gz file02.c.gz file03.c.gz file01.o file02.o file03.o

To decompress every gzipped .c file in a directory,

$ gzip -d *.c.gz
$ ls
file01.c file02.c file03.c file01.o file02.o file03.o

To compress a tar file, just gzip or bzip2 it like a normal file,

$ ls src

file01.c file02.c file03.c file01.o file02.o file03.o
$ tar cf src.tar src
$ ls
a.out file1.c file3 src src.tar
$ bzip2 src.tar
$ ls
a.out file1.c file3 src src.tar.bz2

Previous - Tar Command Archiving Files | Next - I/O and Redirection

Linux - Tar Command Archiving Files

2009-10-04T13:14:00.000-07:00

Linux - Tar Command Archiving Files

An archive is a collection of one or more files grouped together into a single file. The program tar (tape archive) is used in *nix to form an archive. This archive file is commonly called a tar file. Note that the tar file is not compressed. A compressed or uncompressed tar file is also commonly called a tarball. This is similar to the .iso files you see with the Windows operating system. We will see in the next section how to compress a tar file.

Create a Tar

Use the cvf option to create a tar (c stands for create),

$ cd
$ ls
a.out file1.c file3 src
$ tar cvf archive.tar file1.c file3
file1.c
file3
$ ls
a.out archive.tar file1.c file3 src

Note that the "tarred" files are not removed. This tar command would create an archive file named archive.tar which contains the files file1.c and file3. The v option to tar specifies that the program be verbose and display the files it is archiving as they are being archived. The c option means create an archive file. The f option means that what follows the options (the word "archive.tar") is to be the name of the archive file. It is common to give this file a .tar extension. Following the name of the archive file is a list of one or more filenames (or directories) to be archived.

To tar all of the .c files in a directory,

$ ls src
file01.c file02.c file03.c file01.o file02.o file03.o
$ cd src
$ tar cvf archive-c.tar *.c
file01.c
file02.c
file03.c
$ ls
archive-c.tar file01.c file02.c file03.c file01.o file02.o file03.o

Display Tar Contents

To list the contents of a tar archive to the screen, i.e., to see what is in the archive, use the t option (t stands for table of contents),

$ tar tf archive-c.tar
file01.c
file02.c
file03.c

Extract Files

To extract the files from a tar archive use the x (extract) option,

$ cd
$ mkdir gromulate
$ mv src/archive-c.tar gromulate
$ cd gromulate
$ tar xvf archive-c.tar
file01.c
file02.c
file03.c
$ ls
file01.c file02.c file03.c

The file names will be displayed as each of them is extracted (because of the v option).

To extract the tar directly to a different directory than the current directory, use the -C option.

$ tar xvf archive-c.tar -C fred/backup

Tar is often use to archive an entire directory and its subdirectories. In the example below, 'src' is a directory,

$ cd
$ ls src
file01.c file02.c file03.c file01.o file02.o file03.o
$ tar cvf src.tar src
file01.c
file02.c
file03.c
file01.o
file02.o
file03.o
$ ls
a.out file1.c file3 src src.tar
$ tar tf src.tar
file01.c
file02.c
file03.c
file01.o
file02.o
file03.o

Summary

Create a tar,

$ tar cvf name.tar fileSrc

View contents of a tar,

$ tar tf src.tar

Extract contents of a tar,

$ tar xvf archive-c.tar

Extract contents of a tar to a different directory,

$ tar xvf archive-c.tar -C filepath

Previous - Viewing Files with Cat and Less | Next - Compressing Files With gzip and bzip2

Linux - Viewing Files with Cat and Less

2009-10-04T13:06:00.000-07:00

Linux - Viewing Files with Cat and Less

Cat Command

To displays the contents of a file at the terminal window, use the cat (concatenate) command,

$ cat file1.c
#include
int main() {
printf("Hello world.\n");
return 0;
}

With cat, the contents of the file will scroll right off the top of the window if the file is too large.

Less Command

You can use the less command to display a file on the window and then use the Page Up (or b for backwards) and Page Down (or f for forwards) keys to scroll through the file.

$ less file1.c

file1.c is displayed on window

Other Frequently-Used Less Commands

After you have a file opened in less, simply type a command to do something.

Command	Function
h	Display Help
q	Quit less
g	Go to 1st line
G	Go to last line
=	Display file name and current line
#g	Go to line #(ex: 5g)
/	Search forward for pattern(ex: /fred)
?	Search backward for pattern
n	Repeat search in same direction
N	Repeat search in opposite direction
!cmd	Run shell and execute cmd(ex: !ls)
v	Load current file in VI editor

Previous - Deleting Files and Directories (part 2) | Next - Tar Command Archiving Files

Linux - Finding A File

2009-10-04T12:56:00.000-07:00

Linux - Finding A File

Find Command

The find command can be used to find a file that is storedsomewhere in the file system. It is a very complicated command with lots ofoptions, so I will only show you the most basic command. Suppose you know thereis a file named mlocate.db somewhere in the file system but you don't knowwhere. The command to type would be,

$ find / -name mlocate.db

This command tells the find program to start at the rootdirectory (the / part) and search for a file a filed named (-name) mlocate.db.It should be noted that a *nix installation might have 10,000 or more files inthe file system, so this command could run for quite a long time before itfinds the file. If you have a hunch that the file you are looking for is in asubdirectory below root, say /usr, then you could narrow down your search bytyping,

$ find /usr –name mlocate.db

Now, only the directory /usr and its subdirectories will besearched. To perform a case-insensitive search on the file use -iname optionrather than -name.

Locate Command

You can also try the locate command,

$ locate whereis

If this does not work, you must first build the databasewith the command,

$ slocate -u

This will create a file that indexes all the files for fastlookup (may take several minutes)

Whereis Command

You can also try the whereis command to locatebinary(executable files/commands) and their man pages,

$ whereis ls

This will locate the command ls and the respective man pages.

Previous- Changing Directories | Next- Changing File Permissions with 'chmod' Command

The Linux/Unix File System

2009-10-03T23:16:00.002-07:00

The *nix file system is the part of the OS that manages the files and directories stored on secondary storage devices such as tape, optical and hard disks. Files and directories in the file system are stored in a hierarchical fashion(ie, a tree).

At the top level is the root directory indicated by a forward slash symbol /. "Root" is at the top of the file system hierarchy. Every file and directory on the system is stored under root and there is nothing above it in the directory tree.
Your Home Directory
Your home directory is where you have your personal files. Each user has their own home directory. You and you alone have complete control of all the files in your personal home directory.
The home directory is referenced by the '~' character. That character points to the current user's home directory. For instance, the command "cd ~" will change directory to you home directory(cd command discussed more here).

Common Directories in *nix
On a typical *nix system you will find several common directories directly under root. Some of these common directories are discussed below.
/bin
Binary images (executables) for various *nix commands used by users. These would include programs for commands such as ls, cp, mkdir and so on. In a typical distribution there will be a large number of commands files located in this directory, but only a small subset of them are technically required to be installed there.
/boot
Contains the files necessary to boot the *nix operating system. This includes the binary image of the kernel (i.e., the compiled kernel source code). In GNU/Linux The kernel file is commonly named vmlinux (uncompressed) or vmlinuz (compressed) followed by the version and release numbers. If you want to know which version of the kernel you are using, type uname -r at the shell prompt.
/dev
The device directory contains files corresponding to different I/O devices connected to the system. These would include tape drives, cdrom drives, hard disks, terminals, printers, etc. A special device is
/dev/null.
Anything written to /dev/null disappears into the ether. One of the features that made Unix popular in the early days was that all devices are treated as files, and could be accessed using file I/O commands.
/etc
This directory contains host-specific files and directories which are used primarily for system configuration purposes. Executable programs are not located here. If the X window system is installed, the files for it will be installed in a subdirectory of /etc, e.g., /etc/X11.
/home
Users' personal directories are located here. Normally each user is given a home directory where he/she may store his/her files. This is the directory where, as a user, you would spend most of your time. A typical home directory for user fredf would be /home/fredf. Note that the special symbol ~ is used to refer to the home directory in the shell.
/lib
Contains shared library images needed to boot the system and to run the commands in bin and sbin.
/mnt
Used to temporarily mount another file system under the current file system, e.g., to connect the file system for a floppy disk or a cdrom to the current file system. How these devices are mounted is not something ordinary users care about.
/opt
Third-party application programs can be installed here, each within its own subdirectory. /root This is root's home directory. The special login identifier root is the master login for the entire system. Root has privileges that other users do not have, and he or she is typically the system administrator who is responsible for administering the system, installing programs, adding users, mounting file systems, etc.
/sbin
This directory contains system binary files, i.e., executables that are normally used only by root in administering the system. Other system binaries may be found in /usr/sbin and /usr/local/sbin.
/tmp
Temporary files are often placed here.
/usr
The files and directories under usr are mounted read-only (except to root). Underneath usr are several important subdirectories.
/usr/bin
Other user-specific binaries. For example, the gcc program might be installed here.
/usr/include
Include header files for the C compiler are placed here.
/usr/lib
Contains object files and library files used in software development.
/usr/local
Another place where root can install user programs. For example, if you install the Firefox web browser, you may install it under /usr/local/firefox 20 for example. Multiple networked host systems may access the files in /usr/local.
/usr/share
Shared data files, e.g., font files, man pages, other documentation, icon images files, etc.
/usr/src
Source code, generally for reference only (i.e., not for development purposes). On many GNU/Linux systems, the Linux source code will be installed in /usr/src/linux (during installation, you usually have the choice to download and install the Linux source code).

/usr/X11
Files used by X Window (X is part of the graphical system of your Linux installation).
/var
Variable data files (i.e., data files that contain data that are changing) are stored here. These would include temporary files and log files.

Previous - Linux - A Brief History | Next - Linux Shells - Specifically the BASH Shell

Linux - Commands, Arguments, and Options

2009-10-03T23:16:00.001-07:00

Linux - Commands, Arguments, and Options

A commandis a word that is typed at the terminal window prompt in order to performsome action. For example, the ls command is used to list the contents ofa directory (specifically, the current directory). If you would like toview the contents of a different directory, then you can supply an argument tothe ls command which is the location of the desired directory, e.g., ls /binwould display the contents of the /bin directory where /bin is the argument to the ls command.

Inaddition to arguments, many (most) *nix commands accept command options aswell. Options are specified either with a hyphen followed by a letter, e.g., -l,or a pair of hyphens followed by a word, e.g., --help. For example, ls-l /usr/bin is a command (ls) with the option -l and theargument /usr/bin.

Optionsmodify the way commands work. When no options are specified we would say thatis the default behavior of the command. Options can be used to alter thedefault behavior. Note that like everything else in *nix, options are case sensitive.There is a difference between ls -l and ls –L as there is betweenls and LS. A command can have multiple options, e.g., the lscommand supports two options -l and -a that alter it in different ways. A legalls command using these two options would be ls -a -l. But often times,options can be combined so this same command could be typed as ls -al andit would perform the same action.

Auseful option you should know is --help. Many commands will display ascreen of text describing the commands, its action, and its options andarguments in response to the --help option. Whitespace surrounding options isimportant. The command ls -a-l is erroneous because there is no space inbetween the -a and -l options. The correct command is ls-a-l. Inconclusion, know that the general format of a *nix command is commandoptions arguments—in that order.

Next -Man Pages

Linux Shells - Specifically the BASH Shell

2009-10-03T23:08:00.000-07:00

Shells

In *nix(Unix/Linux) the shell is a text-based interface to the operating system. The kernel is the lowest-level innermost part of the operating system, so the shell is so named because it surrounds the kernel. Over the years, various shell programs have been written. The first was the Thompson shell (commonly referred to as simply sh) written by Ken Thompson at Bell Labs. Other popular shells have that have been written over the years include the Berkeley Unix C shell (csh), the TC shell (tcsh; the T comes from the TENEX operating system), the Korn shell (ksh), the Z shell (zsh), the Bourne shell (bsh), and the Bourne-again shell (Bash). Bash was the shell originally developed by GNU for the GNU operating system. It is commonly available in most GNU/Linux distributions and this manual is written assuming you are using Bash.
You can see which shells are installed on your system by typing cat /etc/shells (the chsh -l command simply displays this file). Most likely if you are using Linux, your default shell is bash. An easy way to tell what shell you are running is to type less /etc/passwd and look for the line containing your username. The last entry on the line will be your default login shell. If you wish to change your default login shell you can use the chsh -s shell command. This will modify the shell entry for your username in /etc/passwd so the next time you login you will be running the new shell.

The Bash Shell

Once logged in to linux, you will see a window with some text, awiting your input. This is called a terminal window or just terminal; you may also hear the term console window or just console.

The $ prompt is the Bash shell prompt. It is Bash's way of letting you know that it is waiting for you to type a command. The ~ symbol in Bash always refers to a user's home directory. Your home directory is where you are placed when you first log in and it is the area in the file system where you can store your files. The prompt string can be changed(discussed in later article).

When you type commands at the prompt and press the Enter key, Bash will read the command string you typed in, parse it to break it into words and operators, perform some post-processing, and will then execute the the command. Unless you tell it otherwise, Bash will wait for the command to finish executing before displaying the $ prompt again. Some of the commands that you may use are built-in to Bash, i.e., the code that gets executed is inside the Bash program itself. However, most *nix commands are standalone programs that are found in the directories /bin, /usr/bin, and /sbin directories. For example, we can determine where the ls command is located

$ whereis ls 

ls: /bin/ls

whereis is a command which will search for the program file given to it. In this case we are searching for the program file named gcc. whereis tells us that a file named "ls" can be found in a directories. In fact, the first one /bin/ls is the actual executable file which is the ls command. For fun, try to determine where the whereis program is installed,

$ whereis whereis
whereis: /usr/bin/whereis /usr/share/man/man1/whereis.1.gz

We can see that it is installed in /usr/bin. In fact, most of the basic *nix commands (i.e. executable programs) are located in this directory. Bash will also execute special programs called scripts written in the Bash shell scripting language. See Chapter 11 for a basic introduction to Bash shell scripting. Overall, Bash is a very complex program, and we will only learn a small part of it in this course. However, what we learn in this course is supposed to provide you a solid foundation on which you can learn and obtain more knowledge of *nix and Bash.

Previous - The Linux/Unix File System | Next - Linux - Commands, Arguments, and Options

Linux Commands - Viewing the Current Directory - 'pwd' and 'ls'

2009-10-03T23:07:00.000-07:00

Linux Commands - Viewing the Current Directory - 'pwd' and 'ls'

If you are not familiar with the Linux file system, pleaseread TheLinux/Unix File System.

How Do I Know Which Directory I Am In?

Use the command pwd (print working directory),

$ pwd

/home/fredf

List Files, File Permissions, The Chmod Command

To list the files in a directory type ls,

$ ls

a.outfile1.c file3 src

The option -a will show all the files in thedirectory,

$ ls -a

.bash_profile a.out file1.c file3 src

The special file .bash_profile is a configurationfile which is used to configure the Bash shell when a user logs in.

Note that files starting with a dot are hidden filesand are not displayed during a normal ls command. Hidden files areusually used to store configuration information for various programs.

The option -l will display a long listing,

$ ls -l

-rwxr-xr-x 1 fredf fredf 20987 Oct 10 10:04 a.out

-rwxr-xr-x 1 fredf fredf 1098 Mar 7 2005 file1.c

-rwxr-xr-x 1 fredf fredf 654 Jun 12 18:44 file3

drwxr-xr-x+ 1 fredf fredf 0 Jan 01 2005 src

The first column displays the permissions for thefiles. Permission attributes are changed with the chmodcommand.

Previous- Man Pages | Next - Changing Directories

Linux Commands - Creating and Deleting Files and Directories

2009-10-03T23:04:00.000-07:00

Linux - Creating and Deleting Files and Directories (cd, mkdir, rmdir, rm)

*Review - Changing Directories

To change your working (current) directory, use the cd (change dir) command,

$ cd cse220
$ pwd
/home/fredf/cse220
$ ls
assgn02
$ cd ..
$ pwd
/home/fredf

Note: the 'cd ..' command changes the directory to the parent directory. In linux, '..' refers to the parent directory, while '.' refers to the current directory and finally '~' refers to your home directory. As you progress, you will see these are very useful.

Deleting Files

To delete a file use the rm (remove) command,

$ rm a.out
$ ls
file1.c file3 src
$ rm file3
$ ls -al
-rwxrwxrwx 1 fredf fredf 36 Sep 23 7:53 .bash_profile
-rwxr-xr-x 1 fredf fredf 1098 Mar 7 2005 file1.c
drwxr-xr-x+ 1 fredf fredf 0 Jan 01 2005 src

Note: You can only delete files that you own or have write privilege.

Creating and Removing Directories

To create a new directory use the mkdir (make directory) command and to remove it use the rmdir (remove directory) command,

$ mkdir cse220
$ ls
a.out cse220 file1.c file3 src
$ rmdir cse220
$ ls
a.out file1.c file3 src
$ mkdir cse220
$ mkdir cse220/assgn02
$ ls
a.out cse220 file1.c file3 src
$ ls cse220 assgn02

Suppose we have created directories cse220 and cse220/assgn02 and that Cse220/assgn02 has the files file1.c, file2.c, file1.o, file2.o, and a.out in it.

$ cd assgn02
$ pwd
/home/fredf/cse220/assgn02
$ ls
a.out file1.c file1.o file2.c file2.o
$ cd .
$ pwd /home/fredf/cse220/assgn02
$ cd .. $ pwd /home/fredf/cse220
$ cd ..
$ pwd
/home/fredf

Before deleting a directory, it must be empty (Learn how to delete non-empty directories),

$ rmdir cse220
rmdir: `cse220': Directory not empty
$ cd cse220
$ rmdir assgn02
rmdir: `assgn02': Directory not empty
$ cd assgn02
$ rm file1.c
$ rm file2.c
$ rm file1.o
$ rm file2.o
$ rm a.out
$ ls
$ cd ..
$ rmdir assgn02
$ cd ..
$ rmdir cse220
$ ls a.out file1.c file3 src

The command cd by itself will always change you back to your home directory. Remember, the symbol ~ also always refers to your home directory as well.

$ cd /usr/local/bin
$ pwd /usr/local/bin
$ cd
$ pwd
/home/fredf
$ cd /usr/local/bin
$ pwd /usr/local/bin
$ cd ~
$ pwd /home/fredf
$ cd cse220
$ cd assgn02
$ pwd /home/fredf/cse220/assgn02
$ rm ~/file1.c

The last command would remove the file /home/fredf/file1.c.
Remember, however, that you can only delete a file if you have write privilege.

Previous - Changing File Permissions with 'chmod' Command | Next - File Name Globbing with *, ?, [ ]

Linux - File Name Globbing with *, ?, [ ]

2009-10-03T23:03:00.001-07:00

Linux - File Name Globbing with *, ?, [ ]

Sometimes you want to do something to a group of files, e.g., delete all of them, without having to perform the command on each file individually. For example, suppose we want to delete all of the .c files in a directory. A wildcard is a pattern which matches something else. Two commonly used *nix wildcards are * (called star) and ? (question mark).

· Star(*) means 0 or more characters

· Question Mark(?) means exactly one character

· Brackets([]) represents a set of characters

Commands involving filenames specified with wildcards are expanded by the shell (this is called globbing after the name of a former program called glob which used to do this outside the shell).

The '*'

' file*' will match any filename which starts with the characters "file", and then is followed by zero or more occurrences of any character.

Examples

Suppose Fred's home directory contains the files,

· file01.cpp

· file02.cpp

· file03.cpp

· file1.cpp

· file01.o

· file02.o

· file03.o

· file1.o

To delete all of the .c files, type,

$ rm *.c

To delete file01.cpp and file01.o,

$ rm file01.*

The '?'

The '?' represents exactly one character.

Examples

Consider again Fred's home directory from the previous example.

Delete file01.o, file02.o and file03.o, but not file1.o,

$ rm file??.o

Delete file01.o, but not file01.cpp,

$ rm file01.?

The '[ ]' Glob

A set of characters can be specified with brackets [ ]. '[ab]' means the single character can be a OR b. Ranges can also be specified (ex: '[1-57-9]' represents 1-5 OR 7-9).

Examples

Delete file02.cpp and file03.cpp from Fred's directory,

$ rm file0[23].cpp

This will delete any files that start with f or F (remember linux is case sensitive),

$rm [fF]*

To delete all files which start with the string "file" followed by a single letter type,

$ rm file[a-zA-Z]

The a-z and A-Z in the last example means all the letters in the range lowercase a-z or uppercase A-Z.

There's more to wildcard matching than this, but this is enough to get you started.

More Examples

Remove all files that are exactly 1 character,

$rm ?

Let's say you have a directory named '9-15-2007-Backup-Really-Long-Name-blah...' Rather than typing the whole name, you could just type a subset of the string and use it with the cd command(change directory),

$ cd 9-15-2007*

If you have multiple folders that start with 9-15-2007, your directory will be changed to the first one alphabetically.

You can use file name globbing on most commands that accept files as arguments.

Previous - Creating and Deleting Files and Directories | Next - Deleting Files and Directories (part 2)

Linux Commands - Deleting Files and Directories (part 2)

2009-10-03T22:33:00.000-07:00

Linux Commands - Deleting Files and Directories (part 2)