Exploring Expect

A Tcl-based Toolkit for Automating Interactive Programs

Larger Cover

Exploring Expect

A Tcl-based Toolkit for Automating Interactive Programs

By Don Libes

Publisher: O'Reilly Media

Released: December 1994

Pages: 606

Expect is quickly becoming a part of every UNIX user's toolbox. It allows you to automate Telnet, FTP, passwd, rlogin, and hundreds of other applications that normally require human interaction. Using Expect to automate these applications will allow you to speed up tasks and, in many cases, solve new problems that you never would have even considered before.

For example, you can use Expect to test interactive programs with no changes to their interfaces. Or wrap interactive programs with Motif-like front-ends to control applications by buttons, scrollbars, and other graphic elements with no recompilation of the original programs. You don't even need the source code! Expect works with remote applications, too. Use it to tie together Internet applications including Telnet, Archie, FTP, Gopher, and Mosaic.

Don Libes is the creator of Expect as well as the author of this book. In Exploring Expect, he provides a comprehensive tutorial on all of Expect's features, allowing you to put it immediately to work on your problems. In a down-to-earth and humorous style, he provides numerous examples of challenging real-world applications and how they can be automated using Expect to save you time and money.

Expect is the first of a new breed of programs based on Tcl, the Tool Command Language that is rocking the computer science community. This book provides an introduction to Tcl and describes how Expect applies Tcl's power to the new field of interaction automation. Whether your interest is in Expect or interaction automation or you simply want to learn about Tcl and see how it has been used in real software, you will find Exploring Expect a treasure trove of easy-to-understand and valuable information.

