Out of your shell

lecture in color

Out of your shell

First step to 'power' UNIX usage: master 'the shell'.
Not just what you type commands into.
But also a full programming language.
With the power to act as glue between other programs.

A Shell

What the user talks to.
Many varieties:
- csh (c-shell)
- tcsh (t-shell, our default)
- sh (Bourne shell)
- bash (Bourne-again shell)
- ksh (Korn shell)
- etc.

the 'outer layer' of the UNIX system:

 
The UNIX architecture
+---------------------------+
| a shell                   |
| +-----------------------+ |
| | programs              | |
| | +-------------------+ | |
| | | system calls      | | |
| | | +---------------+ | | |
| | | | the kernel    | | | |
| | | |               | | | |
| | | |               | | | |
| | | |               | | | |
| | | |               | | | |
| | | +---------------+ | | |
| | +-------------------+ | |
| +-----------------------+ |
+---------------------------+

The T-Shell

Based upon the C-shell (man csh).
With several extensions (man tcsh).
A complete programming language with C-like syntax.

Some important T-Shell Commands

set prompt = '% ' - set a shell variable
- private to this copy of the shell.
- used in shell scripting.
setenv PATH /local/bin:/usr/bin:/bin - set an environment variable
- inherited by all commands or executed programs.
- used to convey options to commands.
foreach
```
foreach file (*)
  echo $file
end
```
prints all names of files in the current directory. * is replaced with the names of all files in your current directory. This little script does the same thing (roughly) as the ls command.

while

 
set i = 0
while ($i < 10) 
  echo i=$i
  @ i = $i + 1
end

prints

 
i=0
i=1
i=2
i=3
i=4
i=5
i=6
i=7
i=8
i=9

if
```
if ($i<5) echo 'hi'
```
or
```
if ($i<5) then
  echo 'hi'
else
  echo 'ho'
endif
```
Any number of commands can be between then..else..endif just as in the C if statement.
source file - treat file as if it was typed and execute each command.
Much more. See man csh and man tcsh

Command-line scanning and substitution

To understand the shell, one has to realize first that every command is preprocessed before execution.
There are five kinds of preprocessing:
- Inline execution: utilize backquotes to run a subprogram inside a command.
- History substitution: replacing !29 with the text of the 29th command issued.
- Alias substitution: replacing aliases (shorthands) with their meanings as appropriate.
- Variable substitution: replacing $var with the value of the variable var
- Globbing: replacing patterns that represent filenames with the filenames that they match.
The actual command that gets executed is the result of all these forms of pre-processing, in order.

Examples of substitution

History substitution:
```
 
% !gcc
```
execute the last command typed that begins with the characters gcc.

Alias substitution:

 
% alias m more
% m file # means 'more file'

Variable substitution

 
% set foo = bar
% more $foo # means 'more bar'

Globbing:

 
% ls 
a.c   b.c   c.c   d.out
% lp -d hp0 *.c # means 'lp -d hp0 a.c b.c c.c'

An advanced example: several substitutions on the same line:
```
 
% m $foo ; !! # means 'more bar ; lp -d hp0 a.c b.c c.c'
```
- !! becomes the previous command.
- m becomes more.
- $foo becomes bar.
- *.c is in the text of the !! is replaced by the files it matches.
- in this order
To see the effects of this substitution,
```
 
% set verbose
```
This will cause the shell to print the results of substitution before executing each of the commands you type. This is an example of a shell variable.

Shell Variables

Can be utilized for programming purposes.
But variables with particular reserved names control what the shell itself does.
set: sets a value of a variable.
unset: makes the value of a variable undefined.
Can be treated as strings or arrays.
```
% set foo = (a bee sea)
% echo $foo
a bee sea
% echo $foo[1]
a
% echo $foo[2]
bee
% echo $foo[3]
sea
```
- (a bee sea) - an array of three things.
- If you print just $foo, you concatenate the array together.

Accessing variables

$foo: value of variable foo
$?foo: 1 if variable foo has a value, 0 if not.
$#foo: for an array, the number of elements.
$foo[2]: for an array, the second element.
$foo[2-4]: for an array, the subarray containing elements 2, 3, and 4.
Much more! See man csh.

