Die DFU war ein trojanisches Pferd des DDR-Staatssozialismus, das alljährlich mit bis zu 5 Millionen harten Westmark alimentiert wurde. Das Gründungsmitglied von Westphalen war bereits seinerzeit als STASI-IM tätig.  Unverdächtig organisierte sie den Krefelder Apell (Die hier verlinkte Wikipedia-Darstellung ist ein wenig tendenziös). So sollte die Umsetzung des NATO-Doppelbeschlusses verhindert werden soll. Westeuropa war damals in berechtigter Sorge, dass die Sowjet-Union die strategischen Interessen Europas und der USA auseinander dividieren, weil die frisch aufgerüsteten Mittelstreckenraketen SS-20 nur Europa bedrohten - Nordamerika aber mangels Reichweite nicht.

Das war im Strategiespiel "Kalter Krieg" logisch und richtig: So ließ man den Sowjets eine Frist, um die SS-20 wieder abzuziehen, andernfalls würde die NATO ihrerseits Mittelstreckenraketen (Pershing 2 und Cruise Missile) in Westeuropa stationieren. Ein begrenzter Schlag mit SS-20 hätte so qualifiziert beantwortet werden können, ohne  Raketen von amerikanischem Boden auf den Weg zu schicken.

Oyen und seine Genossen von der Deutschen Friedens Union organisierten mit DDR/SED-Geld den "Krefelder Apell".  Damit sollte die Stationierung der NATO-Mittelstreckenraketen verhindert werden. Über 4 Millionen Bundesbürger erlagen der DDR-Propaganda.

Wie ein Stasi-IM leugnet der Fraktionsführer der umbenannten SED seine Vergangenheit. Wer aber heute hier in den Kommentarzeilen behauptet, frisches Blut und neuer Name hätten aus den Altkommunisten einen demokratischen Haufen gemacht, sollte sich an den Kopf fassen. Frau Ypsilanti wird das nicht davon abhalten, sich von den Repräsentanten der Stasipartei zur hessischen Ministerpräsidentin wählen zu lassen.

Werden die hessichen Landtagsabgeordneten eigentlich auf eine mögliche STASI-Mitarbeit überprüft? Frau Birthler übernehmen Sie!

Oh before I change the subject this man goes crazy over his Y! Messenger list like he don't want me to find out something. Or he don't want me to reply back to shit but he can reply back to people under mine. If he have something to hide then it'll eventually come to light. It probably already has. He probably don't know that I realized what he's hiding. Half the broads on his list is either half naked or fully naked. Its gone be all to late before he actually wake up.

I'm trying this trust thing with him but my gut which is rarely wrong keeps telling me not to trust him; my heart is saying the same thing. Usually if it quacks like a duck...etc etc.

Anyway, my communications with people is very bad, I can't look folks in the eye half the time. I don't like talking but when its time to explain myself I have to go to my blog or something. I have to sit and think about what I want/have to say. Its very frustrating cause its like I can hear myself talk and before I open my mouth my brain tells me I sound stupid. Its reason behind all of that but thats not for strangers to read let alone people I know.

I've been mentally tired lately trying to know who this dude is that I go to sleep next to. But I'm not going to continue to figure him out. Half the time he acts like I caught him in something anyway. I'm not paranoid or nothing is just I know things. I have family and friends who've done it to me numerous times thinking I won't know the difference in their actions.

Its like I know when someone is gay or if I wouldn't like that person without me saying anything to them. Its not judging or anything is just I know in my heart. I'm good at reading people and sometimes I want to ask him; "what did you do or what you've gotten yourself into where you in here on my case acting all giddy and what not?"

I know I wouldn't get the answer to that.

-N-

http://www.welt.de/politik/article2529394/Hessen-SPD-will-mit-Linken-und-Gruenen-verhandeln.html