Chapter 1 Intro—What Is Expect?
1. Ouch, Those Programs Are Painful!
2. A Very Brief Overview
3. A First Script—dialback
4. Total Automation
5. Differing Behavior When Running Non-Interactively
6. Partial Automation
7. Dangerous, Unfriendly, Or Otherwise Unlikable User Interfaces
8. Graphical Applications
9. A Little More About Tcl
10. Job Control
11. Background Processes
12. Using Expect With Other Programs
13. Using Expect On UNIX
14. Using Expect On Other Operating Systems
15. Using Expect In Real Applications
16. Using Expect In Commercial Applications—Legalese
17. Obtaining Expect and the Examples
18. Expect And Tcl Resources
19. Exercises
Chapter 2 Tcl—Introduction And Overview
1. Everything Is A String
2. Quoting Conventions
3. Expressions
4. Braces—Deferring Evaluation
5. Control Structures
6. More On Expressions
7. Lists
8. More Ways To Manipulate Strings
9. Arrays
10. Indirect References
11. Handling Errors
12. Evaluating Lists As Commands
13. Passing By Reference
14. Working With Files
15. File I/O
16. Executing UNIX Commands
17. Environment Variables
18. Handling Unknown Commands
19. Libraries
20. Is There More To Tcl?
21. Exercises
Chapter 3 Getting Started With Expect
1. The send Command
2. The expect Command
3. Anchoring
4. What Happens When Input Does Not Match
5. Pattern-Action Pairs
6. Example—Timed Reads In The Shell
7. The spawn Command
8. The interact Command
9. Example—Anonymous ftp
10. Exercises
Chapter 4 Glob Patterns And Other Basics
1. The * Wildcard
2. More Glob Patterns
3. Backslashes
4. Handling Timeout
5. Handling End Of File (eof)
6. Hints On The spawn Command
7. Back To Eof
8. The close Command
9. Programs That Ignore Eof
10. The wait Command
11. Exercises
Chapter 5 Regular Expressions
1. Regular Expressions—A Quick Start
2. Identifying Regular Expressions And Glob Patterns
3. Using Parentheses To Override Precedence
4. Using Parentheses For Feedback
5. More On The timed–read Script
6. Pattern Matching Strategy
7. Nested Parentheses
8. Always Count Parentheses Even Inside Of Alternatives
9. Example—The Return Value From A Remote Shell
10. Matching Customized Prompts
11. Example—A Smart Remote Login Script
12. What Else Gets Stored In expect_out
13. More On Anchoring
14. Exercises
Chapter 6 Patterns, Actions, And Limits
1. Matching Anything But
2. Really Complex Patterns
3. Really Simple Patterns
4. Matching One Line And Only One Line
5. Tcl’s string match Command
6. Tcl’s regexp Command
7. Tcl’s regsub Command
8. Ignoring Case
9. All Those Other String Functions Are Handy, Too
10. Actions That Affect Control Flow
11. Example—rogue
12. Character Graphics
13. More Actions That Affect Control Flow
14. Matching Multiple Times
15. Recognizing Prompts (Yet Again)
16. Speed Is On Your Side
17. Controlling The Limits Of Pattern Matching Input
18. The full_buffer Keyword
19. Double Buffering
20. Perpetual Buffering
21. The Politics Of Patterns
22. Expecting A Null Character
23. Parity
24. Length Limits
25. Comments In expect Commands
26. Restrictions On expect Arguments
27. eval—Good, Bad, And Ugly
28. Exercises
Chapter 7 Debugging Patterns And Controlling Output
1. Pattern Debugging
2. Enabling Internal Diagnostics
3. Logging Internal Diagnostics
4. Disabling Normal Program Output
5. The log_user Command
6. Example—su2
7. Recording All Expect Output
8. Sending Messages To The Log
9. About File Names
10. Log And Diagnostic State
11. Exercises
Chapter 8 Handling A Process And A User
1. The send_user Command
2. The send_error Command
3. The expect_user Command
4. Dealing With Programs That Reprompt
5. Dealing With Programs That Miss Input
6. Sleeping
7. Line Versus Character-Oriented And Other Terminal Modes
8. Echoing
9. Prompting For A Password On Behalf Of A Program
10. Security And Insecurity
11. Resetting The Terminal Upon Exit
12. More On The stty Command
13. The system Command
14. Redirecting The Standard Input Or Output
15. The expect_tty Command
16. The send_tty Command
17. Exercises
Chapter 9 The Expect Program
1. Expect—Just Another Program
2. Invoking Scripts Without Saying “expect”
3. Rewriting The #! Line
4. The .exp Extension
5. The—And Other Flags
6. The —c Flag
7. The -f Flag
8. Writing The #! Line
9. The −i Flag
10. The -n And -N Flags
11. The -d Flag
12. The -D Flag
13. The -b Flag
14. The - Flag
15. The interpreter Command
16. Exercises
Chapter 10 Handling Multiple Processes
1. The spawn_id Variable
2. Example—chess Versus chess
3. Example—Automating The write Command
4. How exp_continue Affects spawn_id
5. The Value Of spawn_id Affects Many Commands
6. Symbolic Spawn Ids
7. Job Control
8. Procedures Introduce New Scopes
9. How Expect Writes Variables In Different Scopes
10. Predefined Spawn Ids
11. Exercises
Chapter 11 Handling Multiple Processes Simultaneously
1. Implicit Versus Explicit Spawn Ids
2. Waiting From Multiple Processes Simultaneously
3. Example—Answerback
4. Which Pattern Goes With Which Spawn Id
5. Which Spawn Id Matched
6. Spawn Id Lists
7. Example—Connecting Together Two Users To An Application
8. Example—Timing All Commands
9. Matching Any Spawn Id Already Listed
10. The expect_before And expect_after Commands
11. Indirect Spawn Ids
12. Exercises
Chapter 12 Send
1. Implicit Versus Explicit Spawn Ids
2. Sending To Multiple Processes
3. Sending Without Echoing
4. Sending To Programs In Cooked Mode
5. Sending Slowly
6. Sending Humanly
7. Sending Nulls
8. Sending Breaks
9. Sending Strings That Look Like Flags
10. Sending Character Graphics
11. Comparing send To puts
12. Exercises
Chapter 13 Spawn
1. The Search Path
2. Philosophy--Processes Are Smart
3. Treating Files As Spawned Processes
4. Opening Ttys
5. Bugs And Workarounds
6. Process Pipelines And Ptys
7. Automating xterm
8. Checking For Errors From spawn
9. spawn -noecho
10. Example—unbuffer
11. Obtaining Console Output
12. Setting Pty Modes From spawn
13. Hung Ptys
14. Restrictions On Spawning Multiple Processes
15. Getting The Process Id From A Spawn Id
16. Using File I/O Commands On Spawned Processes
17. Exercises
Chapter 14 Signals
1. Signals
2. Signals In Spawned Processes
3. Notes On Specific Signals
4. When And Where Signals Are Evaluated
5. Overriding The Original Return Value
6. Using A Different Interpreter To Process Signals
7. Exit Handling
8. Exercises
Chapter 15 Interact
1. The interact Command
2. Simple Patterns
3. Exact Matching
4. Matching Patterns From The Spawned Process
5. Regular Expressions
6. What Happens To Things That Do Not Match
7. More Detail On Matching
8. Echoing
9. Avoiding Echoing
10. Giving Feedback Without -echo
11. Telling The User About New Features
12. Sending Characters While Pattern Matching
13. The continue And break Actions
14. The return Action
15. The Default Action
16. Detecting End-Of-File
17. Matching A Null Character
18. Timing Out
19. More On Terminal Modes (Or The -reset Flag)
20. Example—Preventing Bad Commands
21. Exercises
Chapter 16 Interacting With Multiple Processes
1. Connecting To A Process Other Than The Currently Spawned Process
2. Connecting To A Process Instead Of The User
3. Example—rz And sz Over rlogin
4. Redirecting Input And Output
5. Default Input And Output
6. Controlling Multiple Processes—kibitz
7. Combining Spawn Ids In A Single -input Or -output
8. Which Spawn Id Matched
9. Indirect Spawn Ids
10. An Extended Example—xkibitz
11. Exercises
Chapter 17 Background Processing
1. Putting Expect In The Background
2. Running Expect Without A Controlling Terminal
3. Disconnecting The Controlling Terminal
4. The fork Command
5. The disconnect Command
6. Reconnecting
7. Using kibitz From Other Expect Scripts
8. Mailing From Expect
9. A Manager For Disconnected Processes—dislocate
10. Expect As A Daemon
11. Example—Automating Gopher and Mosaic telnet Connections
12. Exercises
Chapter 18 Debugging Scripts
1. Tracing
2. Logging
3. Command Tracing
4. Variable Tracing
5. Example—Logging By Tracing
6. UNIX System Call Tracing
7. Tk And tkinspect
8. Traditional Debugging
9. Debugger Command Overview And Philosophy
10. Stepping Over Procedure Calls
11. Stepping Into Procedure Calls
12. Where Am I
13. The Current Scope
14. Moving Up And Down The Stack
15. Returning From A Procedure
16. Continuing Execution
17. Defining Breakpoints
18. Help
19. Changing Program Behavior
20. Changing Debugger Behavior
21. Exercises
Chapter 19 Expect + Tk = Expectk
1. Tk—A Brief Technical Overview
2. Expectk
3. The send Command
4. An Extended Example—tkpasswd
5. The expect Command And The Tk Event Loop
6. The expect_background Command
7. Multiple Spawn Ids In expect_background
8. Background Actions
9. Example—A Dumb Terminal Emulator
10. Example—A Smarter Terminal Emulator
11. Using The Terminal Emulator For Testing And Automation
12. Exercises
Chapter 20 Extended Examples
1. Encrypting A Directory
2. File Transfer Over telnet
3. You Have Unread News—tknewsbiff
4. Exercises
Chapter 21 Expect, C, And C++
1. Overview
2. Linking
3. Include Files
4. Ptys And Processes
5. Allocating Your Own Pty
6. Closing The Connection To The Spawned Process
7. Expect Commands
8. Regular Expression Patterns
9. Exact Matching
10. Matching A Null
11. What Characters Matched
12. When The Number Of Patterns Is Not Known In Advance
13. Expecting From Streams
14. Running In The Background
15. Handling Multiple Inputs And More On Timeouts
16. Output And Debugging Miscellany
17. Pty Trapping
18. Exercises
Chapter 22 Expect As Just Another Tcl Extension
1. Adding Expect To Another Tcl-based Program
2. Differences Between Expect And The Expect Extension In Another Program
3. Adding Extensions To Expect
4. Adding Extensions To Expectk
5. Creating Script-less Expect Programs
6. Functions And Variables In The Expect Extension
7. Exercises
Chapter 23 Miscellaneous
1. Random Numbers
2. Example—Generating Random Passwords
3. The Expect Library
4. Expect Versions
5. Timestamps
6. The time Command
7. Exercises

