Softpanorama (slightly skeptical) Open Source Software Educational Society

May the source be with you, but remember the KISS principle ;-)

Unix exec command

The internal exec command replaces the current shell process with the specified command. Normally, when you run a command a new process is spawned. The exec command does not spawn a new process. Instead, the current process is overlaid with the new command. In other words ehe exec command is  executed  in   place   of  the current shell  without  creating  a  new  process.    Input/output arguments may appear and, if no other arguments    are given, it cause the shell input/output to be modified. The name of the command is identical to the name of system call that provide semantic of this command in Unix.

The exec command is useful in pipes and can be used to set redirection file descriptors. In the latter case the current shell process is modified but not overlaid. In shell the exec command can be used to open, close, and copy file descriptors. If you do not specify a command or arguments, you can specify redirection symbols and file descriptors to perform these functions.

If you specify a command, the shell replaces itself in memory with the new command you specified. For example,

     exec vi myfile

replaces the shell with the vi program text and places you in vi, editing myfile. When you exit vi you exit the system because vi has become your login interface to the operating system.

You can also use the exec command in a set of shell scripts that execute one another. Instead of spawning new processes each time you call a different script, you can exec to the new shell.

The exec command may also be used to open, close, and copy file descriptors as specified by I/O redirection.

You can use exec to perform I/O redirection commands. The following examples illustrate the use of exec for redirection purposes.

exec 3< inputfile	# Opens inputfile with file descriptor 3 for reading.
exec 4> outputfile	# Opens outputfile with file descriptor 4 for writing.
exec 5<&0	# Makes fd 5 a copy of fd 0 (standard input).
exec 6>&p	# Attach fd 6 to co-process.

Following is the general format of the exec command.

     exec [ command ] [ arg ... ]
     exec fd< file
     exec fd> file

Arguments

Examples

     while true
     do
     echo "Go to Mail, Editor, or eXit:"
     read ANS
     case "$ANS" in
          [mM]) exec MAILX ;;
          [eE]) exec ${EDITOR:=vi} ;;
          [xX]) ezec exit ;;
     esac
     done

Notes: Those pages are written by people for whom English is not a native language. Some amount of grammar and spelling errors should be expected. This is a Spartan WHYFF (We Help You For Free) site. It cannot replace the best teachers and the best books. The site contain some obsolete pages as it develops like a living tree... Some links on older pages are broken. Please try to use Google, Open directory, etc. to find a replacement link (see HOWTO search the WEB for details). We would appreciate if you can mail us a correct link. Search Amazon by keywords:     Open directory Research Index

Old News ;-)

[Mar 11, 2007] Sys Admin v16, i03 Miscellaneous Unix Tips Answering Novice Shell Questions

Using the exec & eval Commands

One novice asked when it was suitable to exec and eval Unix commands:

exec mycommand
eval mycommand

The exec command works differently depending on the shell; in the Bourne and Korn shells, the exec command replaces the current shell with the command being exec'ed. Consider this stub script:

exec echo "Hello John"
echo "Hello Ed"
# end stub

When the above stub executes, the current shell will be replaced when exec'ing the echo "Hello John" command. The echo "Hello Ed" command never gets the chance to execute. Obviously, this capability has limited uses.

You might design a shell menu where the requirement is to execute an option that never returns to the menu. Another use would be restricting the user from obtaining the command line. The following last line in the user's .profile file logs the user out as soon as my_executable terminates:

exec my_executable

However, most systems administrators probably use the exit command instead:

my_executable
exit

Don't confuse exec'ing a Unix command with using exec to assign a file to a file descriptor. Remember that the default descriptors are standard input, output, and error or 0, 1, and 2, respectively.

Let's consider an example where you need to read a file with a while loop and ask the user for input in the same loop. Assign the file to an unused descriptor -- 3 in this case -- and obtain the user input from standard input:

exec 3< file.txt
while read line <&3
do
    echo "$line"
    echo "what is your input? "
    read answer
    .
    .
