You are here: RayCosoft.com > Info/Support > Expect Tutorial
Notational conventions
Basic commands The commands send, expect, and spawn
are the building blocks of Expect. The send command sends text
strings to a process, the expect command waits for a specified
text string in the process's output stream, and the spawn command
starts a process.
1. The send command The send command takes a
string as an argument and sends it to a process. For example:send "hello world" This sends the string "hello world" (without the quotes). If Expect is already interacting with a program, the string will be sent to that program. Otherwise, send will send the string to the standard output. Here is what happens when I type this to the Expect interpreter interactively: % expect expect1.1>send "hello world" hello worldexpect1.2>exit % The send command does not format the string in any way, so after it is printed the next Expect prompt gets appended to it without any space. To make the prompt appear on a different line, put a newline character at the end of the string. A newline is represented by "\n". The exit command gets you out of the Expect interpreter. expect1.1>send "hello world\n" hello world expect1.2>exit % If these commands are stored in a file named sayhello, the script can be executed from the Unix command line: % expect sayhello hello world To execute the file with the command "sayhello" rather than typing "expect sayhello", insert the line "#! /usr/local/bin/expect -f " at the beginning of the file and execute the command "chmod ugo+x sayhello". The string /usr/local/bin/expect is the Unix pathname of the Expect interpreter. % cat sayhello #! /usr/local/bin/expect -f send "hello world\n" % % chmod ugo+x sayhello % sayhello hello world
2. The expect command The expect command waits
for a response. Expect can wait for a specific string or any
string that matches a given pattern. Like send, expect
waits for a response from a process if Expect is interacting with a
process, otherwise expect waits for characters from the keyboard.
To see how expect works, create a file named response that
reads:#! /usr/local/bin/expect -f expect "hi\n" send "hello there!\n" When I make the file executable and run it, the interaction looks like this: % chmod ugo+x response % response hi hello there! If you get an error message like couldn't read file " ": no such file or directory, it may be because there are non-printable characters in your file. This can occur if you cut-and-paste text from a web browser to your file. To solve this problem, delete trailing spaces from the end of each line in the script and repeat above steps. What happens when input does not match If expect reads characters
that do not match the expected string, it continues waiting for more
characters. If I had typed hello instead of hi followed by a
return, expect would continue to wait for "hi\n". Finding
unexpected data in the input does not bother expect. It keeps
looking until it finds something that matches. If no input is given, the
expect command eventually times out and returns. By default,
after 10 seconds expect gives up waiting for input that matches
the pattern. This default value can be changed by setting the variable
timeout using the set command. For example, the following command
sets the timeout to 60 seconds.set timeout 60 A timeout of -1 signifies that expect should wait forever and a timeout of 0 indicates that expect should not wait at all. Anchoring To prevent expect from matching unexpected data, expect
patterns can include regular expressions. The caret (^) is a special character that only matches the
beginning of the input; it cannot skip over characters to find a valid
match. For example, the pather ^hi matches if I
enter "hiccup" but not if I enter "sushi". The dollar sign ($) is a special character that matches the end of the
data. The pattern hi$ matches if I enter "sushi"
but not if I enter "hiccup". And the pattern ^hi$
matches neither "sushi" nor "hiccup". It matches "hi" and nothing
else.Patterns that use ^ or $ are "anchored". When patterns are not anchored, patterns match beginning at the earliest possible position in the string. For more informations on pattern matching, see the book Exploring Expect. Pattern-action pairs Expect also allows association
between a command and a pattern. The association is made by listing the
action (also known as command) immediately after the pattern in the
expect command itself. Here is an example of pattern-action
pairs:expect "hi" { send "You said hi\n" } \ "hello" { send "Hello yourself\n" } \ "bye" { send "Good-bye cruel world\n" } This command looks for "hi", "hello", and "bye". If any of the three patterns are found, the action immediately following it gets executed. If there is no match and the default timeout expires, expect stops waiting and execution continues with the next command in the script.
3. The spawn command The spawn command starts
another program. The first argument of the spawn command is the
name of a program to start. The remaining arguments are passed to the
program. For example:spawn ftp ftp.uu.net This command spawns the ftp command; ftp.uu.net is the argument to the ftp command.
Example: anonymous FTP Now we're ready to use the three
commands above to write a little script to automate an interactive
program. When I do anonymous ftp from the Unix command line, this is what
I see:% ftp ftp.uu.net Connected to ftp.uu.net. 220 ftp.UU.NET FTP server (Version wu-2.4(3) Fri Nov 25 16:08:40 EST 1994) ready. Name (ftp.uu.net:dtly): anonymous 331 Guest login ok, send your complete e-mail address as password. Password: 230- 230- Welcome to the UUNET archive. 230- A service of UUNET Technologies Inc, Falls Church, Virginia 230- For information about UUNET, call +1 703 206 5600, or see the files 230- 230- Access is allowed all day. Local time is Wed Feb 28 13:59:46 1996. . . . 230 Guest login ok, access restrictions apply. ftp> To automate this dialog, create a file named aftp that looks like this: #! /usr/local/bin/expect -f # # Make anonymous FTP connection # spawn ftp $argv expect "Name" send "anonymous\r" expect "Password:" send "[email protected]\r" interact Interact is an Expect command that transfers control from the script to the user. When this command is executed, Expect stops reading commands from the script and instead begins reading from the keyboard. Notice that each send command in the script ends with \r and not \n. (A \r is a return character, a \n is a linefeed character). Make the file aftp executable and run it: % chmod ugo+x aftp % aftp ftp.uu.net Example: switching between script control and user
control The following
script is useful for running a cp command when you are not sure if the
target file has write permissions. send "cp -i passwd passwd.$date\n" expect "overwrite" {interact "+" return} send "\n" The cp command warns the user if the target file does not have write permissions using a message containing the string "overwrite". If the script sees the string "overwrite", it pauses and lets you enter commands manually. (You could type chmod to change the file permissions and then reenter the cp command.) When you have finished entering commands, return control to the script by typing "+" (without the quotes). Example: rlogin and set DISPLAY variable The following script runs connects
to the named machine using the rlogin command and sets the DISPLAY
environment variable for the rlogin session using the value of the DISPLAY
variable on the original (source) machine. Notice how environment
variables are accessed using the $env array and Unix commands are invoked
using the exec command. #! /usr/local/bin/expect -- # # rlogin and set DISPLAY environment variable using current DISPLAY value # if {[length $argv] != 1} { puts "usage: xrlogin remotehost" exit } set prompt "(%|#|\\$) $" ;# default prompt catch {set prompt $env(EXPECT_PROMPT)} set timeout -1 eval spawn rlogin $argv expect eof exit -re $prompt if [string match "unix:0.0" $env(DISPLAY)] { set env(DISPLAY) "[exec hostname].[exec domainname]:0.0\r" } send "setenv DISPLAY $env(DISPLAY)\r" interact
Acknowledgements The examples are based on code
written by D. Butler, Noel Davis and Don Libes.
| ||||||||||||||||||||||||||||||