SUBSTITUTION
- Replace old value with new value
sed 's/oldvalue/newvalue/'; 's/old2/new2/'
sed -e 's/old1/new1/' -e /s/old2/new2/'
s: mean substitution
e: mean next argument
- Change all tab to space
sed 's/    / /g'
- Replace with CONDITION
sed '/condition/ s/old/new/'
- Replace withi CONDITIONS in script file
script file --- sedlist
/con1/ s/old1/new1/
/con2/ s/old2/new2/
Call
sed -f sedlist file1
- Prohibiting display:
Adding option -n
sed -n ....
- Want the result output to another file
sed .... oldfile>newfile

DELETEING

- Delete by condition text
sed '/whattofind/ d'
Eg: sed '/two/ d' sample_one

- Delete from rownum a to ronum b
sed 'a,b d' sample_file
Eg sed '1,5 d' sample_file

sed '/^two/ d' sample_one

sed '/two$/ d' sample_one

sed '/^$/ d' {filename}

$ sed '/two/ s/1/2/; /three/ s/1/3/; /^$/ d' sample_one
one     1
two     1
three   1
one     1
two     2
two     2
three   1
$

sed '1,/^$/ d' {filename}

La isla de zapara: un magnifico pedazo de tierra flotante que recibe a quien se adentra a las aguas del lago de Maracaibo. Un pequeño y alargado barquito se abre paso entre islotes y manglares para descargar a una docena de fotógrafos aficionados en este territorio isleño. Su misión, la de registrar fotográficamente las bellezas del lugar. Pero para seis de ellos, esta salida sabatina se transformó en la más aterrorizante y extrema aventura de sus vidas. Entre ellos, me encontraba (o me perdía) yo…

Leer y ver historia completa...

Estas son algunas fotografías de la sesión Grado de Zaparación que esta en mi página en flickr. Ahora si me bautizé con el photoshop lightroom para editar las imágenes. Amé el programita :)

Efecto Vespuccio

A la deriva

München – Der letzte Sonntag förderte ein katastrophales Ergebnis für die CSU zu Tage. In nur 5 Jahren ein Verlust von mehr als 17%. Den Tränen nahe gestand der Huber Erwin: „Ja, ich bin schuld! Aber nicht alleine. Der Beckstein Günther und der Stoiber Edmund haben auch mitgemacht.“ Einzig Womanizer Horst Seehofer unbeschädigt aus der Wahl hervorgehen. Sein Umfragewert liegen weiterhin stabil bei 19,5% in der Zielgruppe. Als Konsequenz hat Huber (KPD) den Rücktritt von Seehofer als Bundesverbraucherminister und den Verzicht auf eine Reinigungskraft in der bayrischen Staatskanzlei bekannt gegeben.

Viele Bürger zeigen sich dennoch besorgt. Machte Huber in letzter Zeit einen besonders fanatischen Eindruck in In- und Ausland⁵ und gab Beckstein wie immer rechts-extremistische Äußerungen von sich, so konnte die berühmte 2-Maß-Rede dennoch nicht den Absturz der Partei in die Bedeutungslosigkeit von 43% verhindern. Dieser nibelungentreue Rest fragt sich jetzt natürlich, ob der Untergang droht, da die kommunistische Partei DIE LINKE 4,4% erringen konnte. Die Antwort ist einfach: Ja.

Der Bund der Vertriebenen hat bereits reagiert und angekündigt, die Volksbewaffnung zu forcieren, um einen traditionellen^ß Ausgleich zu der kommunistischen Einflussnahme herzustellen.

Doch die Betrachtung aller deutschen Alleinregierungsparteien bestätigt die schlimmsten Befürchtungen. Während die SED von Beginn an ein Spitzenergebnis präsentierte, positioniert sich die CSU im Vergleich zur anderen großen, von München und Bayern geprägten Partei (NAZIDAP) anfangs im Mittelfeld (Wikipedia/Kim 2005). Auch auf dem Höhepunkt ihrer Herrschaftszeit fällt die CSU durch ihre beständige Positionierung im Mittelfeld auf. Einzig ihre Durchschnittlichen Alleinregierungsjahre liegen an der Spitze. Doch dies konnte ihren Absturz nicht verhindern. Schon die SED bewies, dass Spitzenergebnisse über Jahre hinweg nicht vor einem schnellen Ende schützen können. Nur ihre Mittelmäßigkeit könnte die CSU jetzt noch vor dem totalen Ende retten. Oder der Rückzug in den Widerstand. Das dürfte der Partei allerdings schwer fallen, schnürte der damalige Innenminister und jetziger Promilleprinz Bayerns, Becksteingünther, doch den Sicherheitscockring der Bayern besonders fest. Auch ist die Partei eher unerfahren, was Untergrundaktivitäten gegen den Staat angeht. Ein Zusammengehen mit der ETA oder der IRA währe demnach sehr wahrscheinlich, sollte die Partei diesen Weg einschlagen wollen.

