Invoking a Shell Script

• With the exception of shell built-ins, when the shell is given a command line to execute, the shell forks, creating a sub-shell
• The sub-shell attempts to execute the command using the system call exec()
• If the command is an executable program, exec() generally succeeds
• If the command is a shell script, exec() will fail
• When exec fails, the systems assumes that the command is a shell script
• The sub-shell then runs the commands in the script
• The sub-shell takes input from a file: the file is the shell script
• The sub-shell does not take input from the command line as does the login shell
• There are at least two ways to run a shell script


• Remember that when a document is created with a text editor (like vi), the execute permission is not typically set
  
• Since this is the case, a shell script cannot be run from the shell because the execute permission of the file is not set...even if you are the owner of the script
• The execute permissions can be changed by using chmod

Example:
$ chmod u+x filename will give the owner execute permissions

• With the execute permission set, the user (owner in this case) can execute the shell script directly from the command line
• Obviously, permissions must be set for group and other for execution by all users

Example:
$ shell_script_name

Shell scripts can be run even if the user does not have execute permission
• This is done by using a bash command to exec a new shell that will run the script directly

Example $ bash shell_script_name
Note
• The second method is inferior to the first
• Why? Because the script runs slower due to the extra layer of complexity created by the new shell and the system overhead involved

Separating and Grouping Commands

Parameters and Variables

• Inside the shell, a shell parameter is associated with a value that is typically accessible to the user
• Shell parameters are sometimes called shell variables (variables for short)
• There are several kinds of shell variables
• Variable names consist of letters, digits and underscores
• Variable names cannot start with a digit
• Examples of Legal Variable Names
• myVar
• chk_vars
• del_3_files
• MY_PATH
• Examples of Illegal Variable Names
• 23Pages
• MY PATH
• 3-blind-mice
• EXPORT variables are accessible to shells and other programs
• EXPORT variable names are usually uppercase, most other variable names are MixedCase
• A variable is a place in memory that contains a value
• A variable name is an alias for the address of the memory cell(s)
• Variable syntax is:
  VARIABLE=value
• System Variables (HOME, PATH, etc) are reserved for system use. Note the use of uppercase
• User-Defined variables are created by users and cannot use RESERVED WORDS

The export Builtin

• Variables are usually local to the process in which they are declared
• The export builtin is used to make variables available to child processes (other processes)
• When export is used, a copy of the variable used as an argument to export is placed in the environment of the child process for its own use

Example without the use of export

here are the scripts

bash$ cat subtest // contents of script subtest
echo "subtest 1: $cheese" // subtest can’t see contents of cheese from //above
cheese=swiss // assign a value to cheese in subtest
echo "subtest 2: $cheese" // echo contents of cheese 2nd time

here's the run...no export

Example using export

here are the scripts

bash$ cat subtest
echo "subtest 1: $cheese" // use GLOBAL value of cheese
cheese=swiss // assign a LOCAL value to cheese
echo "subtest 2: $cheese" // display LOCAL value of cheese

here's the run...using export

Example using export in combination with a variable declaration

here are the scripts

bash$ cat subtest
echo "subtest 1: $cheese"
cheese=swiss
echo "subtest 2: $cheese"

here's the run...using export in combination with a variable declaration

Pathname Expansion

• All shells interpret special characters as special when the shell references an unquoted special character as part of the string
  Example:

  $ tests=rgrogan534*
  $ echo "$tests"
  rgrogan534*
  $
  $
  $
  $ ls
  rgrogan534.test1
  rgrogan534.test2
  $
  $ echo $tests
  rgrogan534.test1 rgrogan534.test2

• The shell expands $tests to rgrogan534* then expands
  rgrogan534* to rgrogan534.test1 and rgrogan534.test2

Removing a variable with unset

• Unless a variable is REMOVED, it exists as long as the shell it was declared in exists
  Example:

  $ tests=rgrogan534*
  $ tests= # removes VALUE from test
  $ echo $tests
  
  $ unset tests # note there is no dollar preceding the var name
  

declare and typeset assign attributes to variables

• declare and typeset mean and do the same thing
• they set attributes and values for shell variables
• See table 8-3 page 282 for commonly used shell variable attributes Example:

the PATH environment keyword

• A path statement provides the shell places to look in the filesystem
  when trying to find a command with the corresponding name
