CRM_SHADOW(8)							  [FIXME: manual]						     CRM_SHADOW(8)

NAME

       crm_shadow - Perform Configuration Changes in a Sandbox Before Updating The Live Cluster

SYNOPSIS

	   crm_shadow [-V] [-p|-e|-q]

DESCRIPTION

       Sets up an environment in which configuration tools (cibadmin, crm_resource, etc) work offline instead of against a live cluster, allowing
       changes to be previewed and tested for side-effects.

OPTIONS

       --verbose, -V
	   turn on debug info. additional instance increase verbosity

       --which, -w
	   indicate the active shadow copy

       --display, -p
	   display the contents of the shadow copy

       --diff, -d
	   display the changes in the shadow copy

       --create-empty, -eNAME
	   create the named shadow copy with an empty cluster configuration

       --create, -cNAME
	   create the named shadow copy of the active cluster configuration

       --reset, -rNAME
	   recreate the named shadow copy from the active cluster configuration

       --commit, -cNAME
	   upload the contents of the named shadow copy to the cluster

       --delete, -dNAME
	   delete the contents of the named shadow copy

       --edit, -eNAME
	   Edit the contents of the named shadow copy with your favorite editor

       --batch, -b
	   do not spawn a new shell

       --force, -f
	   do not spawn a new shell

       --switch, -s
	   switch to the named shadow copy

