Expect

In a sense, Expect shouldn't be necessary. It should be possible to script, to connect together under program control, with shell scripts or ordinary Tcl programs. Why was Expect written?

Good Unix programs are written as tools, and are meant to be programmed with. The primary mechanism for hooking tools together is the pipe, combined with the standard input / standard output filter model (though pipes can also work with more file descriptors). However, there is a class of Unix programs that can't be hooked together this way: programs which talk directly to a terminal device (i.e., interactive programs).

The fact that interactive programs can't be programmed via pipes is an accident of history. When Unix was first introduced, the concept of pipes was new and people didn't think you could program interactive applications with them (or they didn't realize the potential benefits). Modern research Unix systems have attempted, with success, to bring the notion of an interactive session back into the fold with a generalization of both pipes and terminals called streams. But those of us using commercial Unix systems still have a problem.

Berkeley Unix added programmable terminal devices, called pseudo terminals (PTYs) years ago. With PTYs, you can convince an interactive program that its talking to a terminal when in fact another program has control of both ends. However, PTYs are extremely complex and hard to program (by Unix standards). What we need is a level abstraction, a tool that makes programming PTYs easier. Expect is one such tool.

A classic example of the problem is programming FTP. On most Unix systems, the FTP program can't be scripted via pipes, mainly because it wants to be able to turn off echoing when it prompts you for your password. If you try to write a simple Tcl program that execs an FTP process and speaks to it via pipes, you'll find it doesn't work.

Example Uses Of Expect

The Expect Interpreter

expect ?-d? -f scriptfile

A Typical Expect Script

1. Spawn a process
2. Repeatedly:
   1. Send a message to the process
   2. Expect a set of possible responses, and react
3. Turn the interaction over to the user

The spawn Command

spawn program ?args?

The expect Command

expect ?-opts? pat1 body1 ... ?-opts? patn ?bodyn?

expect {*Account:*}

A more complex example:

expect "Wait for response" {} "SERVICE UNAVAILABLE" {error}

Here's a part of an Expect script that handles typical initial responses from telnet:

expect {
    {Connected*Escape character is*.} {}
    "unknown*" {
	error $expect_out(buffer)
    }
    "unreachable*" {
	error $expect_out(buffer)
    }
    eof {
        error "Connection closed."
    }
    timeout {
        error "Connection timed out."
    }
}

This segment of code illustrates another feature: the array variable expect_out has several fields that contain information about the matching process. expect_out(buffer) contains the matching text (and any previously unmatched text).

Each pattern can be preceded by a number of options; the -re option specifies that regular expression pattern matching be used for that pattern instead of globbing.

The timeout pattern can be used in other ways. This short, complete Expect script runs an arbitrary program with a timeout:

#!/local/bin/expect -f
# run a program for a given amount of time
# i.e. time 20 long_running_program
set timeout [lindex $argv 0]
eval spawn [lrange $argv 1 end]
expect

The log_user Command

log_user 0
log_user 1

A Complete Expect Script

#!/local/bin/expect -f
log_user 0
if {[llength $argv] != 1} {
    puts stderr "Usage: daytime host"
    exit 1
}
spawn telnet [lindex $argv 0] daytime
expect "scape character*\en"
expect "*\en"
regexp {([0-9][0-9]:[0-9][0-9]:[0-9][0-9])} $expect_out(buffer) _ time
puts $time

The send Command

send string

The interact Command

interact string1 body1 ... stringn ?bodyn? 

Each string of interest is paired with a body. A null body gives the user access to the Expect interpreter. Here is an example:

set CTRLZ \e032
interact {
	 -reset $CTRLZ {exec kill -STOP 0}
	 \e001    {puts "you typed a control-A\en";
		  send "\e001"
		 }
	 $       {puts "The date is [exec date]."}
	 \e003    exit
	 foo     {puts "bar"}
	 ~~
}

Note that the \e001 pattern not only prints a message to the user but also passes the control-A on to the spawned process.

The final ~~ pattern, has no body, so if the user types ~~ they will be given access to the Expect interpreter's command loop.