Linux expect Command With Examples

Introduction

System administrators automate repetitive tasks all the time. Bash scripts provide many programs and features to carry out system automation tasks. The expect command offers a way to control interactive applications which require user input to continue.

This article explains how to use the expect command with practical examples.

Prerequisites

• Access to the command line/terminal.
• An account with sudo permissions.
• A text editor, such as Vim or nano.

Linux expect Command Syntax

The expect command runs Expect program scripts using the following syntax:

expect [options] [commands/command file]

The Except program uses the following keywords to interact with other programs:

Expect uses TCL (Tool Command Language) to control the program flow and essential interactions.

Some systems do not include Expect by default.

To install it with apt on Debian-based systems, run the following in the terminal:

sudo apt install expect

Alternatively, use yum on Red Hat-based systems:

yum install expect

Follow the installation instructions to complete the setup.

Linux expect Command Options

Below is a table describing available command options for the expect command:

Linux expect Command Examples

The next sections provide practical examples of the expect command, which executes Expect program scripts. To make an Expect script executable, add the following shebang at the start of each script:

#!/usr/bin/expect

The location differs depending on the system. To find the exact path, use:

whereis expect

Exchange the location if Expect is at a different location.

Basic Expect Use

Below is a basic example that explains how the expect command functions:

1. Open a text editor and name the file interactive_script.sh. If you use Vim, run:

vim interactive_script.sh

2. Add the following code to the file:

#!/bin/bash

echo "Hello, who is this?"
read $REPLY
echo "What's your favorite color?"
read $REPLY
echo "How many cats do you have?"
read $REPLY

The code is a basic script with the read command that expects user interaction when run.

3. Save the file and close Vim:

:wq

4. Change the script to executable:

chmod +x interactive_script.sh

5. Create a new file to store the Expect script with:

vim expect_response.exp

The .exp extension is not mandatory, though it helps differentiate Expect scripts from other files.

6. Add the following code to the script:

#!/usr/bin/expect

spawn ./interactive_script.sh
expect "Hello, who is this?\r"
send -- "phoenixNAP\r"
expect "What's your favorite color?\r"
send -- "Blue\r"
expect "How many cats do you have?\r"
send -- "1\r"
expect eof

The script consists of the following lines:

• spawn creates a new process running the interactive_script.sh file.
• expect writes the expected program message and waits for the output. The final line ends the program.
• send contains the replies to the program after each expected message.

7. Save the file and close:

:wq

8. Make the script executable:

chmod +x expect_response.exp

9. Run the script with:

expect expect_response.exp

Or alternatively:

./expect_response.exp

The expect_response.exp script spawns the program process and sends automatic replies.

Expect with Variables

Use the set command to store variables and pass values in Expect scripts. For example, to hardcode a variable, use:

set MYVAR 5

For user input arguments use:

set MYVAR1 [lindex $argv 0]
set MYVAR2 [lindex $argv 1]

In both cases, reference the variable in the script with $<variable name>.

The following example demonstrates using both variables in the Expect script from the previous example (expect_response.exp):

#!/usr/bin/expect
set NAME "phoenixNAP"
set COLOR "Blue"
set NUMBER [lindex $argv 0]
spawn ./interactive_script.sh
expect "Hello, who is this?\r"
send -- "$NAME\r"
expect "What's your favorite color?\r"
send -- "$COLOR\r"
expect "How many cats do you have?\r"
send -- "$NUMBER\r"
expect eof

Passing a number specifies the $NUMBER variable:

./expect_response.exp 22

The other two variables ($NAME and $COLOR) are hardcoded.

Expect with Commands

Use the expect command to automate responses to other programs and commands.

For example, the passwd command prompts the user to input the password twice. While the process is simple for one user, difficulties arise when adding a default password for hundreds of new users as a system administrator.

Expect easily automates the responses to other commands.

1. The following script provides an example of using the expect command with the passwd command:

#!/usr/bin/expect
set USER [lindex $argv 0]
set PASS [lindex $argv 1]
set timeout 1
spawn passwd $USER
expect -exact "Enter new UNIX password: "
send -- "$PASS\r"
expect -exact "Retype new UNIX password: "
send -- "$PASS\r"
expect eof

The code takes two passed arguments as the username and password to provide for the passwd command.

2. Run the script with:

sudo expect password.exp <username> <password>

The script automatically sets the password for the provided username.

3. To automate the task for multiple users, use a while loop. The syntax for the TCL while loop is different from the Bash while loop:

#!/usr/bin/expect
set PASS "Welcome@123"
set i 1
set timeout 1
while {$i<11} {
        spawn passwd "user$i"
        expect -exact "Enter new UNIX password: "
        send -- "$PASS\r"
        expect -exact "Retype new UNIX password: "
        send -- "$PASS\r"
        expect eof
                incr i
}

The script assumes all users have the username user1, user2, etc., up to user10. The password is hardcoded as Welcome@123. After each user, the code increments the i value.

4. Run the script with:

For the code to work, the example assumes the users already exist on the system.

Autoexpect

Instead of writing Expect scripts from scratch, the Autoexpect program helps generate scripts interactively.

To demonstrate how Autoexpect works, do the following:

1. Run the Bash script from the first example (interactive_script.sh) using Autoexpect:

autoexpect ./interactive_script.sh

The output prints a confirmation message and the Expect script name (script.exp) to the console.

2. Provide answers to the questions. The replies save to the script.exp file and generate the Expect program code automatically. When complete, the output prints a confirmation.

3. Review the generated script in a text editor to see the code:

vim script.exp

The interactions are saved to the Expect script for future use.

Conclusion

After following the steps from this guide, you know the purpose of Expect scripts, the expect command, and some use cases.

Expect is a powerful automation tool for system administration tasks and code testing. Use the man command to review the complete manual for Expect.