INTERNAL COMMANDS

       To work with a shadow configuration, you need to create one first:

	   crm_shadow --create-empty YOUR_NAME

       It gives you an internal shell like the one from the crm tool. Use help to get an overview of all internal commands, or help subcommand for
       a specific command.

       Table 1. Overview of Internal Commands
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|												       |
       |       Command	|	 Syntax/Description									       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     alias [-p] [name[=value] ... ]							       |
       |       alias	|												       |
       |		|												       |
       |		|		.PP										       |
       |		|												       |
       |		|	 alias with no arguments or with the -p 						       |
       |		|	 option prints the list of aliases in the						       |
       |		|	 form alias NAME=VALUE on standard output.						       |
       |		|	 Otherwise, an alias is defined for each						       |
       |		|	 NAME whose VALUE is given. A trailing							       |
       |		|	 space in VALUE causes the next word to be						       |
       |		|	 checked for alias substitution when the						       |
       |		|	 alias is expanded. Alias returns true							       |
       |		|	 unless a NAME is given for which no alias						       |
       |		|	 has been defined.									       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     bg [JOB_SPEC ...]									       |
       |       bg	|												       |
       |		|												       |
       |		|		.PP Place each JOB_SPEC in the							       |
       |		|	 background, as if it had been started with						       |
       |		|	 &. If JOB_SPEC is not present, the shell's						       |
       |		|	 notion of the current job is used.							       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     bind [-lpvsPVS] [-m keymap] [-f filename]						       |
       |       bind	|		[-q name] [-u name] [-r keyseq] 						       |
       |		|		[-x keyseq:shell-command]							       |
       |		|		[keyseq:readline-function or readline-command]					       |
       |		|												       |
       |		|												       |
       |		|		.PP Bind a key sequence to a							       |
       |		|	 Readline function or a macro, or set a 						       |
       |		|	 Readline variable. The non-option argument						       |
       |		|	 syntax is equivalent to that found in							       |
       |		|	 ~/.inputrc, but must be passed as a single						       |
       |		|	 argument: bind "C-xC-r":								       |
       |		|	 re-read-init-file.									       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     break [N]										       |
       |       break	|												       |
       |		|												       |
       |		|		.PP Exit from within a for, while or until					       |
       |		|	 loop. If N is specified, break N levels.						       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     builtin [shell-builtin [arg ...]]							       |
       |       builtin	|												       |
       |		|												       |
       |		|		.PP Run a shell builtin. This is useful when					       |
       |		|	 you wish to rename a shell builtin to be a function,					       |
       |		|	 but need the functionality of the builtin within the					       |
       |		|	 function itself.									       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     caller [EXPR]									       |
       |       caller	|												       |
       |		|												       |
       |		|		.PP Returns the context of the current						       |
       |		|	 subroutine call. Without EXPR, returns $line						       |
       |		|	 $filename. With EXPR, returns $line $subroutine					       |
       |		|	 $filename; this extra information can be used to					       |
       |		|	 provide a stack trace. 								       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     case WORD in [PATTERN [| PATTERN] [COMMANDS;;] ... esac				       |
       |       case	|												       |
       |		|												       |
       |		|		.PP Selectively execute COMMANDS based upon					       |
       |		|	 WORD matching PATTERN. The `|' is used to separate					       |
       |		|	 multiple patterns.									       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     cd [-L|-P] [dir]									       |
       |       cd	|												       |
       |		|												       |
       |		|		.PP Change the current directory to DIR.					       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     command [-pVv]									       |
       |       command	|	     command [arg ...]									       |
       |		|												       |
       |		|												       |
       |		|		.PP Runs COMMAND with ARGS ignoring shell functions.				       |
       |		|	 If you have a shell function called `ls', and you wish to				       |
       |		|	 call the command `ls', you can say "command ls". If the -p				       |
       |		|	 option is given, a default value is used for PATH that is				       |
       |		|	 guaranteed to find all of the standard utilities. If the -V				       |
       |		|	 or -v option is given, a string is printed describing					       |
       |		|	 COMMAND. The -V option produces a more verbose description.				       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     compgen [-abcdefgjksuv] [-o option] [-A action]					       |
       |       compgen	|	       [-G globpat] [-W wordlist] [-P prefix]						       |
       |		|	       [-S suffix] [-X filterpat] [-F function] 					       |
       |		|	       [-C command] [WORD]								       |
       |		|												       |
       |		|												       |
       |		|		.PP Display the possible completions depending on				       |
       |		|	 the options. Intended to be used from within a shell					       |
       |		|	 function generating possible completions. If the optional				       |
       |		|	 WORD argument is supplied, matches against WORD are					       |
       |		|	 generated.										       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     complete [-abcdefgjksuv] [-pr] [-o option] 					       |
       |       complete |		[-A action] [-G globpat] [-W wordlist] [-P prefix]				       |
       |		|		[-S suffix] [-X filterpat] [-F function] [-C command]				       |
       |		|		[name ...]									       |
       |		|												       |
       |		|												       |
       |		|		.PP For each NAME, specify how arguments are to be				       |
       |		|	 completed. If the -p option is supplied, or if no options				       |
       |		|	 are supplied, existing completion specifications are					       |
       |		|	 printed in a way that allows them to be reused as input.				       |
       |		|	 The -r option removes a completion specification for each				       |
       |		|	 NAME, or, if no NAMEs are supplied, all completion					       |
       |		|	 specifications.									       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     continue [N]									       |
       |       continue |												       |
       |		|												       |
       |		|		.PP Resume the next iteration of the enclosing FOR,				       |
       |		|	 WHILE or UNTIL loop. If N is specified, resume at the N-th				       |
       |		|	 enclosing loop.									       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     declare [-afFirtx] [-p] [name[=value] ...] 					       |
       |       declare	|												       |
       |		|												       |
       |		|		.PP Declare variables and/or give them attributes. If				       |
       |		|	 no NAMEs are given, then display the values of variables				       |
       |		|	 instead. The -p option will display the attributes and 				       |
       |		|	 values of each NAME.									       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     dirs [-clpv] [+N] [-N]								       |
       |       dirs	|												       |
       |		|												       |
       |		|		.PP Display the list of currently remembered					       |
       |		|	 directories. Directories find their way onto the list with				       |
       |		|	 the pushd command; you can get back up through the list with				       |
       |		|	 the popd command.									       |
       |		|												       |
       |		|		.PP										       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     disown [-h] [-ar] [JOBSPEC ...]							       |
       |       disown	|												       |
       |		|												       |
       |		|		.PP By default, removes each JOBSPEC argument from				       |
       |		|	 the table of active jobs. If the -h option is given, the job				       |
       |		|	 is not removed from the table, but is marked so that SIGHUP				       |
       |		|	 is not sent to the job if the shell receives a SIGHUP. The				       |
       |		|	 -a option, when JOBSPEC is not supplied, means to remove all				       |
       |		|	 jobs from the job table; the -r option means to remove only				       |
       |		|	 running jobs.										       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     echo [-neE] [arg ...]								       |
       |       echo	|												       |
       |		|												       |
       |		|		.PP Output the ARGs. If -n is specified, the trailing				       |
       |		|	 newline is suppressed. If the -e option is given,					       |
       |		|	 interpretation of the following backslash-escaped characters				       |
       |		|	 is turned on:										       |
       |		|												       |
       |		|		.RS 4 a (alert, bell)								       |
       |		|	      (backspace)									       |
       |		|	     c (suppress trailing newline)							       |
       |		|	     E (escape character)								       |
       |		|	     f (form feed)									       |
       |		|	     
 (new line)									       |
       |		|	     
 (carriage return)								       |
       |		|	     	 (horizontal tab)								       |
       |		|	     v (vertical tab)									       |
       |		|	     \ (backslash)									       |
       |		|	     nnn (the character whose ASCII code is NNN (octal).				       |
       |		|	     NNN can be 									       |
       |		|			     0 to 3 octal digits)						       |
       |		|		.PP You can explicitly turn off the interpretation of				       |
       |		|	 the above characters with the -E option.						       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     enable [-pnds] [-a] [-f filename] [name...]					       |
       |       enable	|												       |
       |		|												       |
       |		|		.PP Enable and disable builtin shell commands. This				       |
       |		|	 allows you to use a disk command which has the same name as				       |
       |		|	 a shell builtin without specifying a full pathname. If -n is				       |
       |		|	 used, the NAMEs become disabled; otherwise NAMEs are					       |
       |		|	 enabled. For example, to use the test found in $PATH instead				       |
       |		|	 of the shell builtin version, type enable -n test. On					       |
       |		|	 systems supporting dynamic loading, the -f option may be				       |
       |		|	 used to load new builtins from the shared object FILENAME.				       |
       |		|	 The -d option will delete a builtin previously loaded with				       |
       |		|	 -f. If no non-option names are given, or the -p option is				       |
       |		|	 supplied, a list of builtins is printed. The -a option means				       |
       |		|	 to print every builtin with an indication of whether or not				       |
       |		|	 it is enabled. The -s option restricts the output to the				       |
       |		|	 POSIX.2 `special' builtins. The -n option displays a list of				       |
       |		|	 all disabled builtins. 								       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     eval [ARG ...]									       |
       |       eval	|												       |
       |		|												       |
       |		|		.PP Read ARGs as input to the shell and execute the				       |
       |		|	 resulting command(s).									       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     exec [-cl] [-a name] file [redirection ...]					       |
       |       exec	|												       |
       |		|												       |
       |		|		.PP Exec FILE, replacing this shell with the					       |
       |		|	 specified program. If FILE is not specified, the					       |
       |		|	 redirections take effect in this shell. If the first					       |
       |		|	 argument is -l, then place a dash in the zeroth arg passed				       |
       |		|	 to FILE, as login does. If the -c option is supplied, FILE				       |
       |		|	 is executed with a null environment. The -a option means to				       |
       |		|	 make set argv[0] of the executed process to NAME. If the				       |
       |		|	 file cannot be executed and the shell is not interactive,				       |
       |		|	 then the shell exits, unless the shell option execfail is				       |
       |		|	 set.											       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     exit [N]										       |
       |       exit	|												       |
       |		|												       |
       |		|		.PP Exit the shell with a status of N. If N is					       |
       |		|	 omitted, the exit status is that of the last command					       |
       |		|	 executed.										       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     export [-nf] [NAME[=value] ...]							       |
       |       export	|	     export -p										       |
       |		|												       |
       |		|												       |
       |		|		.PP										       |
       |		|												       |
       |		|	 NAMEs are marked for automatic export to the environment of				       |
       |		|	 subsequently executed commands. If the -f option is given,				       |
       |		|	 the NAMEs refer to functions. If no NAMEs are given, or if				       |
       |		|	 -p is given, a list of all names that are exported in this				       |
       |		|	 shell is printed. An argument of -n says to remove the 				       |
       |		|	 export property from subsequent NAMEs. An argument of --				       |
       |		|	 disables further option processing.							       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     false										       |
       |       false	|												       |
       |		|												       |
       |		|		.PP Return an unsuccessful result.						       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     fc [-e ename] [-nlr] [FIRST] [LAST]						       |
       |       fc	|	     fc -s [pat=rep] [cmd]								       |
       |		|												       |
       |		|												       |
       |		|		.PP fc is used to list or edit and re-execute					       |
       |		|	 commands from the history list.  FIRST and LAST can be 				       |
       |		|	 numbers specifying the range, or FIRST can be a string,				       |
       |		|	 which means the most recent command beginning with that				       |
       |		|	 string.										       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     fg [JOB_SPEC]									       |
       |       fg	|												       |
       |		|												       |
       |		|		.PP Place JOB_SPEC in the foreground, and make it the				       |
       |		|	 current job. If JOB_SPEC is not present, the shell's notion				       |
       |		|	 of the current job is used.								       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     for NAME [in WORDS ... ;] do COMMANDS; done					       |
       |       for	|												       |
       |		|												       |
       |		|		.PP The for loop executes a sequence of commands for				       |
       |		|	 each member in a list of items. If in WORDS ...; is not				       |
       |		|	 present, then in "$@" is assumed. For each element in WORDS,				       |
       |		|	 NAME is set to that element, and the COMMANDS are executed.				       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     function NAME { COMMANDS ; }							       |
       |       function |	     function NAME () { COMMANDS ; }							       |
       |		|												       |
       |		|												       |
       |		|		.PP Create a simple command invoked by NAME which				       |
       |		|	 runs COMMANDS. Arguments on the command line along with NAME				       |
       |		|	 are passed to the function as $0 ..  $n.						       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     getopts OPTSTRING NAME [arg]							       |
       |       getopts	|												       |
       |		|												       |
       |		|		.PP Getopts is used by shell procedures to parse				       |
       |		|	 positional parameters. 								       |
       |		|												       |
       |		|		.PP										       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     hash [-lr] [-p PATHNAME] [-dt] [NAME...]						       |
       |       hash	|												       |
       |		|												       |
       |		|		.PP For each NAME, the full pathname of the command				       |
       |		|	 is determined and remembered. If the -p option is supplied,				       |
       |		|	 PATHNAME is used as the full pathname of NAME, and no path				       |
       |		|	 search is performed. The -r option causes the shell to 				       |
       |		|	 forget all remembered locations. The -d option causes the				       |
       |		|	 shell to forget the remembered location of each NAME. If the				       |
       |		|	 -t option is supplied the full pathname to which each NAME				       |
       |		|	 corresponds is printed. If multiple NAME arguments are 				       |
       |		|	 supplied with -t, the NAME is printed before the hashed full				       |
       |		|	 pathname. The -l option causes output to be displayed in a				       |
       |		|	 format that may be reused as input. If no arguments are				       |
       |		|	 given, information about remembered commands is displayed.				       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     history [-c] [-d OFFSET] [n]							       |
       |       history	|	     history -ps arg [arg...]								       |
       |		|	     history -awrm [filename]								       |
       |		|												       |
       |		|												       |
       |		|		.PP Display the history list with line numbers. Lines				       |
       |		|	 listed with with a * have been modified. Argument of N says				       |
       |		|	 to list only the last N lines. The -c option causes the				       |
       |		|	 history list to be cleared by deleting all of the entries.				       |
       |		|	 The -d option deletes the history entry at offset OFFSET.				       |
       |		|	 The -w option writes out the current history to the history				       |
       |		|	 file; -r means to read the file and append the contents to				       |
       |		|	 the history list instead.  -a means to append history lines				       |
       |		|	 from this session to the history file. Argument -n means to				       |
       |		|	 read all history lines not already read from the history				       |
       |		|	 file and append them to the history list.						       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     jobs [-lnprs] [JOBSPEC ...]							       |
       |       jobs	|	     job -x COMMAND [ARGS]								       |
       |		|												       |
       |		|												       |
       |		|		.PP Lists the active jobs. The -l option lists					       |
       |		|	 process id's in addition to the normal information; the -p				       |
       |		|	 option lists process id's only. If -n is given, only					       |
       |		|	 processes that have changed status since the last					       |
       |		|	 notification are printed.  JOBSPEC restricts output to that				       |
       |		|	 job. The -r and -s options restrict output to running and				       |
       |		|	 stopped jobs only, respectively. Without options, the status				       |
       |		|	 of all active jobs is printed. If -x is given, COMMAND is				       |
       |		|	 run after all job specifications that appear in ARGS have				       |
       |		|	 been replaced with the process ID of that job's process				       |
       |		|	 group leader.										       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     kill [-s sigspec | -n signum | -sigspec] pid | JOBSPEC ... 			       |
       |       kill	|	     kill -l [sigspec]									       |
       |		|												       |
       |		|												       |
       |		|		.PP Send the processes named by PID (or JOBSPEC) the				       |
       |		|	 signal SIGSPEC. If SIGSPEC is not present, then SIGTERM is				       |
       |		|	 assumed. An argument of -l lists the signal names; if					       |
       |		|	 arguments follow -l they are assumed to be signal numbers				       |
       |		|	 for which names should be listed. Kill is a shell builtin				       |
       |		|	 for two reasons: it allows job IDs to be used instead of				       |
       |		|	 process IDs, and, if you have reached the limit on processes				       |
       |		|	 that you can create, you don't have to start a process to				       |
       |		|	 kill another one.									       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     let ARG [ARG ...]									       |
       |       let	|												       |
       |		|												       |
       |		|		.PP Each ARG is an arithmetic expression to be					       |
       |		|	 evaluated. Evaluation is done in fixed-width integers with no				       |
       |		|	 check for overflow, though division by 0 is trapped and				       |
       |		|	 flagged as an error. The following list of operators is				       |
       |		|	 grouped into levels of equal-precedence operators. The levels				       |
       |		|	 are listed in order of decreasing precedence.						       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     local NAME[=VALUE] ...								       |
       |       local	|												       |
       |		|												       |
       |		|		.PP Create a local variable called NAME, and give it				       |
       |		|	 VALUE.  local can only be used within a function; it makes the 			       |
       |		|	 variable NAME have a visible scope restricted to that function 			       |
       |		|	 and its children.									       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     logout										       |
       |       logout	|												       |
       |		|												       |
       |		|		.PP Logout of a login shell.							       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     popd [+N | -N] [-n]								       |
       |       popd	|												       |
       |		|												       |
       |		|		.PP Removes entries from the directory stack. With no				       |
       |		|	 arguments, removes the top directory from the stack, and cd's				       |
       |		|	 to the new top directory.								       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     printf [-v var] format [ARGUMENTS] 						       |
       |       printf	|												       |
       |		|												       |
       |		|		.PP printf formats and prints ARGUMENTS under control				       |
       |		|	 of the FORMAT.  FORMAT is a character string which contains				       |
       |		|	 three types of objects: plain characters, which are simply				       |
       |		|	 copied to standard output, character escape sequences which				       |
       |		|	 are converted and copied to the standard output, and format				       |
       |		|	 specifications, each of which causes printing of the next				       |
       |		|	 successive argument. In addition to the standard printf(1)				       |
       |		|	 formats, %b means to expand backslash escape sequences in the				       |
       |		|	 corresponding argument, and %q means to quote the argument in				       |
       |		|	 a way that can be reused as shell input. If the -v option is				       |
       |		|	 supplied, the output is placed into the value of the shell				       |
       |		|	 variable VAR rather than being sent to the standard output.				       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     pushd [dir | +N | -N] [-n] 							       |
       |       pushd	|												       |
       |		|												       |
       |		|		.PP Adds a directory to the top of the directory stack, 			       |
       |		|	 or rotates the stack, making the new top of the stack the				       |
       |		|	 current working directory. With no arguments, exchanges the				       |
       |		|	 top two directories.									       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     pwd [-LP]										       |
       |       pwd	|												       |
       |		|												       |
       |		|		.PP Print the current working directory. With the -P				       |
       |		|	 option, pwd prints the physical directory, without any 				       |
       |		|	 symbolic links; the -L option makes pwd follow symbolic links. 			       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     read [-ers] [-u fd] [-t timeout] [-p prompt] [-a array] [-n nchars] [-d delim] [NAME ...] |
       |       read	|												       |
       |		|												       |
       |		|		.PP The given NAMEs are marked readonly and the values				       |
       |		|	 of these NAMEs may not be changed by subsequent assignment. If 			       |
       |		|	 the -f option is given, then functions corresponding to the				       |
       |		|	 NAMEs are so marked. If no arguments are given, or if -p is				       |
       |		|	 given, a list of all readonly names is printed. The -a option				       |
       |		|	 means to treat each NAME as an array variable. An argument of				       |
       |		|	 -- disables further option processing. 						       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     readonly [-af] [NAME[=VALUE] ...]							       |
       |       readonly |	     readonly -p									       |
       |		|												       |
       |		|												       |
       |		|		.PP The given NAMEs are marked readonly and the values of these NAMEs may not be       |
       |		|	 changed by subsequent assignment. If the -f option is given, then functions corresponding to  |
       |		|	 the NAMEs are so marked. If no arguments are given, or if -p is given, a list of all readonly |
       |		|	 names is printed. The -a option means to treat each NAME as an array variable. An argument of |
       |		|	 -- disables further option processing. 						       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     return [N] 									       |
       |       return	|												       |
       |		|												       |
       |		|		.PP Causes a function to exit with the return value specified by N. If N is omitted,   |
       |		|	 the return status is that of the last command. 					       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     select NAME [in WORDS ... ;] do COMMANDS; done					       |
       |       select	|												       |
       |		|												       |
       |		|		.PP The WORDS are expanded, generating a list of words. The set of expanded words is   |
       |		|	 printed on the standard error, each preceded by a number. If in WORDS is not present, in "$@" |
       |		|	 is assumed. The PS3 prompt is then displayed and a line read from the standard input. If the  |
       |		|	 line consists of the number corresponding to one of the displayed words, then NAME is set to  |
       |		|	 that word. If the line is empty, WORDS and the prompt are redisplayed. If EOF is read, the    |
       |		|	 command completes. Any other value read causes NAME to be set to null. The line read is saved |
       |		|	 in the variable REPLY.  COMMANDS are executed after each selection until a break command is   |
       |		|	 executed.										       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     set [--abefhkmnptuvxBCHP] [-o OPTION] [ARG...]					       |
       |       set	|												       |
       |		|												       |
       |		|		.PP Sets internal shell options.						       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     shift [n]										       |
       |       shift	|												       |
       |		|												       |
       |		|		.PP The positional parameters from $N+1 ...  are renamed to $1 ...  If N is not given, |
       |		|	 it is assumed to be 1. 								       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     shopt [-pqsu] [-o long-option] OPTNAME [OPTNAME...]				       |
       |       shopt	|												       |
       |		|												       |
       |		|		.PP Toggle the values of variables controlling optional behavior. The -s flag means to |
       |		|	 enable (set) each OPTNAME; the -u flag unsets each OPTNAME. The -q flag suppresses output;    |
       |		|	 the exit status indicates whether each OPTNAME is set or unset. The -o option restricts the   |
       |		|	 OPTNAMEs to those defined for use with set -o. With no options, or with the -p option, a list |
       |		|	 of all settable options is displayed, with an indication of whether or not each is set.       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     source FILENAME [ARGS]								       |
       |       source	|												       |
       |		|												       |
       |		|		.PP Read and execute commands from FILENAME and return. The pathnames in $PATH are     |
       |		|	 used to find the directory containing FILENAME. If any ARGS are supplied, they become the     |
       |		|	 positional parameters when FILENAME is executed.					       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     suspend [-f]									       |
       |       suspend	|												       |
       |		|												       |
       |		|		.PP Suspend the execution of this shell until it receives a SIGCONT signal. The -f if  |
       |		|	 specified says not to complain about this being a login shell if it is; just suspend anyway.  |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     test [expr]									       |
       |       test	|												       |
       |		|												       |
       |		|		.PP Exits with a status of 0 (true) or 1 (false) depending on the evaluation of EXPR.  |
       |		|	 Expressions may be unary or binary. Unary expressions are often used to examine the status of |
       |		|	 a file. There are string operators as well, and numeric comparison operators.		       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     time [-p] PIPELINE 								       |
       |       time	|												       |
       |		|												       |
       |		|		.PP Execute PIPELINE and print a summary of the real time, user CPU time, and system   |
       |		|	 CPU time spent executing PIPELINE when it terminates. The return status is the return status  |
       |		|	 of PIPELINE. The -p option prints the timing summary in a slightly different format. This     |
       |		|	 uses the value of the TIMEFORMAT variable as the output format.			       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     times										       |
       |       times	|												       |
       |		|												       |
       |		|		.PP Print the accumulated user and system times for processes run from the shell.      |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     trap [-lp] [ARG SIGNAL_SPEC ...]							       |
       |       trap	|												       |
       |		|												       |
       |		|		.PP The command ARG is to be read and executed when the shell receives signal(s)       |
       |		|	 SIGNAL_SPEC. If ARG is absent (and a single SIGNAL_SPEC is supplied) or -, each specified     |
       |		|	 signal is reset to its original value. If ARG is the null string each SIGNAL_SPEC is ignored  |
       |		|	 by the shell and by the commands it invokes. If a SIGNAL_SPEC is EXIT (0) the command ARG is  |
       |		|	 executed on exit from the shell. If a SIGNAL_SPEC is DEBUG, ARG is executed after every       |
       |		|	 simple command. If the -p option is supplied then the trap commands associated with each      |
       |		|	 SIGNAL_SPEC are displayed. If no arguments are supplied or if only -p is given, trap prints   |
       |		|	 the list of commands associated with each signal. Each SIGNAL_SPEC is either a signal name in |
       |		|	 signal.h or a signal number. Signal names are case insensitive and the SIG prefix is	       |
       |		|	 optional.  trap -l prints a list of signal names and their corresponding numbers. Note that a |
       |		|	 signal can be sent to the shell with kill -signal $$.					       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     true										       |
       |       true	|												       |
       |		|												       |
       |		|		.PP Return a successful result. 						       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     type [-afptP] NAME [NAME ...]							       |
       |       type	|												       |
       |		|												       |
       |		|												       |
       |		|		.PP Obsolete, see declare.							       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     typeset [-afFirtx] [-p] name[=value]						       |
       |       typeset	|												       |
       |		|												       |
       |		|		.PP Obsolete, see declare.							       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     ulimit [-SHacdfilmnpqstuvx] [limit 						       |
       |       ulimit	|												       |
       |		|												       |
       |		|		.PP Ulimit provides control over the resources available to processes started by the   |
       |		|	 shell, on systems that allow such control.						       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     umask [-p] [-S] [MODE]								       |
       |       umask	|												       |
       |		|												       |
       |		|		.PP The user file-creation mask is set to MODE. If MODE is omitted, or if -S is        |
       |		|	 supplied, the current value of the mask is printed. The -S option makes the output symbolic;  |
       |		|	 otherwise an octal number is output. If -p is supplied, and MODE is omitted, the output is in |
       |		|	 a form that may be used as input. If MODE begins with a digit, it is interpreted as an octal  |
       |		|	 number, otherwise it is a symbolic mode string like that accepted by chmod(1). 	       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     unalias [-a] NAME [NAME ...]							       |
       |       unalias	|												       |
       |		|												       |
       |		|		.PP Remove NAMEs from the list of defined aliases. If the -a option is given, then     |
       |		|	 remove all alias definitions.								       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     unset [-f] [-v] [NAME ...] 							       |
       |       unset	|												       |
       |		|												       |
       |		|		.PP For each NAME, remove the corresponding variable or function. Given the -v, unset  |
       |		|	 will only act on variables. Given the -f flag, unset will only act on functions. With neither |
       |		|	 flag, unset first tries to unset a variable, and if that fails, then tries to unset a	       |
       |		|	 function. Some variables cannot be unset; also see readonly.				       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     until COMMANDS; do COMMANDS; done							       |
       |       until	|												       |
       |		|												       |
       |		|		.PP Expand and execute COMMANDS as long as the final command in the until COMMANDS has |
       |		|	 an exit status which is not zero.							       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     wait [N]										       |
       |       wait	|												       |
       |		|												       |
       |		|		.PP Wait for the specified process and report its termination status. If N is not      |
       |		|	 given, all currently active child processes are waited for, and the return code is zero.  N   |
       |		|	 may be a process ID or a job specification; if a job spec is given, all processes in the      |
       |		|	 job's pipeline are waited for. 							       |
       +----------------+------------------------------------------------------------------------------------------------------+
       |		|	     while COMMANDS; do COMMANDS; done							       |
       |       while	|												       |
       |		|												       |
       |		|		.PP Expand and execute COMMANDS as long as the final command in the while COMMANDS has |
       |		|	 an exit status of zero.								       |
       +----------------+------------------------------------------------------------------------------------------------------+

[FIXME: source] 						    07/05/2010							     CRM_SHADOW(8)