Cover image for Exploring Expect

Exploring Expect

Author Don Libes
Release Date: 1994/12/01
ISBN: 9781565920903
Topic:
0%
59
Chapters
0-1
Hours read
0k
Total Words
    Start Reading Now    
       Add to Wishlist       
View table of contents

Book Description

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.

Table of Contents

  1. Exploring Expect
  2. Dedication
  3. A Note Regarding Supplemental Files
  4. Preface
    1. Expect—Why another tool?
    2. Tcl—A Little History
    3. Acknowledgments
    4. We’d Like to Hear From You
  5. How To Read This Book
    1. Notational Conventions
    2. Exercises
  6. 1. Intro—What Is Expect?
    1. Ouch, Those Programs Are Painful!
    2. A Very Brief Overview
    3. A First Script—dialback
    4. Total Automation
      1. Testing
    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
      1. Important Reading Material
      2. Other Books
      3. Other Online Documentation
      4. Support
    19. Exercises
  7. 2. Tcl—Introduction And Overview
    1. Everything Is A String
    2. Quoting Conventions
      1. Return Values
      2. Puts
    3. Expressions
    4. Braces—Deferring Evaluation
    5. Control Structures
      1. The while Command
      2. The incr Command
      3. The for Command
      4. The if Command
      5. The switch Command
      6. Continuation Lines
      7. The break And continue Commands
      8. The proc And return Commands
      9. The source Command
    6. More On Expressions
    7. Lists
      1. Selecting Elements Of Lists
      2. Varying Argument Lists
      3. Lists Of Lists
      4. Creating Lists
      5. The list And concat Commands
      6. Building Up Lists With The lappend Command
      7. The linsert Command
      8. The lreplace Command
      9. The lsearch Command
      10. The lsort Command
      11. The split And join Commands
    8. More Ways To Manipulate Strings
      1. The scan And format Commands
      2. The string Command
      3. The append Command
    9. Arrays
    10. Indirect References
      1. Variable Information
      2. Array Information
      3. Unsetting Variables
      4. Tracing Variables
    11. Handling Errors
      1. Causing Errors
    12. Evaluating Lists As Commands
    13. Passing By Reference
      1. Evaluating Commands In Other Scopes
    14. Working With Files
    15. File I/O
      1. File Name Matching
      2. Setting And Getting The Current Directory
      3. File Name Manipulation
      4. File Information
    16. Executing UNIX Commands
    17. Environment Variables
    18. Handling Unknown Commands
    19. Libraries
    20. Is There More To Tcl?
    21. Exercises
  8. 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
  9. 4. Glob Patterns And Other Basics
    1. The * Wildcard
      1. * At The Beginning Of A Pattern Is Rarely Useful
      2. * At The End Of A Pattern Can Be Tricky
    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
  10. 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
  11. 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
  12. 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
  13. 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
      1. Securing Scripts By File Protection
      2. Securing Scripts By Host Protection
    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
  14. 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
      1. The Terminal Mode During The interpreter Command
      2. The interpreter Prompt
      3. Changing The Prompt—prompt1 And prompt2
      4. Causing The interpreter Command To Return
      5. ^D
      6. Using interpreter In Production Scripts
    16. Exercises
  15. 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
  16. 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
      1. How Long Are expect_before And expect_after In Effect?
      2. Using expect_before And expect_after With The Currently Spawned Process—DANGER
      3. Undoing The Effects Of expect_before And expect_after
      4. Information On The Current expect_before And expect_after Patterns
      5. expect_before And expect_after Actions
    11. Indirect Spawn Ids
      1. Indirect Spawn Ids—Are They Really That Useful?
    12. Exercises
  17. 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
  18. 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
  19. 14. Signals
    1. Signals
    2. Signals In Spawned Processes
    3. Notes On Specific Signals
      1. SIGINT—Software Interrupt Signal
      2. SIGTERM—Software Termination Signal
      3. SIGQUIT—Quit Signal
      4. SIGKILL—Kill Signal
      5. SIGCHLD—Child Termination Signal
      6. SIGHUP—Hangup Signal
      7. SIGPIPE—Broken Pipe Signal
      8. SIGWINCH—Window Size Change Signal
      9. SIGTSTP—Terminal-Generated Stop SignalSIGSTOP—Kernel-Generated Stop SignalSIGCONT—Continue Signal
      10. SIGUSR1 And SIGUSR2—User-Defined Signals
      11. Other Signals
    4. When And Where Signals Are Evaluated
      1. Avoiding Problems Caused By Signal Handlers
    5. Overriding The Original Return Value
    6. Using A Different Interpreter To Process Signals
    7. Exit Handling
    8. Exercises
  20. 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
  21. 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
      1. How kibitz Works
    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
  22. 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
      1. Telling The System About Your Daemon
    12. Exercises
  23. 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
      1. Breakpoint By Line Number And Filename
      2. Breakpoint By Expression
      3. Breakpoint By Pattern Match
      4. Breakpoint Actions
      5. Limitations Of Breakpoint Actions And Interactive Commands
      6. General Form Of Breakpoints
      7. Listing Breakpoints
      8. Deleting Breakpoints
    18. Help
    19. Changing Program Behavior
    20. Changing Debugger Behavior
    21. Exercises
  24. 19. Expect + Tk = Expectk
    1. Tk—A Brief Technical Overview
      1. Widgets
      2. Other Widgets And Naming Conventions
      3. Displaying Widgets
      4. Bindings And Events
      5. The Event Loop
    2. Expectk
      1. Expectk Scripts
    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
      1. The term_expect Procedure
    12. Exercises
  25. 20. Extended Examples
    1. Encrypting A Directory
    2. File Transfer Over telnet
    3. You Have Unread News—tknewsbiff
      1. The tknewsbiff Script
    4. Exercises
  26. 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
      1. Caching Regular Expressions
    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
  27. 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
      1. Shared Variables
      2. Non-Shared Variables and Functions
    7. Exercises
  28. 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
  29. A. Appendix—Commands and Variables
    1. Commands And Flags
    2. Variables
  30. Index
  31. About the Author
  32. Copyright
3.129.70.157