done
exec 3<&-   # close the file descriptor when done

The eval command is more interesting. A common eval use is to build a dynamic string containing valid Unix commands and then use eval to execute the string. Why do we need eval? Often, you can build a command that doesn't require eval:

evalstr="myexecutable"
$evalstr   # execute the command string

However, chances are the above command won't work if "myexecutable" requires command-line arguments. That's where eval comes in.

Our man page says that the arguments to the eval command are "read as input to the shell and the resulting commands executed". What does that mean? Think of it as the eval command forcing a second pass so the string's arguments become the arguments of the spawned child shell.

In a previous column, we built a dynamic sed command that skipped 3 header lines, printed 5 lines, and skipped 3 more lines until the end of the file:

evalstr="sed -n '4,\${p;n;p;n;p;n;p;n;p;n;n;n;}' data.file"
eval $evalstr  # execute the command string

This command fails without eval. When the sed command executes in the child shell, eval forces the remainder of the string to become arguments to the child.

Possibly the coolest eval use is building dynamic Unix shell variables. The following stub script dynamically creates shell variables user1 and user2 setting them equal to the strings John and Ed, respectively:

COUNT=1
eval user${COUNT}=John
echo $user1

COUNT=2
eval user${COUNT}=Ed
echo $user2
Pasting Files with paste

Another novice asked how to line up three files line by line sending the output to another file. Given the following:

file1:

1
2
3

file2:

a
b
c

file3:

7
8
9

the output file should look like this:

1a7
2b8
3c9

The paste command is a ready-made solution:

paste file1 file2 file3

By default, the delimiter character between the columns is a tab key. The paste command provides a -d delimiter option. Everything after -d is treated as a list. For example, this paste rendition uses the pipe symbol and ampersand characters as a list:

paste -d"|&" file1 file2 file3

The command produces this output:

1|a&7
2|b&8
3|c&9

The pipe symbol character, |, is used between columns 1 and 2, while the ampersand, &, separates column 2 and 3. If the list is completely used, and if the paste command contains more files arguments, then paste starts at the beginning of the list.

To satisfy our original requirement, paste provides a null character, \0, signifying no character. To prevent the shell from interpreting the character, it must also be quoted:

paste -d"\0" file1 file2 file3

The exec command

The exec command will replace the parent process by whatever the command is typed.

Try the following:

exec ls -l

As you will have noticed, this closes the shell you are currently using. Why?

The exec command terminated the parent process and started (executed) the ls command and the ls command did what it was supposed to do and exited with a zero status, but ls has no parent process to return to, and thereby the shell is shut down.

If for example, we ran our eatout.sh script, but instead of running it as we have previously, we exec'd it, the script would run but would also close our terminal from which we ran the script.

exec eatout.sh

This means that when the person finally types exit to exit the menu, they are sent back to the login prompt.

To see this in action, let's consider the following sequence of commands:

pstree -p |less

You will notice that "pstree" starts with the init command or the init process. Somewhere further down this 'tree', init starts a shell (bash/ksh/csh) which is then going to run the pstree and the less command.

Now, in order to see exec at work, we need to find out the current process id.

Use:

echo $$

to determine this (the ps command would give you the same information).

Now type the pstree command again, producing a diagram of your process tree.

pstree -p | less

Search for your process id recorded from the echo above. Once you have located it, quit pstree and type:

exec bash

This would replace our current shell (our parent) with a new shell, and thus a new process id (PID).

echo $$

You can also look at the pstree again.

By using the exec command, instead of making the new shell's parent your original shell, the new shell will be owned by init.

Recommended Links

the exec command

exec -- execute a command in place of the current shell

LinuxDevCenter.com -- The exec Command by Mike Loukides and Jerry Peek  02/10/2000

The exec Command There is more than one use for exec, learn a couple of new ones in this excerpt from Unix Power Tools, 2nd Edition.

Last modified: March 15, 2008