Appendix Appendix—Commands and Variables
1. Commands And Flags
2. Variables

Title:

Exploring Expect

By:

Don Libes

Publisher:

O'Reilly Media

Formats:

Print
Ebook
Safari Books Online

Print:

December 1994

Ebook:

August 2010

Pages:

606

Print ISBN:

978-1-56592-090-3

| ISBN 10:

1-56592-090-2

Ebook ISBN:

978-1-4493-8458-6

| ISBN 10:

1-4493-8458-7

Colophon

Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The animal featured on the cover of Exploring Expect is a chimpanzee, a primate of the Pongidae family, which also includes orangutans and gorillas. The chimpanzee is the mostly closely related to man of all animals, biochem ically, physiologically, behaviorally, and in brain structure. Chimpanzees are known to express emotions similar to those commonly associated with humans, including anger, affection, sadness, and happiness. They also display behavior similar to that of humans in their ability and inclination to pick up, examine, and manipulate objects. Until recently it was believed that humans are the only animals able to build tools. It has since been discovered that chimpanzees often build simple instruments to help retrieve food from holes in the ground, logs, or other hard-to-reach places.

Chimpanzees use a vast array of facial expressions, postures, and gestures to communicate with each other, in addition to at least 32 different sounds. There is some evidence to suggest that chimpanzees are able to learn symbolic languages.