Watch out

Arrays are a matter of convenience.
Anything typed inside () is parsed into words and becomes an array.
Anything outside () becomes a simple string.
So we can freely convert between arrays and scalars and back again just by placing things inside () or not.

This creates some rather mysterious behavior:

 
% set foo = (a b c)
% echo $?bar
0
% set bar = $foo[2-$#foo]
% echo $?bar
1
% echo $bar
b
% echo $#bar
1
% echo $bar[1]
b
% echo $bar[2]
bar: Subscript out of range.

% # now let's try that with parens: 
% set bar = ( $foo[2-$#foo] ) 
% echo $bar
b c
% echo $#bar
2
% echo $bar[1]
b
% echo $bar[2]
c

Weird:if you get the value of an array, but don't put it in (), it ceases to be an array.
In this case, only the first element becomes the value of the variable.

Some important shell variables

The problem with shell variables is that many of them mean something so that their names are reserved. See man csh for a list.
mail - how to warn me of incoming mail.
```
 
set mail = (60 /var/mail/couch)
```
checks every 60 seconds for updates to /var/mail/couch.
- (60 /var/mail/couch) is an array.
- $mail[1] is a number of seconds.
- $mail[2] is your incoming mail directory.
history - control how many commands are saved in the command history.
```
% set history=50
% set savehist=30
```
- This continually saves the last 50 commands you type, so that the history command recalls them.
- This also saves the last 30 commands when you log out and puts them back in your shell when you log back in.

prompt - how shell prompts you for input:

% set prompt='by your command? '
by your command?

and numerous others.

Environment Variables

Control execution of commands outside the shell.
setenv PATH /local/bin:/usr/bin - set a list of directories in which to search for commands, in order.
- tcsh pre-reads this directory to make a hash table of commands.
- If you add a command, must type the magical command rehash to tell it to read directories again.
- A typical EECS path:
```
 
% echo $PATH
.:/u/f/couch/bin:/u/f/couch:/local/sol/5.7/bin:/local/bin:/local/games:/usr/openwin/bin:/usr/bin:/usr/ucb:/usr/ccs/bin:/local/hosts
```
- The special directory . represents your current directory, the one that ls would list.
setenv TERM vt100 - inform editors of what terminal you're using:
- vt100 - DEC vt100 emulator
- xterm - xterm shell window
- ansi - ansi standard terminal
setenv EDITOR emacs - what's your editing preference?
setenv LD_LIBRARY_PATH /local/lib:/local/sol/2.7/lib - where should the linker and programs look for their static (.o, .a) and dynamic shared (.so, .sa) libraries.
setenv MANPATH /local/man:/usr/share/man - where should the man command look for manual pages?

A few variables are strange

shell variable term is also known as environment variable TERM.

shell variable path is also known as environment variable PATH.

 
% echo $path
. /u/f/couch/bin /u/f/couch /local/sol/5.7/bin /local/bin /local/games /usr/openwin/bin /usr/bin /usr/ucb /usr/ccs/bin /local/hosts
% echo $PATH
.:/u/f/couch/bin:/u/f/couch:/local/sol/5.7/bin:/local/bin:/local/games:/usr/openwin/bin:/usr/bin:/usr/ucb:/usr/ccs/bin:/local/hosts

Setting one also automatically sets the other. They're aliases for one another.

Quoting of strings

Can control how string substitutions occur by using different kinds of quoting.
Three kinds of strings: '...', "...", `...`.
'a literal string'
```
 
% echo 'a $literal string'
a $literal string
```
Not evaluated; stops all substitution from happening.

"an $evaluated string"

 
% set evaluated = 'foo'
% echo "an $evaluated string"
an foo string

Evaluated; variable substitution occurs.

`an executed string`
```
 
% echo `users`
couch root
```
where couch and root are the only users logged in now. This executes its contents as a command and then substitutes the output of the command into the current line with no line breaks.
```
% users
couch
root
% echo `users`
couch root
```

Input and output

Each shell command can read from or write to files.
command < file - read input from file.
command > file - send output to file.
command >> file - append output to end of file.
command >& file - send output to file (with error messages inserted).
command >>& file - append output to file (with error messages inserted).
command << STRING - read input up to where STRING occurs, make this input to the command. Example:
```
 
% cat <<SOMETHING
hi there
ho there
SOMETHING
hi there
ho there
%
```
The shell can also glue the output of one command to the input of another.
c1 | c2 - send the output from command c1 to command c2.
c1 |& c2 - send the output from command c1 (with error messages inserted) to command c2.

A complex example:

c1 <in | c2 |& c3 >out 
 
 start c1 and send file in to it as input. 
 Send the output of c1 to c2, 
 and send the output of c2 to c3 with error
messages inserted in the output. 
 Put the result of c3 into the file out.

Pattern matching

Often have to indicate filenames to the shell.
The shell allows one to use shorthands for filenames.
The process of interpreting the shorthands is called globbing.
The shell command
```
 
set noglob
```
turns off this pattern matching while the shell command
```
 
unset noglob
```
turns it back on.
Patterns we use for matching files are a superset of regular expressions.

Regular Expressions

Goal of shell regular expressions (RE's): make it easier to specify filenames as arguments to commands.
Shell RE syntax is different from all other RE syntaxes, particularly those found in emacs, vi, perl, php, and javascript! Further, all of those other syntaxes are the same!.
? matches any one character (except /).
* matches 0 or more arbitrary characters (except /).
[123] matches either '1', '2', or '3' in this position.
Backslashes turn off special character meanings.
\*, \?, \[123\] match the literal characters *, ?, [123].
One special case: {hi,ho} means to replicate the pattern, once with hi, once with ho. This is not a matching statement. E.g., {foo,bar}.[ch] means foo.[ch] bar.[ch].
To match literal { and } use \{ and \}.

Regular Expression Examples

*.[ch] - every file ending in .c or .h.
.??* - every file whose name starts with ., and contains at least two other characters (and possibly more).
[a-f]*.c - any file that starts with a character between a and f and ends in .c (with anything at all between these).

Problem of the day #1

Suppose we have a directory containing the files

`3com-config`	`4.Xupdate`	`5.Xupdate`	`Procedures`	`adaptec`
`adduser`	`apachectl`	`backref.out`	`backref.pl`	`block-schedule`
`boot.sun3`	`cabletron`	`choosing2`	`cisco`	`client.pl`
`config`	`core`	`cpack`	`dec`	`deptinfo`
`digs`	`disaster`	`doall`	`dos`	`etc`
`fvwm`	`global`	`hostkeys`	`hostmap`	`jump`
`kirby`	`largo`	`lci3200`	`linux`	`lsr`
`mac`	`machines`	`makedb`	`manual.pages`	`mgc_printer`
`monitor`	`monsta`	`move`	`naming`	`netsight`
`nis`	`patches`	`pgp`	`policia`	`policy`
`priorities`	`problem`	`purchases`	`remexec`	`restore`
`sofa`	`squirrel`	`src`	`ssh`	`tccs`
`training`	`transfer`	`transpond`	`ua`	`uptimes`
`use`	`users`	`webauth`	`words`	`x`

What actual commands are interpreted by the shell when you type the following?

ls -l c*
echo *_*
more m*_*r m*.*s

Creating your own shell script

edit the script into a file.
```
 
vi foo
```
change first line of file to
```
 
#! /bin/csh
```
make the file 'executable':
```
 
chmod +x foo
```
Then typing
```
 
% foo
```
will execute your script as if you'd typed it!

The UNIX philosophy

Lots of little tools and programs.
Shell acts as glue between programs.
The whole is greater than the sum of its parts.

Simple UNIX shell hacks

write a message to all currently logged-in users:

contents of out/write.csh...
#! /bin/csh -f -b 
foreach person (`users`)
write $person <<EOF
hi there, i\'m me\!
EOF
end
...end of out/write.csh

logout all your sessions on a machine, not just the one you're in:

contents of out/die.csh...
#! /bin/csh -f -b
set processes = (`ps -ef | awk '$1 == "'$USER'" {print $2}'`)
kill -9 $processes
...end of out/die.csh

How to understand a complex shell script:

Work from inside to outside.
Cut and paste things into the shell to see what they do.
set echo to watch the script execute.
set verbose to get the shell to tell you what it's doing.

Problem of the day #2

What do you think the following shell script does? How would you verify your theory?
```
 
foreach file (*)
  set size = (`du -s $file`) 
  if ($size[1] > 10000) then 
     echo $size[1] $file
  endif
end
```
Note: I fixed it to really work, after the lecture.

Common shell duties

Specify environment variables that provide options to complex systems.
Customize each user's environment so they can access what they need.

Property Inheritance

Important concept: subprocesses executed by a shell inherit properties from the parent shell.
Inherited:
- Environment variables.
- Open file descriptors, e.g., stdin, stdout, stderr.
Not inherited:
- Shell variables.
- Aliases.
- History.
- Most everything else.
For more details, see man execl. execl is the subroutine that executes a new child process.

Digging deeper: how the shell executes children

Perform substitutions on command string.
Parse your command into arguments.

Place these into an array of char *, i.e.,

 
   char *command="/usr/bin/cat"; // command to execute; 
   char *argv[] = {"foo.c", "bar.c" , NULL}; // arguments;

Then execute (roughly) the following C code:

 
    int pid;    // pid of child, or 0 for child
    int status; // exit code
    if (pid=fork()) { 
	// I'm the parent; wait for command to finish
        waitpid(pid,&status,0); 
        // command is done now!
    } else { 
        execv(command,argv); 	
        // no return from this call!
    } 
    // after this, status contains exit code of process.

fork() clones a process completely.
After the fork, all is duplicated.
execv(...) replaces one clone with the execution of a new command.
Only environment variables are preserved!
For more details, see man 2 wait, man 2 fork, man 2 execv. 2=system calls.

Specifying options to Complex Systems

Environment variables also specify options for complex programs.

Example: /local/env/mentor.cshrc

contents of out/mentor.cshrc...
# cshrc source for the mentor package
setenv MGC_HOME /loc/mentor
setenv MGLS_LICENSE_FILE $MGC_HOME/etc/cust/mgls/mgc.licenses
set path = ($MGC_HOME/bin $path)
set path=($path /loc/mentor/tufts/mdk/bin)
# set MGC_LOCATION_MAP
setenv MGC_LOCATION_MAP /loc/mentor/etc/mgc_location_map
# set AMPLE_PATH
if (! $?AMPLE_PATH) then
        setenv AMPLE_PATH /loc/mentor/tufts/mdk/userware
else
        setenv AMPLE_PATH /loc/mentor/tufts/mdk/userware:${AMPLE_PATH}
endif
...end of out/mentor.cshrc

This does several things:
- Change the PATH variable so the program will be found.
- Change the MANPATH so the documentation is available to the man command.
- Set other options only understood by Mentor Graphics programs.

Customizing User Environments

Must tell each shell how to execute commands that each user needs.
Can do this because each shell, when it begins executing, reads and interprets several files automatically.

Shell startup

All instances of tcsh read and execute all commands in /etc/.cshrc, followed by commands in ~/.cshrc (unless overridden by user, -fb flag).
- This includes shells invoked to interpret files of commands.
- .cshrc should set important shell variables and aliases.
tcsh login shells then also executes commands from /etc/.login, followed by ~/.login.
- First shell you get after login.
- Shows up in w.
- .login sets important environment variables (once).

A brief tour of EECS user login

tcsh login shell invoked.

reads /etc/.cshrc:

contents of out/etc.cshrc...
# Standard C-shell startup actions for eecs.tufts.edu
#
# This file will be changed from time to time, so if you wish to modify its 
# effects it is better to run this and then change things than to copy and
# modify this file.

# check if this person is allowed in; block if not
if (-f /etc/csh.people) then 
    set tcshAllowed = 0
    foreach tcshPerson (`/bin/cat /etc/csh.people`)
        if ($tcshPerson == $USER) then
            set tcshAllowed = 1
        endif
    end
    if ($tcshAllowed == 0) then
        echo Sorry, you are not allowed to login to `/bin/hostname`
        echo Please use a timesharing server instead!
        sleep 4
        exec /bin/false
    endif
    unset tcshAllowed
    unset tcshPerson
endif 

set autologout=60
limit coredumpsize 1m

# Set up CLASSES environment variable if not already set up.
# This only happens at login time.
# If you `unsetenv CLASSES' then every shell instance will set it again.
# To disable the list of classes you must `setenv CLASSES ""'.
if (! $?CLASSES) then
  # Get a list of classes I belong to.  This takes a little time.
  if (-r /local/etc/ac-classes) then
      set Classes = (`awk '$3=="'$user'"{print $2}' /local/etc/ac-classes`)
  else
      set Classes= 
  endif
  # If there are any, then put the list into the environment separated with :
  if ($#Classes > 0) then
    setenv CLASS $Classes[1]
    setenv CLASSES `echo $Classes | tr ' ' ':'`
  # If not, set environment variable empty so we do not check again
  else
    set Classes=
    setenv CLASSES ""
  endif
else
  # Convert environment variable to shell variable
  set Classes=(`echo $CLASSES | tr ":" " "`)
endif

# set up standard paths without the window system
set path=(. ~/bin ~ /local/bin /local/games /usr/bin /usr/ucb /usr/ccs/bin /local/hosts)
setenv MANPATH /local/man:/usr/share/man
setenv LD_LIBRARY_PATH /local/lib:/usr/ccs/lib

# modify standard paths for X windows
setenv LD_LIBRARY_PATH /loc/X11/lib:$LD_LIBRARY_PATH

# modify standard paths for Sun Motif runtime package
setenv LD_LIBRARY_PATH /usr/dt/lib:$LD_LIBRARY_PATH

# modify standard paths for OpenWindows
# commenting these statements out will disable OpenWindows
if (! $?OPENWINHOME) setenv OPENWINHOME /usr/openwin
# put the openwin bins behind local bins and ahead of system bins
set path=($path[1-5] ${OPENWINHOME}/bin $path[6-])
setenv MANPATH ${MANPATH}:${OPENWINHOME}/share/man
# openwin libraries take precedence over x11 libraries in /local/lib
setenv LD_LIBRARY_PATH ${OPENWINHOME}/lib:${LD_LIBRARY_PATH}
setenv FONTPATH ${OPENWINHOME}/lib/fonts
setenv HELPPATH ${OPENWINHOME}/lib/help

# add local app-defaults
# dert 1999-09-23
setenv XAPPLRESDIR /local/X11/lib/X11/app-defaults

# modify standard paths for subarchitecture-dependent code. 
# this code is stored in /local/mach/<machine>/bin for each 
# machine as specified in uname -n

set host = `uname -n`
if ( -d /local/mach/$host/bin ) then
    set path=($path[1-3] /local/mach/$host/bin $path[4-])
endif 
if (-d /local/mach/$host/lib ) then
    setenv LD_LIBRARY_PATH ${LD_LIBRARY_PATH}:/local/mach/$host/lib
endif
if (-d /local/mach/$host/man ) then
    setenv MANPATH ${MANPATH}:/local/mach/$host/man
endif
unset host

# put in os-revision-dependent stuff if present
# this code is stored in /local/solaris/<revision>/bin for each 
# for each Solaris revision as specified in uname -r

set rev = `uname -r`
if ( -d /local/sol/$rev/bin ) then
    set path=($path[1-3] /local/sol/$rev/bin $path[4-])
endif
if (-d /local/sol/$rev/lib ) then
    setenv LD_LIBRARY_PATH /local/sol/$rev/lib:${LD_LIBRARY_PATH}
endif
if (-d /local/sol/$rev/man ) then
    setenv MANPATH /local/sol/$rev/man:${MANPATH}
endif
unset rev

# Use other script to invoke class-specific cshrc files.
# This is done this way so that anyone can run the script explicitly.

if ($#Classes > 0) then
  if(x$Classes[1] != x && -r /local/etc/class.cshrc) then
    # Invoke class-specific cshrc files.
    source /local/etc/class.cshrc 
  endif
endif
# Release shell variable, leave environment variable around
unset Classes

# special alias allows users to decide what packages to use. 
alias use 'set packages = ( \!* ) ; source /local/lib/use'

### This was taking too much login time due to disk cacheing; 
### I disabled it 3/21/98 alc
### use -q frame idl magic meta speedsim
### use -q frame idl magic
use -q netscape
...end of out/etc.cshrc

which in turn reads/local/etc/Class_cshrc

contents of out/Class_cshrc...
#! /bin/tcsh -fb
# Class-specific shell startup actions for cs.tufts.edu
#
# This file should be sourced after the shell variable CLASSES has been
# set up as a word list of classes:  e.g. `setenv CLASSES 11:15:280; source...'
# As a side effect, this script kills the variables Classes and TheClass

if ($?CLASSES) then
  # Convert environment variable to shell variable
  set Classes=(`echo $CLASSES | tr ":" " "`)
  # If there are any appropriate classes,
  if ($?Classes) then
    if ($#Classes > 0) then
      if (x$Classes[1] != x) then 
	# Invoke class-specific cshrc files
	foreach TheClass ($Classes)
	  if (-r /g/$TheClass/Class_cshrc) source /g/$TheClass/Class_cshrc
	end
	unset TheClass
      endif
    endif
  endif
endif
...end of out/Class_cshrc

reads ~/.cshrc:

contents of out/home.cshrc...
# C-shell and T-shell initialization file for Tufts University
#######################################################################
#  This file controls options and behavior of the command interpreter,
#  by executing a standard script that is the same for all users. 
#
#  To customize your shell, either
#  1) (preferred) add your personal preferences to the end 
#     of this file, after the line `source /local/etc/standard.cshrc'
#  2) (advanced)  replace this file by the standard script
#     /local/etc/standard.cshrc and edit it to suit your own tastes. 
#
#     To do 2), while in your home,
#     a) cp /local/etc/standard.cshrc .cshrc
#     b) emacs .cshrc (to make changes). 
#     But if you mess up your environment, so that nothing works, 
#     you must restore the old state of your account by: 
#     c) cp /local/etc/template.cshrc .cshrc
#######################################################################

# Execute the standard startup file.
source /local/etc/standard.cshrc

# Put your own custom commands here -- 
# uncomment the following ones for some common abbreviations

# alias a alias
# alias h history
# alias m more
# alias e emacs
...end of out/home.cshrc

which in turn reads /local/etc/standard.cshrc:

contents of out/standard.cshrc...
# @(#)Cshrc 1.1 86/01/06 SMI; 
#################################################################
#
#         .cshrc file
#
#         initial setups for both interactive and noninteractive
#         C-Shells
#
#################################################################

#       If executing the normal C-shell, still read system-wide init file
 
if ($?SHELL != 0) then
    if ($SHELL == /bin/csh && -r /etc/csh.cshrc) source /etc/csh.cshrc
endif

# Set default file protection off limits to others
umask 077

# Exit this script if this is not an interactive shell
if ($?USER == 0 || $?prompt == 0) exit

# Enable shell histories
set history=50
set savehist=50

# Enable filename completion in case you use csh instead of default tcsh
# (the ESCAPE key will try to finish file names)
set filec

# Limit core dumps to something reasonable (3 Megabytes) just to avoid
#	accidentally creating huge useless files.
limit coredumpsize 3m

# To allow control-D for logout, comment out the following line.
set ignoreeof

# Use a prompt like presto{bjones}1:
if ("$prompt" == "> " || "$prompt" == "% ") set prompt="`uname -n`{`whoami`}\!: "

# To shorten some common commands, un-comment the following lines.

# alias a        alias
# alias h        history
# alias m        more

# figure out operating system from uname command
set opsys = `/usr/bin/uname -s`

# Sun Microsystems Special initialization
if ($opsys == 'SunOs') then 
    # execute these commands on all SunOS systems: 
    # disable job control :  comment out these two lines to enable it. 
    stty susp undef
    stty dsusp undef

# Silicon Graphics Special initialization
else if ($opsys == 'IRIX') then
    # execute these commands on ALL IRIX systems:
    if (`/usr/bin/uname -r | /usr/bin/awk -F. '{print $1}'` >=6) then
	# execute these commands on IRIX 6.x systems and above: 
	# disable job control :  comment out these two lines to enable it. 
	stty susp undef
	stty dsusp undef
    else 
	# execute these commands on IRIX 5.x systems and below: 
	# disable job control :  comment out these two lines to enable it. 
	stty susp ^
	stty dsusp ^
    endif

# Dec Alpha Special initialization
else if ($opsys == 'OSF1') then
    # execute these commands on ALL OSF/1 systems: 
    # disable job control :  comment out these two lines to enable it. 
    stty susp undef
    stty dsusp undef

# Dec MIPS Special initialization
else if ($opsys == 'ULTRIX') then
   # execute these commands on ALL ULTRIX systems: 
    # disable job control :  comment out these two lines to enable it. 
   stty susp undef
   stty dsusp undef
endif

unset opsys
...end of out/standard.cshrc

Then the shell reads /etc/.login:

contents of out/etc.login...
# Standard login actions for eecs.tufts.edu
#
# This file will be changed from time to time, so if you wish to modify its 
# effects it is better to run this and then change things than to copy and
# modify this file.

# keep people out during system work 
if (-f /etc/nologin) then
    echo No logins -- system is not available for general use. 
    echo Please try again later. 
    sleep 4
    logout
endif

# show messages of the day
/usr/bin/cat /etc/motd
if (-f /local/bin/motd && -d /g/motd/news) then
    /local/bin/motd -sq all
endif

# Use class.login script to invoke class-specific login files.
# This is done this way so that anyone can run the script explicitly.
if ($?CLASSES) then
  # Convert environment variable to shell variable
  set Classes=(`echo $CLASSES | tr ":" " "`)
  if ($#Classes > 0) then
    if(x$Classes[1] != x && -r /local/etc/class.login) then 
      # Invoke class-specific login files.
      source /local/etc/class.login
    endif
  endif
  # Release shell variable
  unset Classes
endif
...end of out/etc.login

which in turn reads/local/etc/Class_cshrc

contents of out/Class_login...
#! /bin/tcsh -fb
# Class-specific login actions for cs.tufts.edu
#
# This file should be sourced after the shell variable CLASSES has been
# set up as a word list of classes:  e.g. `setenv CLASSES 11:15:280; source...'
# As a side effect, this script kills the variables Classes and TheClass

if ($?CLASSES) then 
  # Convert environment variable to shell variable
  set Classes=(`echo $CLASSES | tr ":" " "`)
  # If there are any appropriate classes,
  if ($?Classes) then
    if ($#Classes > 0) then
      if (x$Classes[1] != x) then 
	# Invoke class-specific login files
	foreach TheClass ($Classes)
	  if (-r /g/$TheClass/Class_login) source /g/$TheClass/Class_login
	end
	unset TheClass
      endif
    endif
  endif
endif
...end of out/Class_login

followed by ~/.login:

contents of out/user.login...
# C-shell and T-shell initialization file for Tufts University
#######################################################################
#  This file controls options and behavior of the command interpreter,
#  by executing a standard script that is the same for all users. 
#
#  To customize your shell, #  replace this file by the standard script
#  /local/etc/standard.login and edit it to suit your own tastes. 
#     While in your home,
#     a) cp /local/etc/standard.login .login
#     b) emacs .login (to make changes). 
#     But if you mess up your environment, so that nothing works, 
#     you must restore the old state of your account by: 
#     c) cp /local/etc/template.login .login
#######################################################################

# Execute the standard startup file.
source /local/etc/standard.login
...end of out/user.login

which reads /local/etc/standard.login:

contents of out/standard.login...
# @(#)Login 1.1 86/01/06 SMI; 
##################################################################
#
#         .login file
#
#         Read in after the .cshrc file when you log in.
#         Not read in for subsequent shells.  For setting up
#         terminal and global environment characteristics.
#
##################################################################


#	If executing the normal C-shell, still read system-wide init file

if ($?SHELL != 0) then
    if ($SHELL == /bin/csh && -r /etc/csh.login) source /etc/csh.login
endif

#       terminal characteristics for remote terminals:
#	default is vt100 for ALL remote terminals

if ($?TERM == 0) then
    setenv TERM vt100
endif

#       general terminal characteristics

# Un-comment the following line to use control-H (backspace) for DELETE
# stty erase '^h'

#       environment variables

# Tell the "more" command to erase the screen before displaying each page
setenv MORE '-c'

# figure out operating system from uname command
set opsys = `/usr/bin/uname -s`

# Sun Microsystems Special initialization
if ($opsys == 'SunOs') then 
    # execute these commands on all SunOs systems
    set noglob
    set term = `/usr/ucb/tset - -IQ -m unknown:?vt100 -m network:?vt100 -m dialup:?vt100 $TERM`
    unset noglob
    # start up openwindows if on a workstation
    if ("`tty`" == "/dev/console") then
	# First give the user a chance to bail out 
	echo -n "Openwin? (^C to interrupt)"
	# A control-C during this sleep will simply skip the rest of this file
	# and leave the user in an ordinary shell 
	sleep 5 ; echo ' '
	/usr/openwin/bin/openwin
	# After exiting openwin, log out by default 
	echo -n "Logging out... (^C to stay logged in)"
	# A control-C during this sleep will skip the logout and leave the user 
	# in an ordinary shell 
	sleep 5 ; echo ' '
	logout
    endif 

# Silicon Graphics Special initialization
else if ($opsys == 'IRIX') then
    # execute these commands on ALL IRIX systems:
    if (`/usr/bin/uname -r | /usr/bin/awk -F. '{print $1}'` >=6) then
	# execute these commands on IRIX 6.x systems and above: 
    else 
	# execute these commands on IRIX 5.x systems and below: 
    endif

# Dec Alpha Special initialization
else if ($opsys == 'OSF1') then
    # execute these commands on ALL OSF/1 systems: 

# Dec MIPS Special initialization
else if ($opsys == 'ULTRIX') then
   # execute these commands on ALL ULTRIX systems: 
endif

unset opsys
...end of out/standard.login

Some dirty hacks

How we customize environments for classes.
- set environment variables CLASS to the one class that you're taking, and CLASSES to the list of classes you're taking in total (by querying /local/etc/ac-classes).
- For each class $c:
  - /etc/.cshrc sources /local/etc/Class_cshrc, which sources /g/$c/Class_cshrc for each class!
  - /etc/.login sources /local/etc/Class_login, which sources /g/$c/Class_login!

How we deal with environment variable clutter:

alias use 'set packages = ( \!* ) ; source /local/lib/use'

where /local/lib/use is:

contents of out/use...
#! /usr/bin/tcsh 
# support for configuration of large packages for selective use 
# this file MUST BE SOURCED in order to work properly. 
# this script is SOURCED as a result of the alias: 
# alias use 'set packages = ( \!* ) ; source /local/lib/use'
# in /etc/csh.cshrc!

if ($?packages) then 
    if ($packages[1] == '-q') then 
	shift packages
	set packages_no_echo
    endif
    foreach pkg ($packages)
	if (-f /local/env/$pkg.cshrc) then
	    if (! $?packages_no_echo) then
		echo Using package $pkg : setting up your environment
	    endif
	    source /local/env/$pkg.cshrc
	else
	    if (! $?packages_no_echo) then
		echo There is no package $pkg -- please check your spelling
	    endif
	endif
    end
else 
     echo You must specify a package to use\!
endif
unset packages
unset packages_no_echo
...end of out/use

use mentor - set up environment for Mentor Graphics.
use frame - set up environment for FrameMaker.

lecture in color

/comp/150NET/notes/out.php
downloaded on Nov-23-2009 02:27:35 PM,
was last modified on Feb-17-2004 10:49:14 PM.
All lecture note content is copyright 2004 by
Alva L. Couch, Computer Science, Tufts University