Bleibt die Frage, wohin trieb es die Millionen Ex-CSU Wähler trieb. Eine Theorie der CIA und des Mossad belegen mit Daten des BGS, dass sich in den letzten Wochen ein Strom Bayern nach Weißrussland abgesetzt hat. Indizien hierfür bietet auch das Wahlergebnis vom gleichen Tag wie die Bayernwahl. So gewann die Partei von Staatschef Lukaschenko jeden Sitz im Parlament. Insider¹³ aus der Wahlbeobachtungskommission der OSZE ließen durchblicken, dass dies wohl nur durch die Stimmen der zugewanderten alleinregierungsliebenden Bayern möglich wurde.

Der Staatsschutz ermittelt.

Literaturangabe

Spears, Britney/Hawking, Stephen (2008): Deutschland sucht den krassesten Kommunistenhasser. Das Buch. Berlin. Axel Springer.

von der Vogelweide, Walther (1223): Ottenton. Bozen. Handschriftlich.

Wikipedia, Seirmour-Klaus/Kim, Young Ill (2005): Bavaria's CSU. Heir to Hitler? Demin. KNAX-Hefte Verlag.

$ sed -e 's/TEXT_TO_FIND/TEXT_TO_REPLACE/g' SRCFILENAME > DESTFILENAME

Need to use -i instead of -e if we want to do the replace operation "in place". There is also an option to backup the source file when doing this !

To do the same for a given set of html files, I used a combination of find and xargs and also the -i switch for the sed command:

$ find -iname '*.html' -print0 | xargs -0 sed -i 's/TEXT_TO_FIND/TEXT_TO_REPLACE/g'

http://www.welt.de/politik/article2481703/Linke-kann-ueber-den-Erfolg-der-CSU-entscheiden.html

Cada día que pasa sin lograr que me quiera
es un día perdido...
¡Oh Señor, no permitas por piedad que me muera
sin que me haya querido!
Porque entonces mi espíritu, con su sed no saciada
con su anhelo voraz,
errará dando tumbos por la noche estrellada,
como pájaro loco, sin alivio ni paz...

By Amado Nervo

What is $*?

Its mainly used for showing up all params. This show all parameter values passed in shell script

What does $# stand for?

# will return the number of parameters that are passed as the command-line arguments.

What does $? Return?

$? will return exit status of command .0 if command gets successfully executed ,non-zero if command failed.

What are Different types of shells?

sh : the oldest shell 
csh : C shell 
ksh : Korn Shell 
bash : bourne again shell 

How do you read arguments in a shell program - $1, $2?

Shell script accepts parameters in following format... 
$1 would be the first command line argument, $2 the second, and so on 
$0 is the name of the script or function

If your script has more than 9 params then accept in following way... 
${12} : 12th param 
${18} : 18th param

What are the different kinds of loops available in shell script?

for, if, while, case

What is the difference between a shell variable that is exported and the one that is not exported?

The Shell variable which is exported would available to all the programs outside the Shell also. And the shell variable which is not exported, would available for that shell or for the shell program only, in which the variable is declared.

Export LANG=C 
will make the variable LANG the global variable, put it into the global environment. All other processes can use it. 
 
LANG=C 
will change the value only in the current script. 

If you have a string "one two three", which shell command would you use to extract the strings?

echo $string | cut -d" " -f1 
echo $string | cut -d" " -f2 
echo $string | cut -d" " -f3 

How will you list only the empty lines in a file (using grep)?