The natural habitat of the chimpanzee is western Africa, from Sierra Leone to the Great Lakes east of the Congo. Living primarily in forested areas, chimpanzees will spend 50 to 70 percent of their time in trees. They are omnivores, eating primarily fruits and vegetables, but they will also hunt and eat small animals. They live in family groups, which consist of about twice as many females as males. While adult chimpanzees are not monogamous, there is a close bond between a young chimp and its parents, and this bond remains unbroken for life. Chimpanzees are very sociable and affectionate animals, and frequently hug, kiss, stroke each other, or hold hands. Violent fights often break out within a social group. The loser of the fight makes up to the winner by displaying submissive behavior and conciliatory gestures. In this way they maintain the social harmony.

Though able to, the chimpanzee rarely walks erect on both feet. Short arm muscles prevent simultaneous extension of the wrists and fingers. Because of this, chimpanzees are unable to walk with their hands flat; when walking on all fours, only the knuckles of their hands touch the ground. Unlike human feet, chimpanzee feet also have an opposing toe, but it is used mainly for climbing and for walking on precarious footing. The foot is rarely used for picking up objects. UNIX and its attendant programs can be unruly beasts. Nutshell Handbooks help you tame them. ... Edie Freedman designed this cover and the entire UNIX bestiary that appears on other Nutshell Handbooks. The beasts themselves are adapted from 19th-century engravings from the Dover Pictorial Archive. The cover layout was produced with Adobe Photoshop 2.5 and Quark XPress 3.3 for the Macintosh, using the Adobe ITC Garamond font.

The inside layout was designed by Edie Freedman and Jennifer Niederst and implemented by Mike Sierra in FrameMaker using Adobe ITC Garamond and New Courier fonts. The figures were created in FrameMaker by Don Libes. The colophon was written by Clairemarie Fisher O'Leary.

Description

Table of Contents

Product Details

About the Author

Colophon

Recommended for You

Customer Reviews

REVIEW SNAPSHOT®

by PowerReviews

oreillyExploring Expect

3.0

(based on 3 reviews)

Reviewed by 3 customers

Sort by

Displaying reviews 1-3

8/13/2005

(6 of 7 customers found this review helpful)

5.0

Great Reference!

By Russell Chapman

from Undisclosed

Comments about oreilly Exploring Expect:

Written by the author of the program, this book is exactly what I expected, and more.

If you enjoy automating tasks and writing scripts, Expect is a great addition to your toolbox, and this book is a great companion and welcome addition to your reference shelf.