• Note that by default, your home directory IS NOT in the path
• By default, when a NEW shell is spawned, the PATH statement doesn't
  exist for the new shell
• Use the export command to provide access to the path for all sub-shells
  Example:

  export PATH=/usr/local/bin:/usr/bin:/bin

• IMPORTANT: a single colon as the FIRST character in the path,
  a single colon as the LAST character in the path, or any two colons
  with nothing between them (anywhere in the path statement) represenr the
  CURRENT WORKING DIRECTORY
  Example 1:

  export PATH=/usr/local/bin:/usr/bin:/bin:

• In the case above, the current directory is at the END of the path. Example 2:

  export PATH=/usr/local/bin::/usr/bin:/bin

• In the case above, the current directory is in the MIDDLE of the path. Example 3:

  export PATH=:/usr/local/bin::/usr/bin:/bin

• In the case above, the current directory is the FIRST directory of the path.
• With regard to the working directory being FIRST in the path, note the security precaution given
  on page 285 of the text

The Command Line Prompts

• PS1 is the primary user prompt. In BASH the default prompt can be changed
  See table 8-4, page 287 for PS1 symbols
• PS2 is the secondary user prompt. In BASH, it usually is used to indicate
  that the system is waiting for more input. BASH default is >
• PS3 is the menu prompt. for use with the select control structure
• PS4 is the debugging prompt. BASH can run a script one line at a time to help
  find a problem that occurs
• The default symbol is the plus ( + ) sign, and it precedes each line that is run
• Note: PS4 must be exported from the shell that creates the sub-shell,
  to the shell that will actually run the script

Process Structure

• Processes are hierarchical
• Processes have a root, parents, and children
• Parent processes fork (spawn) child processes
• fork() is the name of the system call that creates a new process
• When a UNIX machine is booted, PID number 1 is initiated and the process is called init
• init is the mother of all processes during the life of the session (until the system is brought down)
• If terminals are attached to the system, init forks a getty process for each terminal
• When a user logs in to the terminal the getty process becomes a login process
• The login process then becomes the user’s shell process

Processes

• A process is the execution of a command by the OS
• A process will either run in the current shell, or run in a sub-shell
  (child) that was spawned by the parent shell
• A shell built-in does not require a sub-shell (fork a process),
  as it runs in the current shell
• Each process has a PID (process ID), and maybe a PPID (parent process ID)
• The ps -f command will display (for each running process) the username,PID,
  PPID, TIME-of-run, TTY, TIME (elapsed?), and CMD (the name of the running process) Example:

  rgrogan@analog24: $ ps -f
  UID PID PPID C STIME TTY TIME CMD
  rgrogan 31460 31459 3 18:51 pts/2 00:00:00 -bash
  rgrogan 31476 31460 0 18:51 pts/2 00:00:00 ps -f
  rgrogan@analog24: $
  

Various Summaries

• Table 8-5, page 290 summarizes bash keyword variables
• Table 8-6, page 291 summarizes special shell characters

Single/Double Quoting in Aliases

• Using the appropriate quoting method is critical when using variables in aliases

  Example using double-quotes:

  rgrogan@analog24: $ echo $PWD
  /home/rgrogan
  rgrogan@analog24: $ alias dir1=" echo working directory is $PWD"
  rgrogan@analog24: $ alias dir1
  alias dir1=' echo working directory is /home/rgrogan'
  rgrogan@analog24: $
  

  Example using single-quotes:

  rgrogan@analog24: $ echo $PWD
  /home/rgrogan
  rgrogan@analog24: $ alias dir2=' echo working directory is $PWD'
  rgrogan@analog24: $ alias dir2
  alias dir2=' echo working directory is $PWD'
  rgrogan@analog24: $
  

The Order of Command Line Expansion

1. Brace expansion
   Example:

   $ echo List_{AA, BB, CC}
   List_AA List_BB List_CC
   

2. Tilde Expansion...remember the ~ stands for your home directory...see page 326
3. Parameter and Variable Expansion - $myVar will be expanded
   ...quoting type comes into play here
4. Arithmetic Expansion - $((expression))...will be discussed later
5. Command Substition - $(command)...echo "The date is $(date)"
6. Word Splitting: will discuss this later
7. Pathname Expansion -
   Example:

   $ ls
   tmp1 tmp2 tmp3
   $ echo tmp*
   tmp1 tmp2 tmp3
   $ rm tmp*
   $ echo tmp*
   tmp*
   $