grep "^$" filename.txt

How would you get the character positions 10-20 from a text file?

cat filename.txt | cut -c 10-20

or

cut -c10-20 <filename.txt>

How would you replace the n character in a file with some xyz?

sed 's/n/xyz/g' filename > new_filename

We can replace n characters by using the following command:
1,$s/./xyz/g
where 1 shows that the search string will start searching patterns from first line of the file.
           '.' for any character.
            g for global replacemet.

What is the difference between a 'thread' and a 'process'?

A process is a collection of virtual memory space, code, data, and system resources. A thread is code that is to be serially executed within a process. A processor executes threads, not processes, so each application has at least one process, and a process always has at least one thread of execution, known as the primary thread. A process can have multiple threads in addition to the primary thread

Thread – is stream of executable code within process. They are light weight process. All thread with in a process  share process instruction,code & data segment,open file descriptor,signal handler,userID and GroupID. Thread has its own set of register including program counter,stack pointer 

What is this line in the shell script do ?#!/bin/ksh?

To invoke the shell indirectly this line is added as the first line in the file.This particular line invokes korn shell

What is use of "cut" command? Give some examples.

Cut - Utility used to cut/Strip out the required data/text from the source.

Cut can be used in three modes,

  Stripping by Character

     cut -c 1-3

  Striping by Byte length

     cut -b -1-72

Stripping by delimiter and fields.

     cut -d "|" -f1

Where   

-d "|" -> Delimiter used in input text to separate columns

-f1 -> Field/Column number  

While processing huge input files, Cut's performance is far better than awk

thanks - shivmohan purohit 

Unix  Vi editor command keys:

File Options:

  sh      Invoke shell  

vi      Vi mode  

wq      Write and quit  

w <f>   Write file <f>  

w! <f>  Overwrite file <f>

Many standard utilities (rdist, make, cron, etc.) allow you to specify a command to run at a certain time. Usually, this command is simply passed to the Bourne shell, which means that you can execute whole scripts, should you choose to do so. Steve Bourne, wrote the Bourne shell which appeared in the Seventh Edition Bell Labs Research version of Unix.

Lastly, UNIX runs Bourne shell scripts when it boots. If you want to modify the boot-time behavior of a system, you need to learn to write and modify Bourne shell scripts. It said there are 95% shell code written in Bourne shell. Code written in Bourne shell is compatible with shell scripting like ksh, bash & zsh. That means with minimal or no change one could port shell script written in Bourne shell to ksh or bash or zsh.

*Bash is popular among Linux users.

There are couple of other shells available which I will not be talking are C shell ( Used by C program to create programming rich shell) this is incompatible to Bourne shell. The C shell, csh, and its variant tcsh is a fine interactive shell (I use tcsh), but is a lousy shell for writing scripts.

Lets understand what is an executable files, they also know as program or binary executables, This files are machine readable files and human eyes can not make sense out of it. Others only contain text, knows as script. They are interpreter scripts like awk, sed, perl and many more.

Learning Shell Scripting

#!/bin/sh

The first line of any script must begin with #!, followed by the name of the interpreter. Some versions of UNIX allow whitespace between #! and the name of the interpreter. Others do not. Hence, if you want your script to be portable, leave out the blank.

A script, like any file that can be run as a command, needs to be executable: save this script as rotatelog and run

chmod +x rotatelog
to make it executable.

You can now run it by running
./rotatelog