In performing many UNIX administration tasks, one which my current job allowed me the opportunity to automate is a means of maintaining passwords on many servers. In particular, we have a requirement to change root's password on some 1600+ servers monthly, as well as our own passwords on hundreds of servers. We have every flavor of UNIX and more variations of what to expect interacting with ssh, telnet, Sun, HP, Linux, AIX, NCR, and as many differences among the system prompts. After buying this book, I found much of my learning curve easier. The examples and the overview of Tcl are priceless.

The Expect man pages are good, but having this book handy, with the program author's colorful and descriptive explanations has been a great help in the above and other successful tools using Expect.

This may seem as much a rave of Expect as well as this book, but as a fan of both and a person who prefers a good reference manual, Exploring Expect earns my recommendation.

8/8/2005

(3 of 8 customers found this review helpful)

1.0

not for beginners

By tjotjobina

from Undisclosed

Comments about oreilly Exploring Expect:

I have tried using this book to learn expect and are failed. Have given up learning expect since it seems there is no other book about expect. like a gentle introduction to expect. if u are a beginner dont bother with this

10/11/2000

(7 of 8 customers found this review helpful)

3.0

Exploring Expect Review

By Michael Chelomanov

from Undisclosed

Comments about oreilly Exploring Expect:

I much appreciate the author's efforts in writing such a wonderfull program but speaking about the book... I found it to be a bit hard to follow. The systemization in introducing this technology leaves much to be desired.

Most of the O'Reilly books you can literally can start reading and actually using them without of any prior experience in whatever the subject is, unfortunately it does not apply to the Exploring Expect book.

For example right now I need to find out how to programm cursor movemets via expect in order to navigate menu driven telnet interface, and quess what - the only mentioning of the arrows is on page 286, which asks me to write code, which will do it. SO I an surfing the WWW for the answer. I would think that would be quite common question, but for some reason it is not answered in the book.

Having said all above it is still a-must-to-have for any unix sysadmin it's O'Reilly book after all.

Displaying reviews 1-3

Save a Tree - Go Digital what is this?

Ebook: $27.99

Formats: DAISY, ePub, Mobi, PDF

Print & Ebook: $43.99

Print: $39.99

Safari Books Online - Read now >

Chapter 1 Intro—What Is Expect?

Ouch, Those Programs Are Painful!

A Very Brief Overview

A First Script—dialback

Total Automation

Differing Behavior When Running Non-Interactively

Partial Automation

Dangerous, Unfriendly, Or Otherwise Unlikable User Interfaces

Graphical Applications

A Little More About Tcl

Job Control

Background Processes

Using Expect With Other Programs

Using Expect On UNIX

Using Expect On Other Operating Systems

Using Expect In Real Applications

Using Expect In Commercial Applications—Legalese

Obtaining Expect and the Examples

Expect And Tcl Resources

Exercises

Chapter 2 Tcl—Introduction And Overview

Everything Is A String

Quoting Conventions

Expressions

Braces—Deferring Evaluation

Control Structures

More On Expressions

Lists

More Ways To Manipulate Strings

Arrays

Indirect References

Handling Errors

Evaluating Lists As Commands

Passing By Reference

Working With Files

File I/O

Executing UNIX Commands

Environment Variables

Handling Unknown Commands

Libraries

Is There More To Tcl?

Exercises

Chapter 3 Getting Started With Expect

The send Command

The expect Command

Anchoring

What Happens When Input Does Not Match

Pattern-Action Pairs

Example—Timed Reads In The Shell

The spawn Command

The interact Command

Example—Anonymous ftp

Exercises

Chapter 4 Glob Patterns And Other Basics

The * Wildcard

More Glob Patterns

Backslashes

Handling Timeout

Handling End Of File (eof)

Hints On The spawn Command

Back To Eof

The close Command

Programs That Ignore Eof

The wait Command

Exercises

Chapter 5 Regular Expressions

Regular Expressions—A Quick Start

Identifying Regular Expressions And Glob Patterns

Using Parentheses To Override Precedence

Using Parentheses For Feedback

More On The timed–read Script

Pattern Matching Strategy

Nested Parentheses

Always Count Parentheses Even Inside Of Alternatives

Example—The Return Value From A Remote Shell

Matching Customized Prompts

Example—A Smart Remote Login Script

What Else Gets Stored In expect_out

More On Anchoring

Exercises