Unlike some other operating systems, UNIX allows any program to be used as a script interpreter. This is why people talk about ``a Bourne shell script'' or ``an awk script.'' One might even write a more script, or an ls script (though the latter wouldn't be terribly useful). Hence, it is important to let Unix know which program will be interpreting the script.

When Unix tries to execute the script, it sees the first two characters (#!) and knows that it is a script. It then reads the rest of the line to find out which program is to execute the script. For a Bourne shell script, this will be /bin/sh. Hence, the first line of our script must be

#!/bin/sh

After the command interpreter, you can have one, and sometimes more, options. Some flavors of Unix only allow one, though, so don't assume that you can have more.

Variables

sh allows you to have variables, just like any programming languages. Variables do not need to be declared.

To set a sh variable, use VAR=value

And to use the value of the variable later, use $VAR or ${VAR}

The latter syntax is useful if the variable name immediately followed by other text:

#!/bin/sh

COLOR=yellow

echo This looks $COLORish

echo This seems ${COLOR}ish

prints

This looks

This seems yellowish

There is only one type of variable in sh: strings.

This is somewhat limited, but is sufficient for most purposes.

Local vs. environment variables

A sh variable can be either a local variable or an environment variable. They both work the same way; the only difference lies in what happens when the script runs another program (which, as we saw earlier, it does all the time).

Environment variables are passed to subprocesses. Local variables are not.

By default, variables are local. To turn a local variable into an environment variable,

use

export VAR

Here's a simple wrapper for a program:

#!/bin/sh

NETSCAPE_HOME=/usr/imports/libdata

CLASSPATH=$NETSCAPE_HOME/classes

export CLASSPATH $NETSCAPE_HOME/bin/netscape.bin

Here, NETSCAPE_HOME is a local variable; CLASSPATH is an environment variable. CLASSPATH will be passed to netscape.bin (netscape.bin uses the value of this variable to find Java class files); NETSCAPE_HOME is a convenience variable that is only used by the wrapper script; netscape.bin doesn't need to know about it, so it is kept local.

The only way to unexport a variable is to unset it:

unset VAR

This removes the variable from the shell's symbol table, effectively making as if it had never existed; as a side effect, the variable is also unexported.

Also, if you have a function by the same name as the variable, unset will also delete that function. Since you may want to use this variable later, it is better not to define it in the first place.

Also, note that if a variable was passed in as part of the environment, it is already an environment variable when your script starts running. If there is a variable that you really don't want to pass to any subprocesses, you should unset it near the top of your script. This is rare, but it might conceivably happen.

If you refer to a variable that hasn't been defined, sh substitutes the empty string.

#!/bin/sh

echo aaa $FOO bbb

echo xxx${FOO}yyy

prints

aaa bbb xxxyyy

Special variables

sh treats certain variables specially: some are set for you when your script runs, and some affect the way commands are interpreted.

Command-line arguments

The most useful of these variables are the ones referring to the command-line arguments. $1 refers to the first command-line argument (after the name of the script), $2 refers to the second one, and so forth, up to $9.

If you have more than nine command-line arguments, you can use the shift command: this discards the first command-line argument, and bumps the remaining ones up by one position: $2 becomes $1, $8 becomes $7, and so forth.

The variable $0 (zero) contains the name of the script (argv[0] in C programs).

Often, it is useful to just list all of the command-line arguments.

For this, sh provides the variables $* (star) and $@ (at). Each of these expands to a string containing all of the command-line arguments, as if you had used $1 $2 $3...

The difference between $* and $@ lies in the way they behave when they occur inside double quotes: $* behaves in the normal way, whereas $@ creates a separate double-quoted string for each command-line argument.

That is, "$*" behaves as if you had written "$1 $2 $3", whereas "$@" behaves as if you had written "$1" "$2" "$3".

Finally, $# contains the number of command-line arguments that were given.

Other special variables

$? gives the exit status of the last command that was executed. This should be zero if the command exited normally.

$- lists all of the options with which sh was invoked. See sh(1) for details.

$$ holds the PID of the current process.

$! holds the PID of the last command that was executed in the background.

$IFS (Input Field Separator) determines how sh splits strings into words.

Quasi-variable constructs

The ${VAR} construct is actually a special case of a more general class of constructs:

${VAR:-expression}

Use default value: if VAR is set and non-null, expands to $VAR. Otherwise, expands to expression.

${VAR:=expression}

Set default value: if VAR is set and non-null, expands to $VAR. Otherwise, sets VAR to expression and expands to expression.

${VAR:?[expression]}

If VAR is set and non-null, expands to $VAR. Otherwise, prints expression to standard error and exits with a non-zero exit status.

${VAR:+expression}

If VAR is set and non-null, expands to the empty string. Otherwise, expands to expression.

${#VAR}

Expands to the length of $VAR.

The above patterns test whether VAR is set and non-null. Without the colon, they only test whether VAR is set.

Pattern-matching

sh supports a limited form of pattern-matching. The operators are

* Matches zero or more characters.

? Matches exactly one character.

[range] Matches any character in range.

Range can be either a list of characters that match, or two endpoints separated by a dash: [ak3] matches either a, k, or 3; [a-z] matches any character in the range a through z; [a-mz] matches either a character in the range a through m, or z. If you wish to include a dash as part of the range, it must be the first character, e.g., [-p] will match either a dash or p.

When an expression containing these characters occurs in the middle of a command, sh substitutes the list of all files whose name matches the pattern. This is known as ``globbing.'' Otherwise, these are used mainly in the case construct.

As a special case, when a glob begins with * or ?, it does not match files that begin with a dot. To match these, you need to specify the dot explicitly (e.g., .*, /tmp/.*).

Note to MS-DOS users: under MS-DOS, the pattern *.* matches every file. In sh, it matches every file that contains a dot.

Quoting

If you say something like

echo * MAKE $$$ FAST *

it won't do what you want: first of all, sh will expand the *s and replace them with a list of all the files in the current directory. Then, since any number of tabs or blanks can separate words, it will compress the three spaces into one. Finally, it will replace the first instance of $$ with the PID of the shell. This is where quoting comes in.

sh supports several types of quotes. Which one you use depends on what you want to do.

Backslash

Just as in C strings, a backslash (``\'') removes any special meaning from the character that follows. If the character after the backslash isn't special to begin with, the backslash has no effect. The backslash is itself special, so to escape it, just double it: \\.

Single quotes

Single quotes, such as 'foo' work pretty much the way you'd expect: anything inside them (except a single quote) is quoted.

You can say

echo '* MAKE $$$ FAST *'

and it'll come out the way you want it to.

Note that a backslash inside single quotes also loses its special meaning, so you don't need to double it. There is no way to have a single quote inside single quotes.

Double quotes, such as

"foo"

preserve spaces and most special characters. However, variables and backquoted expressions are expanded and replaced with their value.

If you have an expression within backquotes (also known as backticks), e.g.,

`cmd`

the expression is evaluated as a command, and replaced with whatever the expression prints to its standard output. Thus,

echo You are `whoami`

prints

You are irfan

Built-in commands

sh understands several built-in commands, i.e., commands that do not correspond to any program. These commands include:

{ commands ; }, ( commands )

Execute commands in a subshell. That is, run them as if they were a single command. This is useful when I/O redirection is involved, since you can pipe data to or from a mini-script inside a pipeline.

The { commands; } variant is somewhat more efficient, since it doesn't spawn a true subshell. This also means that if you set variables inside of it, the changes will be visible in the rest of the script.

: (colon)

Does nothing. This is generally seen as

: ${VAR:=default}

. filename

The dot command reads in the specified filename, as if it had occurred at that place in the script.

bg [job], fg [job]

bg runs the specified job (or the current job, if none is specified) in the background. fg resumes the specified job (or the current job, if none is specified) in the foreground.

Jobs are specified as %number. The jobs command lists jobs.

cd [dir]

Sets the current directory to dir. If dir is not specified, sets the current directory to the home directory.

pwd

Prints the current directory.

echo args

Prints args to standard output.

eval args

Evaluates args as a sh expression. This allows you to construct a string on the fly (e.g., using a variable that holds the name of a variable that you want to set) and execute it.

exec command

Runs the specified command, and replaces the current shell with it. That is, nothing after the exec statement will be executed, unless the exec itself fails.

exit [n]

Exit the current shell with exit code n. This defaults to zero.

kill [-sig] %job

Send signal sig to the specified job. sig can be either numeric or symbolic. kill -l lists all available signals. By default, sig is SIGTERM (15).

read name...

Reads one line from standard input and assigns it to the variable name. If several variables name1, name2, name3 etc. are specified, then the first word of the line read is assigned to name1, the second to name2, and so forth. Any remaining words are assigned to the last variable.

set [+/-flag] [arg]

With no arguments, prints the values of all variables.set -x turns on the x option to sh; set +x turns it off.set args... sets the command-line arguments to args.

test expression

Evaluates a boolean expression and exits with an exit code of zero if it is true, or non-zero if it is false. See test for more details.

trap [command sig]...

If signal sig is sent to the shell, execute command. This is useful for exiting cleanly (e.g., removing temporary files etc.) when the script is interrupted.

ulimit

Print or set system limits on resource usage.

umask [nnn]

Sets the umask to nnn (an octal number). With no argument, prints the current umask. This is most useful when you want to create files, but want to restrict who can read or write them.

wait [n]

Wait for the background process whose PID is n to terminate. With no arguments, waits for all of the background processes to terminate.

Bear in mind that the list of builtins varies from one implementation to another, so don't take this list as authoritative.

Flow control

sh supports several flow-control constructs, which add power and flexibility to your scripts.

if

The if statement is a simple conditional. You've seen it in every programming language. Its syntax is

if condition ; then
commands
[elif condition ; then
commands]...
[else
commands]
fi

That is, an if-block, optionally followed by one or more elif-blocks (elif is short for ``else if''), optionally followed by an else-block, and terminated by fi.

The if statement pretty much does what you'd expect: if condition is true, it executes the if-block. Otherwise, it executes the else-block, if there is one. The elif construct is just syntactic sugar, to let you avoid nesting multiple if statements.

#!/bin/sh

myname=`whoami`

if [ $myname = root ]; then

echo "Welcome to FooSoft 3.0"

else

echo "You must be root to run this script"

exit 1

fi

The more observant among you (or those who are math majors) are thinking, ``Hey! You forgot to include the square brackets in the syntax definition!''

Actually, I didn't: [ is actually a command, /bin/[, and is another name for the test command. See below for details.

This is why you shouldn't call a test program test: if you have ``.'' at the end of your path, as you should, executing test will run /bin/test.

The condition can actually be any command. If it returns a zero exit status, the condition is true; otherwise, it is false. Thus, you can write things like

#!/bin/sh

user=arnie

if grep $user /etc/passwd; then

echo "$user has an account"

else

echo "$user doesn't have an account"

fi

while

The while statement should also be familiar to you from any number of other programming languages. Its syntax in sh is

while condition; do
commands
done

As you might expect, the while loop executes commands as long as condition is true. Again, condition can be any command, and is true if the command exits with a zero exit status.

A while loop may contain two special commands: break and continue.

break exits the while loop immediately, jumping to the next statement after the done.

continue skips the rest of the body of the loop, and jumps back to the top, to where condition is evaluated.

for

The for loop iterates over all of the elements in a list. Its syntax is

for var in list; do
commands
done

list is zero or more words. The for construct will assign the variable var to each word in turn, then execute commands. For example:

#!/bin/sh

for i in foo bar baz "do be do"; do

echo "$i"

done

will print

foo bar baz do be do

A for loop may also contain break and continue statements. They work the same way as in the while loop.

Case

The case construct works like C's switch statement, except that it matches patterns instead of numerical values. Its syntax is

case expression in
pattern)
commands
;;
...
esac

expression is a string; this is generally either a variable or a backquoted command.

pattern is a glob pattern (see globbing).

The patterns are evaluated in the order in which they are seen, and only the first pattern that matches will be executed. Often, you'll want to include a ``none of the above'' clause; to do this, use * as your last pattern.

IO

A command's input and/or output may be redirected to another command or to a file. By default, every process has three file descriptors: standard input (0), standard output (1) and standard error (2). By default, each of these is connected to the user's terminal.

However, one can do many interesting things by redirecting one or more file descriptor:

< filename

Connect standard input to the file filename. This allows you to have a command read from the file, rather than having to type its input in by hand.

> filename

Connect standard output to the file filename. This allows you to save the output of a command to a file. If the file does not exist, it is created. If it does exist, it is emptied before anything happens.

(Exercise: why doesn't cat * > zzzzzzz work the way you'd expect?)

>> filename

Connects standard output to the file filename. Unlike >, however, the output of the command is appended to filename.

<<word

This construct isn't used nearly as often as it could be. It causes the command's standard input to come from... standard input, but only until word appears on a line by itself. Note that there is no space between << and word.

This can be used as a mini-file within a script, e.g.,

cat > foo.c <<EOT

#include <stdio.h>

main() {

printf("Hello, world!\n");

} EOT

It is also useful for printing multiline messages, e.g.:

line=13 cat <<EOT An error occurred on line $line. See page 98 of the manual for details. EOT

As this example shows, by default, << acts like double quotes (i.e., variables are expanded). If, however, word is quoted, then << acts like single quotes.

<&digit

Use file descriptor digit as standard input.

>&digit

Use file descriptor digit as standard output.

<&-

Close standard input.

>&-

Close standard output.

command1 | command2

Creates a pipeline: the standard output of command1 is connected to the standard input of command2. This is functionally identical to

command1 > /tmp/foo
command2 < /tmp/foo

except that no temporary file is created, and both commands can run at the same time

There is a proverb that says, ``A temporary file is just a pipe with an attitude and a will to live.'' Any number of commands can be pipelined together.

command1 && command2

Execute command1. Then, if it exited with a zero (true) exit status, execute command2.

command1 || command2

Execute command1. Then, if it exited with a non-zero (false) exit status, execute command2.

If any of the redirection constructs is preceded by a digit, then it applies to the file descriptor with that number, rather than the default (0 or 1, as the case may be). For instance,

command 2>&1 > filename

associates file descriptor 2 (standard error) with the same file as file descriptor 1 (standard output), then redirects both of them to filename.

This is also useful for printing error messages:

echo "Danger! Danger Will Robinson!" 1>&2

Note that I/O redirections are parsed in the order they are encountered, from left to right. This allows you to do fairly tricky things, including throwing out standard output, and piping standard output to a command.

Functions

When a group of commands occurs several times in a script, it is useful to define a function. Defining a function is a lot like creating a mini-script within a script.

A function is defined using

name () {
commands
}

and is invoked like any other command:

name args...

You can redirect a function's I/O, embed it in backquotes, etc., just like any other command.

One way in which functions differ from external scripts is that the shell does not spawn a subshell to execute them. This means that if you set a variable inside a function, the new value will be visible outside of the function.

A function can use return n to terminate with an exit status of n. Obviously, it can also exit n, but that would terminate the entire script.

Function arguments

A function can take command-line arguments, just like any script. Intuitively enough, these are available through $1, $2... $9 just like the main script.

Useful utilities

There are a number of commands that aren't part of sh, but are often used inside sh scripts. These include:

basename

basename pathname prints the last component of pathname:

basename /foo/bar/baz

prints

baz

dirname

The complement of basename: dirname pathname prints all but the last component of pathname, that is the directory part: pathname:

dirname /foo/bar/baz

prints

/foo/bar

/bin/[ is another name for /bin/test. It evaluates its arguments as a boolean expression, and exits with an exit code of 0 if it is true, or 1 if it is false.

If test is invoked as [, then it requires a closing bracket ] as its last argument. Otherwise, there must be no closing bracket.

test understands the following expressions, among others:

-e filename

True if filename exists.

-d filename

True if filename exists and is a directory.

-f filename

True if filename exists and is a plain file.

-h filename

True if filename exists and is a symbolic link.

-r filename

True if filename exists and is readable.

-w filename

True if filename exists and is writable.

-n string

True if the length of string is non-zero.

-z string

True if the length of string is zero.

string

True if string is not the empty string.

s1 = s2

True if the strings s1 and s2 are identical.

s1 != s2

True if the strings s1 and s2 are not identical.

n1 -eq n2

True if the numbers n1 and n2 are equal.

n1 -ne n2

True if the numbers n1 and n2 are not equal.

n1 -gt n2

True if the number n1 is greater than n2.

n1 -ge n2

True if the number n1 is greater than or equal to n2.

n1 -lt n2

True if the number n1 is less than n2.