shell expect 的介绍

原创 2007年09月13日 02:28:00


一、概述

我们通过Shell可以实现简单的控制流功能,如:循环、判断等。但是对于需要
交互的场合则必须通过人工来干预,有时候我们可能会需要实现
和交互程序如telnet服务器等进行交互的功能。而Expect就使用来实现这种功能
的工具。

Expect是一个免费的编程工具语言,用来实现自动和交互式任务进行通信,而无
需人的干预。Expect的作者Don
Libes在1990年开始编写Expect时对Expect做有如下定义:Expect是一个用来实
现自动交互功能的软件套件(Expect [is a] software suite
for automating interactive
tools)。使用它系统管理员的可以创建脚本用来实现对命令或程序提供输入,而
这些命令和程序是期望从终端(terminal)得到输入,一般来
说这些输入都需要手工输入进行的。Expect则可以根据程序的提示模拟标准输入
提供给程序需要的输入来实现交互程序执行。甚至可以实现实
现简单的BBS聊天机器人。

Expect是不断发展的,随着时间的流逝,其功能越来越强大,已经成为系统管理
员的的一个强大助手。Expect需要Tcl编程语言的支持,要在系
统上运行Expect必须首先安装Tcl。


二、Expect工作原理

从最简单的层次来说,Expect的工作方式象一个通用化的Chat脚本工具。Chat脚
本最早用于UUCP网络内,以用来实现计算机之间需要建立连接
时进行特定的登录会话的自动化。

Chat脚本由一系列expect-send对组成:expect等待输出中输出特定的字符,通
常是一个提示符,然后发送特定的响应。例如下面的Chat脚本实
现等待标准输出出现Login:字符串,然后发送somebody作为用户名;然后等待Pa
ssword:提示符,并发出响应sillyme。


QUOTE:
Login: somebody Password: sillyme
这个脚本用来实现一个登录过程,并用特定的用户名和密码实现登录。

Expect最简单的脚本操作模式本质上和Chat脚本工作模式是一样的。

例子:
1、实现功能
下面我们分析一个响应chsh命令的脚本。我们首先回顾一下这个交互命令的格式
。假设我们要为用户chavez改变登录脚本,要求实现的命令交
互过程如下:


QUOTE:
# chsh chavez
Changing the login shell for chavez
Enter the new value, or press return for the default
Login Shell [/bin/bash]: /bin/tcsh
#
可以看到该命令首先输出若干行提示信息并且提示输入用户新的登录shell。我
们必须在提示信息后面输入用户的登录shell或者直接回车不修
改登录shell。


2、下面是一个能用来实现自动执行该命令的Expect脚本:


CODE:[Copy to clipboard]#!/usr/bin/expect
# Change a login shell to tcsh

set user [lindex $argv 0]
spawn chsh $user
expect "]:"
send "/bin/tcsh "
expect eof
exit
这个简单的脚本可以解释很多Expect程序的特性。和其他脚本一样首行指定用来
执行该脚本的命令程序,这里是/usr/bin/expect。程序第一行
用来获得脚本的执行参数(其保存在数组$argv中,从0号开始是参数),并将其保
存到变量user中。

第二个参数使用Expect的spawn命令来启动脚本和命令的会话,这里启动的是chs
h命令,实际上命令是以衍生子进程的方式来运行的。

随后的expect和send命令用来实现交互过程。脚本首先等待输出中出现]:字符串
,一旦在输出中出现chsh输出到的特征字符串(一般特征字符串
往往是等待输入的最后的提示符的特征信息)。对于其他不匹配的信息则会完全
忽略。当脚本得到特征字符串时,expect将发送/bin/tcsh和一
个回车符给chsh命令。最后脚本等待命令退出(chsh结束),一旦接收到标识子进
程已经结束的eof字符,expect脚本也就退出结束。

3、决定如何响应

管理员往往有这样的需求,希望根据当前的具体情况来以不同的方式对一个命令
进行响应。我们可以通过后面的例子看到expect可以实现非常
复杂的条件响应,而仅仅通过简单的修改预处理脚本就可以实现。下面的例子是
一个更复杂的expect-send例子:


CODE:[Copy to clipboard]expect -re
"[(.*)]:"
if {$expect_out(1,string)!="/bin/tcsh"}
{
send "/bin/tcsh" }
send " "
expect eof
在这个例子中,第一个expect命令现在使用了-re参数,这个参数表示指定的的
字符串是一个正则表达式,而不是一个普通的字符串。对于上面
这个例子里是查找一个左方括号字符(其必须进行三次逃逸(escape),因此有三
个符号,因为它对于expect和正则表达时来说都是特殊字符)后
面跟有零个或多个字符,最后是一个右方括号字符。这里.*表示表示一个或多个
任意字符,将其存放在()中是因为将匹配结果存放在一个变量
中以实现随后的对匹配结果的访问。

当发现一个匹配则检查包含在[]中的字符串,查看是否为/bin/tcsh。如果不是
则发送/bin/tcsh给chsh命令作为输入,如果是则仅仅发送一个
回车符。这个简单的针对具体情况发出不同相响应的小例子说明了expect的强大
功能。

在一个正则表达时中,可以在()中包含若干个部分并通过expect_out数组访问它
们。各个部分在表达式中从左到右进行编码,从1开始(0包含有
整个匹配输出)。()可能会出现嵌套情况,这这种情况下编码从最内层到最外层
来进行的。

4、使用超时

下一个expect例子中将阐述具有超时功能的提示符函数。这个脚本提示用户输入
,如果在给定的时间内没有输入,则会超时并返回一个默认的
响应。这个脚本接收三个参数:提示符字串,默认响应和超时时间(秒)。


CODE:[Copy to clipboard]#!/usr/bin/expect
# Prompt function with timeout and default.
set prompt [lindex $argv 0]
set def [lindex $argv 1]
set response $def
set tout [lindex $argv 2]
脚本的第一部分首先是得到运行参数并将其保存到内部变量中。


CODE:[Copy to clipboard]send_tty "$prompt: "
set timeout $tout
expect " " {
set raw $expect_out(buffer)
# remove final carriage return
set response [string trimright "$raw" " "]
}
if {"$response" == "} {set response
$def}
send "$response "
# Prompt function with timeout and default.
set prompt [lindex $argv 0]
set def [lindex $argv 1]
set response $def
set tout [lindex $argv 2]
这是脚本其余的内容。可以看到send_tty命令用来实现在终端上显示提示符字串
和一个冒号及空格。set
timeout命令设置后面所有的expect命令的等待响应的超时时间为$tout(-l参数
用来关闭任何超时设置)。

然后expect命令就等待输出中出现回车字符。如果在超时之前得到回车符,那么
set命令就会将用户输入的内容赋值给变脸raw。随后的命令将
用户输入内容最后的回车符号去除以后赋值给变量response。

然后,如果response中内容为空则将response值置为默认值(如果用户在超时以
后没有输入或者用户仅仅输入了回车符)。最后send命令将respo
nse变量的值加上回车符发送给标准输出。

一个有趣的事情是该脚本没有使用spawn命令。
该expect脚本会与任何调用该脚本的进程交互。

如果该脚本名为prompt,那么它可以用在任何C风格的shell中。


% set a='prompt "Enter an answer" silence 10'
Enter an answer: test

% echo Answer was "$a"
Answer was test
prompt设定的超时为10秒。如果超时或者用户仅仅输入了回车符号,echo命令将
输出

Answer was "silence"

5、一个更复杂的例子

下面我们将讨论一个更加复杂的expect脚本例子,这个脚本使用了一些更复杂的
控制结构和很多复杂的交互过程。这个例子用来实现发送write
命令给任意的用户,发送的消息来自于一个文件或者来自于键盘输入。


CODE:[Copy to clipboard]#!/usr/bin/expect
# Write to multiple users from a prepared file
# or a message input interactively

if {$argc<2} {
send_user "usage: $argv0 file user1 user2 ... "
exit
}
send_user命令用来显示使用帮助信息到父进程(一般为用户的shell)的标准输出



CODE:[Copy to clipboard]set nofile 0
# get filename via the Tcl lindex function
set file [lindex $argv 0]
if {$file=="i"} {
set nofile 1
} else {
# make sure message file exists
if {[file isfile $file]!=1} {
send_user "$argv0: file $file not found. "
exit }}
这部分实现处理脚本启动参数,其必须是一个储存要发送的消息的文件名或表示
使用交互输入得到发送消的内容的"i"命令。

变量file被设置为脚本的第一个参数的值,是通过一个Tcl函数lindex来实现的
,该函数从列表/数组得到一个特定的元素。[]用来实现将函数l
index的返回值作为set命令的参数。

如果脚本的第一个参数是小写的"i",那么变量nofile被设置为1,否则通过调用
Tcl的函数isfile来验证参数指定的文件存在,如果不存在就报
错退出。

可以看到这里使用了if命令来实现逻辑判断功能。该命令后面直接跟判断条件,
并且执行在判断条件后的{}内的命令。if条件为false时则运行
else后的程序块。


CODE:[Copy to clipboard]set procs {}
# start write processes
for {set i 1} {$i<$argc}
{incr i} {
spawn -noecho write
[lindex $argv $i]
lappend procs $spawn_id
}
最后一部分使用spawn命令来启动write进程实现向用户发送消息。这里使用了fo
r命令来实现循环控制功能,循环变量首先设置为1,然后因此
递增。循环体是最后的{}的内容。这里我们是用脚本的第二个和随后的参数来sp
awn一个write命令,并将每个参数作为发送消息的用户名。lap
pend命令使用保存每个spawn的进程的进程ID号的内部变量$spawn_id在变量proc
s中构造了一个进程ID号列表。


CODE:[Copy to clipboard]if {$nofile==0} {
setmesg [open "$file" "r"]
} else {
send_user "enter message,
ending with ^D: " }
最后脚本根据变量nofile的值实现打开消息文件或者提示用户输入要发送的消息



CODE:[Copy to clipboard]set timeout -1
while 1 {
if {$nofile==0} {
if {[gets $mesg chars] == -1} break
set line "$chars "
} else {
expect_user {
-re " " {}
eof break }
set line $expect_out(buffer) }

foreach spawn_id $procs {
send $line }
sleep 1}
exit
上面这段代码说明了实际的消息文本是如何通过无限循环while被发送的。while
循环中的
if判断消息是如何得到的。在非交互模式下,下一行内容从消息文件中读出,当
文件内容结束时while循环也就结束了。(break命令实现终止循
环) 。

在交互模式下,expect_user命令从用户接收消息,当用户输入ctrl+D时结束输
入,循环同时结束。
两种情况下变量$line都被用来保存下一行消息内容。当是消息文件时,回车会
被附加到消息的尾部。

foreach循环遍历spawn的所有进程,这些进程的ID号都保存在列表变量$procs中
,实现分别和各个进程通信。send命令组成了foreach的循环体
,发送一行消息到当前的write进程。while循环的最后是一个sleep命令,主要
是用于处理非交互模式情况下,以确保消息不会太快的发送给各
个write进程。当while循环退出时,expect脚本结束。


三、参考资源

Expect软件版本深带有很多例子脚本,不但可以用于学习和理解expect脚本,而
且是非常使用的工具。一般可以在/usr/doc/packages/expect/
example看到它们,在某些linux发布中有些expect脚本保存在/usr/bin目录下。

Don Libes, Exploring Expect, O'Reilly & Associates, 1995.

John Ousterhout, Tcl and the Tk Toolkit, Addison-Wesley, 1994.

一些有用的expect脚本

autoexpect:这个脚本将根据自身在运行时用户的操作而生成一个expect脚本。
它的功能某种程度上类似于在Emacs编辑器的键盘宏工具。一个
自动创建的脚本可能是创建自己定制脚本的好的开始。

kibitz:这是一个非常有用的工具。通过它两个或更多的用户可以连接到同一个s
hell进程。

tkpasswd:
这个脚本提供了修改用户密码的GUI工具,包括可以检查密码是否是基于字典模
式。这个工具同时是一个学习expect和tk的好实例。


另附:


QUOTE:
创建时间:2001-04-29
文章属性:转载
文章来源:中国科大BBS站
文章提交:quack (quack_at_xfocus.org)

[版权声明]
  
  Copyright(c) 1999
    
  本教程由*葫芦娃*翻译,并做了适当的修改,可以自由的用于非商业目的。
  但Redistribution时必须拷贝本[版权声明]。      

[BUG]

  有不少部分,翻译的时候不能作到“信,达”。当然了,任何时候都没有做
到“雅”,希望各位谅解。

[原著]
 
  Don Libes: National Institute of Standards and Technology
    libes@cme.nist.gov

[目录]
  
  1.摘要
  2.关键字
  3.简介
  4.Expect综述
  5.callback
  6.passwd 和一致性检查
  7.rogue 和伪终端
  8.ftp
  9.fsck
  10.多进程控制:作业控制
  11.交互式使用Expect
  12.交互式Expect编程
  13.非交互式程序的控制
  14.Expect的速度
  15.安全方面的考虑
  16.Expect资源
  17.参考书籍

1.[摘要]

 
现代的Shell对程序提供了最小限度的控制(开始,停止,等等),而把交互的特
性留给了用户。
这意味着有些程序,你不能非交互的运行,比如说passwd。
有一些程序可以非交互的运行,但在很大程度上丧失了灵活性,比如说fsck。这
表明Unix的工具构造逻辑开始出现问题。Expect恰恰填补了其
中的一些裂痕,解决了在Unix环境中长期存在着的一些问题。

 
Expect使用Tcl作为语言核心。不仅如此,不管程序是交互和还是非交互的,Exp
ect都能运用。这是一个小语言和Unix的其他工具配合起来产生
强大功能的经典例子。
 
 
本部分教程并不是有关Expect的实现,而是关于Expect语言本身的使用,这主要
也是通过不同的脚本描述例子来体现。其中的几个例子还例证
了Expect的几个新特征。
 
2.[关键字]
  
  Expect,交互,POSIX,程序化的对话,Shell,Tcl,Unix;

3.[简介]
 
  一个叫做fsck的Unix文件系统检查程序,可以从Shell里面用-y或者-n选项
来执行。 在手册[1]里面,-y选项的定义是象这样的。

  “对于fsck的所有问题都假定一个“yes”响应;在这样使用的时候,必须
特别的小心,因为它实际上允许程序无条件的继续运行,即使是遇
到了一些非常严重的错误”
  
  相比之下,-n选项就安全的多,但它实际上几乎一点用都没有。这种接口非
常的糟糕,但是却有许多的程序都是这种风格。 文件传输程
序ftp有一个选项可以禁止交互式的提问,以便能从一个脚本里面运行。但一旦
发生了错误,它没有提供的处理措施。

  Expect是一个控制交互式程序的工具。他解决了fsck的问题,用非交互的方
式实现了所有交互式的功能。Expect不是特别为fsck设计的,
它也能进行类似ftp的出错处理。

  fsck和ftp的问题向我们展示了象sh,csh和别的一些shell提供的用户接口的
局限性。 Shell没有提供从一个程序读和象一个程序写的功能
。这意味着shell可以运行fsck但只能以牺牲一部分fsck的灵活性做代价。有一
些程序根本就不能被执行。比如说,如果没有一个用户接口交互
式的提供输入,就没法运行下去。其他还有象Telnet,crypt,su,rlogin等程序无
法在shell脚本里面自动执行。还有很多其他的应用程序在设计
是也是要求用户输入的。

  Expect被设计成专门针和交互式程序的交互。一个Expect程序员可以写一个
脚本来描述程序和用户的对话。接着Expect程序可以非交互的
运行“交互式”的程序。写交互式程序的脚本和写非交互式程序的脚本一样简单
。Expect还可以用于对对话的一部分进行自动化,因为程序的控
制可以在键盘和脚本之间进行切换。

bes[2]里面有详细的描述。简单的说,脚本是用一种解释性语言写的。(也有C和
C++的Expect库可供使用,但这超出了本文的范围).Expect提供
了创建交互式进程和读写它们的输入和输出的命令。 Expect是由于它的一个同
名的命令而命名的。

  Expect语言是基于Tcl的。Tcl实际上是一个子程序库,这些子程序库可以嵌
入到程序里从而提供语言服务。 最终的语言有点象一个典型
的Shell语言。里面有给变量赋值的set命令,控制程序执行的if,for,continue
等命令,还能进行普通的数学和字符串操作。当然了,还可以用
exec来调用Unix程序。所有这些功能,Tcl都有。Tcl在参考书籍
Outerhour[3][4]里有详细的描述。

  Expect是在Tcl基础上创建起来的,它还提供了一些Tcl所没有的命令。spaw
n命令激活一个Unix程序来进行交互式的运行。 send命令向进
程发送字符串。expect命令等待进程的某些字符串。 expect支持正规表达式并
能同时等待多个字符串,并对每一个字符串执行不同的操作。e
xpect还能理解一些特殊情况,如超时和遇到文件尾。

  expect命令和Tcl的case命令的风格很相似。都是用一个字符串去匹配多个
字符串。(只要有可能,新的命令总是和已有的Tcl命令相似,以
使得该语言保持工具族的继承性)。下面关于expect的定义是从手册[5]上摘录下
来的。

      expect patlist1 action1 patlist2 action2.....

    该命令一直等到当前进程的输出和以上的某一个模式相匹配,或者等 
   到时间超过一个特定的时间长度,或者等到遇到了文件
的结束为止。
    
    如果最后一个action是空的,就可以省略它。

    每一个patlist都由一个模式或者模式的表(lists)组成。如果有一个模
式匹配成功,相应的action就被执行。执行的结果从expect返
回。
    被精确匹配的字符串(或者当超时发生时,已经读取但未进行匹配的字
符串)被存贮在变量expect_match里面。如果patlist是eof或者t
imeout,则发生文件结束或者超时时才执行相应的action.一般超时的时值是10秒
,但可以用类似"set timeout
30"之类的命令把超时时值设定为30秒。
    
    下面的一个程序段是从一个有关登录的脚本里面摘取的。abort是在脚
本的别处定义的过程,而其他的action使用类似与C语言的Tcl原
语。

      expect "*welcome*"        break     
           "*busy*"        {print busy;continue}
          "*failed*"        abort 
          timeout        abort

    模式是通常的C
Shell风格的正规表达式。模式必须匹配当前进程的从上一个expect或者interac
t开始的所有输出(所以统配符*使用的非常)的普遍。但是,一
旦输出超过2000个字节,前面的字符就会被忘记,这可以通过设定match_max的
值来改变。

  expect命令确实体现了expect语言的最好和最坏的性质。特别是,expect命
令的灵活性是以经常出现令人迷惑的语法做代价。除了关键字
模式(比如说eof,timeout)那些模式表可以包括多个模式。这保证提供了一种方
法来区分他们。但是分开这些表需要额外的扫描,如果没有恰当
的用["]括起来,这有可能会把和当成空白字符。由于Tcl提供了两种字符串引用
的方法:单引和双引,情况变的更糟。(在Tcl里面,如果不会
出现二义性话,没有必要使用引号)。在expect的手册里面,还有一个独立的部
分来解释这种复杂性。幸运的是:有一些很好的例子似乎阻止了
这种抱怨。但是,这个复杂性很有可能在将来的版本中再度出现。为了增强可读
性,在本文中,提供的脚本都假定双引号是足够的。

  字符可以使用反斜杠来单独的引用,反斜杠也被用于对语句的延续,如果不
加反斜杠的话,语句到一行的结尾处就结束了。这和Tcl也是一
致的。Tcl在发现有开的单引号或者开的双引号时都会继续扫描。而且,分号可
以用于在一行中分割多个语句。这乍听起来有点让人困惑,但是
,这是解释性语言的风格,但是,这确实是Tcl的不太漂亮的部分。

5.[callback]

  令人非常惊讶的是,一些小的脚本如何的产生一些有用的功能。下面是一个
拨电话号码的脚本。他用来把收费反向,以便使得长途电话对
计算机计费。这个脚本用类似“expect callback.exp
12016442332”来激活。其中,脚本的名字便是callback.exp,而+1(201)644-23
32是要拨的电话号码。

    #first give the user some time to logout
    exec sleep 4
    spawn tip modem
    expect "*connected*"
    send "ATD [llindex $argv 1] "
    #modem takes a while to connect
    set timeout 60
    expect "*CONNECT*"

  第一行是注释,第二行展示了如何调用没有交互的Unix程序。sleep
4会使程序阻塞4秒,以使得用户有时间来退出,因为modem总是会回叫用户已经
使用的电话号码。

  下面一行使用spawn命令来激活tip程序,以便使得tip的输出能够被expect
所读取,使得tip能从send读输入。一旦tip说它已经连接上,mo
dem就会要求去拨打大哥电话号码。(假定modem都是贺氏兼容的,但是本脚本可
以很容易的修改成能适应别的类型的modem)。不论发生了什么,
expect都会终止。如果呼叫失败,expect脚本可以设计成进行重试,但这里没有
。如果呼叫成功,getty会在expect退出后检测到DTR,并且向
用户提示loging:。(实用的脚本往往提供更多的错误检测)。

  这个脚本展示了命令行参数的使用,命令行参数存贮在一个叫做argv的表里
面(这和C语言的风格很象)。在这种情况下,第一个元素就是电
话号码。方括号使得被括起来的部分当作命令来执行,结果就替换被括起来的部
分。这也和C Shell的风格很象。

  这个脚本和一个大约60K的C语言程序实现的功能相似。
    

6.[passwd和一致性检查]

  在前面,我们提到passwd程序在缺乏用户交互的情况下,不能运行,passwd
会忽略I/O重定向,也不能嵌入到管道里边以便能从别的程序或
者文件里读取输入。这个程序坚持要求真正的与用户进行交互。因为安全的原因
,passwd被设计成这样,但结果导致没有非交互式的方法来检
验passwd。这样一个对系统安全至关重要的程序竟然没有办法进行可靠的检验,
真实具有讽刺意味。

  passwd以一个用户名作为参数,交互式的提示输入密码。下面的expect脚本
以用户名和密码作为参数而非交互式的运行。

    spawn oasswd [lindex $argv 1]
    set password [lindex $argv 2]
    expect "*password:"
    send "$password "
    expect "*password:"
    send "$password "
    expect eof

  第一行以用户名做参数启动passwd程序,为方便起见,第二行把密码存到一
个变量里面。和shell类似,变量的使用也不需要提前声明。

  在第三行,expect搜索模式"*password:",其中*允许匹配任意输入,所以
对于避免指定所有细节而言是非常有效的。
上面的程序里没有action,所以expect检测到该模式后就继续运行。

  一旦接收到提示后,下一行就就把密码送给当前进程。表明回车。(实际上
,所有的C的关于字符的约定都支持)。上面的程序中有两个expe
ct-send序列,因为passwd为了对输入进行确认,要求进行两次输入。在非交互
式程序里面,这是毫无必要的,但由于假定passwd是在和用户进
行交互,所以我们的脚本还是这样做了。

  最后,"expect
eof"这一行的作用是在passwd的输出中搜索文件结束符,这一行语句还展示了关
键字的匹配。另外一个关键字匹配就是timeout了,timeout被
用于表示所有匹配的失败而和一段特定长度的时间相匹配。在这里eof是非常有
必要的,因为passwd被设计成会检查它的所有I/O是否都成功了
,包括第二次输入密码时产生的最后一个新行。

  这个脚本已经足够展示passwd命令的基本交互性。另外一个更加完备的例子
回检查别的一些行为。比如说,下面的这个脚本就能检查passw
d程序的别的几个方面。所有的提示都进行了检查。对垃圾输入的检查也进行了
适当的处理。进程死亡,超乎寻常的慢响应,或者别的非预期的
行为都进行了处理。

    spawn passwd [lindex $argv 1]
    expect     eof            {exit 1}     
        timeout            {exit 2}    
        "*No such user.*"    {exit 3}    
        "*New password:"    
    send "[lindex $argv 2 "
    expect     eof            {exit 4}    
        timeout            {exit 2}    
        "*Password too long*"    {exit 5}    
        "*Password too short*"    {exit 5}    
        "*Retype ew password:"
    send "[lindex $argv 3] "
    expect     timeout            {exit 2}    
        "*Mismatch*"        {exit 6}    
        "*Password unchanged*"    {exit 7}    
        " "        
    expect    timeout            {exit 2}    
        "*"            {exit 6}    
        eof

   
  这个脚本退出时用一个数字来表示所发生的情况。0表示passwd程序正常运
行,1表示非预期的死亡,2表示锁定,等等。使用数字是为了简
单起见。expect返回字符串和返回数字是一样简单的,即使是派生程序自身产生
的消息也是一样的。实际上,典型的做法是把整个交互的过程
存到一个文件里面,只有当程序的运行和预期一样的时候才把这个文件删除。否
则这个log被留待以后进一步的检查。

  这个passwd检查脚本被设计成由别的脚本来驱动。这第二个脚本从一个文件
里面读取参数和预期的结果。对于每一个输入参数集,它调用
第一个脚本并且把结果和预期的结果相比较。(因为这个任务是非交互的,一个
普通的老式shell就可以用来解释第二个脚本)。比如说,一个pa
sswd的数据文件很有可能就象下面一样。

    passwd.exp    3    bogus    -        -
    passwd.exp    0    fred    abledabl    abledab
l
    passwd.exp    5    fred    abcdefghijklm    -
    passwd.exp    5    fred    abc        -
    passwd.exp    6    fred    foobar        b
ar    
    passwd.exp    4    fred    ^C        -

  第一个域的名字是要被运行的回归脚本。第二个域是需要和结果相匹配的退
出值。第三个域就是用户名。第四个域和第五个域就是提示时
应该输入的密码。减号仅仅表示那里有一个域,这个域其实绝对不会用到。在第
一个行中,bogus表示用户名是非法的,因此passwd会响应说:
没有此用户。expect在退出时会返回3,3恰好就是第二个域。在最后一行中,^C
就是被切实的送给程序来验证程序是否恰当的退出。

  通过这种方法,expect可以用来检验和调试交互式软件,这恰恰是IEEE的PO
SIX
1003.2(shell和工具)的一致性检验所要求的。进一步的说明请参考Libes[6]。

7.[rogue 和伪终端]

  Unix用户肯定对通过管道来和其他进程相联系的方式非常的熟悉(比如说:
一个shell管道)。expect使用伪终端来和派生的进程相联系。伪
终端提供了终端语义以便程序认为他们正在和真正的终端进行I/O操作。

  比如说,BSD的探险游戏rogue在生模式下运行,并假定在连接的另一端是一
个可寻址的字符终端。可以用expect编程,使得通过使用用户
界面可以玩这个游戏。

  rogue这个探险游戏首先提供给你一个有各种物理属性,比如说力量值,的
角色。在大部分时间里,力量值都是16,但在几乎每20次里面就
会有一个力量值是18。很多的rogue玩家都知道这一点,但没有人愿意启动程序2
0次以获得一个好的配置。下面的这个脚本就能达到这个目的。

    for {} {1} {} {
        spawn rogue
        expect "*Str:18*"    break    
            "*Str:16*"    
        close
        wait
    }
    interact

  第一行是个for循环,和C语言的控制格式很象。rogue启动后,expect就检
查看力量值是18还是16,如果是16,程序就通过执行close和wai
t来退出。这两个命令的作用分别是关闭和伪终端的连接和等待进程退出。rogue
读到一个文件结束符就推出,从而循环继续运行,产生一个新
的rogue游戏来检查。

  当一个值为18的配置找到后,控制就推出循环并跳到最后一行脚本。intera
ct把控制转移给用户以便他们能够玩这个特定的游戏。

  想象一下这个脚本的运行。你所能真正看到的就是20或者30个初始的配置在
不到一秒钟的时间里掠过屏幕,最后留给你的就是一个有着很
好配置的游戏。唯一比这更好的方法就是使用调试工具来玩游戏。

  我们很有必要认识到这样一点:rogue是一个使用光标的图形游戏。expect
程序员必须了解到:光标的运动并不一定以一种直观的方式在屏
幕上体现。幸运的是,在我们这个例子里,这不是一个问题。将来的对expect的
改进可能会包括一个内嵌的能支持字符图形区域的终端模拟器


8.[ftp]

  我们使用expect写第一个脚本并没有打印出"Hello,World"。实际上,它实
现了一些更有用的功能。它能通过非交互的方式来运行ftp。ftp
是用来在支持TCP/IP的网络上进行文件传输的程序。除了一些简单的功能,一般
的实现都要求用户的参与。

  下面这个脚本从一个主机上使用匿名ftp取下一个文件来。其中,主机名是
第一个参数。文件名是第二个参数。

        spawn    ftp    [lindex $argv 1]
        expect "*Name*"
        send     "anonymous "
        expect "*Password:*"
        send [exec whoami]
        expect "*ok*ftp>;*"
        send "get [lindex $argv 2] "
        expect "*ftp>;*"

  上面这个程序被设计成在后台进行ftp。虽然他们在底层使用和expect类似
的机制,但他们的可编程能力留待改进。因为expect提供了高级
语言,你可以对它进行修改来满足你的特定需求。比如说,你可以加上以下功能


    :坚持--如果连接或者传输失败,你就可以每分钟或者每小时,甚
        至可以根据其他因素,比如说用户的负载,来进行不定期的
        重试。
    :通知--传输时可以通过mail,write或者其他程序来通知你,甚至
        可以通知失败。
    :初始化-每一个用户都可以有自己的用高级语言编写的初始化文件
        (比如说,.ftprc)。这和C shell对.cshrc的使用很类似。

  expect还可以执行其他的更复杂的任务。比如说,他可以使用McGill大学的
Archie系统。Archie是一个匿名的Telnet服务,它提供对描述I
nternet上可通过匿名ftp获取的文件的数据库的访问。通过使用这个服务,脚本
可以询问Archie某个特定的文件的位置,并把它从ftp服务器上
取下来。这个功能的实现只要求在上面那个脚本中加上几行就可以。

  现在还没有什么已知的后台-ftp能够实现上面的几项功能,能不要说所有的
功能了。在expect里面,它的实现却是非常的简单。“坚持”的
实现只要求在expect脚本里面加上一个循环。“通知”的实现只要执行mail和wr
ite就可以了。“初始化文件”的实现可以使用一个命令,source
.ftprc,就可以了,在.ftprc里面可以有任何的expect命令。

  虽然这些特征可以通过在已有的程序里面加上钩子函数就可以,但这也不能
保证每一个人的要求都能得到满足。唯一能够提供保证的方法
就是提供一种通用的语言。一个很好的解决方法就是把Tcl自身融入到ftp和其他
的程序中间去。实际上,这本来就是Tcl的初衷。在还没有这样
做之前,expect提供了一个能实现大部分功能但又不需要任何重写的方案。

9.[fsck]

  fsck是另外一个缺乏足够的用户接口的例子。fsck几乎没有提供什么方法来
预先的回答一些问题。你能做的就是给所有的问题都回答"yes"
或者都回答"no"。

  下面的程序段展示了一个脚本如何的使的自动的对某些问题回答"yes",而
对某些问题回答"no"。下面的这个脚本一开始先派生fsck进程,
然后对其中两种类型的问题回答"yes",而对其他的问题回答"no"。

    for {} {1} {} {
        expect
            eof        break        
            "*UNREF FILE*CLEAR?"    {send "r
"}    
            "*BAD INODE*FIX?"    {send "y "}    
            "*?"            {send "n
"}    
    }

  在下面这个版本里面,两个问题的回答是不同的。而且,如果脚本遇到了什
么它不能理解的东西,就会执行interact命令把控制交给用户
。用户的击键直接交给fsck处理。当执行完后,用户可以通过按"+"键来退出或
者把控制交还给expect。如果控制是交还给脚本了,脚本就会自
动的控制进程的剩余部分的运行。

    for {} {1} {}{
        expect             
            eof        break        
            "*UNREF FILE*CLEAR?"    {send "y
"}    
            "*BAD INODE*FIX?"    {send "y "}    
            "*?"            {interact
+}    
    }

  如果没有expect,fsck只有在牺牲一定功能的情况下才可以非交互式的运行
。fsck几乎是不可编程的,但它却是系统管理的最重要的工具
。许多别的工具的用户接口也一样的不足。实际上,正是其中的一些程序的不足
导致了expect的诞生。

10.[控制多个进程:作业控制]


 
expect的作业控制概念精巧的避免了通常的实现困难。其中包括了两个问题:一
个是expect如何处理经典的作业控制,即当你在终端上按下^Z
键时expect如何处理;另外一个就是expect是如何处理多进程的。

 
对第一个问题的处理是:忽略它。expect对经典的作业控制一无所知。比如说,
你派生了一个程序并且发送一个^Z给它,它就会停下来(这是伪
终端的完美之处)而expect就会永远的等下去。

 
但是,实际上,这根本就不成一个问题。对于一个expect脚本,没有必要向进程
发送^Z。也就是说,没有必要停下一个进程来。expect仅仅是
忽略了一个进程,而把自己的注意力转移到其他的地方。这就是expect的作业控
制思想,这个思想也一直工作的很好。

  从用户的角度来看是象这样的:当一个进程通过spawn命令启动时,变量spa
wn_id就被设置成某进程的描述符。由spawn_id描述的进程就被
认为是当前进程。(这个描述符恰恰就是伪终端文件的描述符,虽然用户把它当
作一个不透明的物体)。expect和send命令仅仅和当前进程进行
交互。所以,切换一个作业所需要做的仅仅是把该进程的描述符赋给spawn_id。

  这儿有一个例子向我们展示了如何通过作业控制来使两个chess进程进行交
互。在派生完两个进程之后,一个进程被通知先动一步。在下面
的循环里面,每一步动作都送给另外一个进程。其中,read_move和write_move
两个过程留给读者来实现。(实际上,它们的实现非常的容易,
但是,由于太长了所以没有包含在这里)。

    spawn chess            ;# start player one
    set id1    $spawn_id
    expect "Chess "
    send "first "            ;# force it to go first
    read_move

    spawn chess            ;# start player two
    set id2    $spawn_id
    expect "Chess "
    
    for {} {1} {}{
        send_move
        read_move
        set spawn_id    $id1
        
        send_move
        read_move
        set spawn_id    $id2
    }

  
有一些应用程序和chess程序不太一样,在chess程序里,的两个玩家轮流动。下
面这个脚本实现了一个冒充程序。它能够控制一个终端以便用
户能够登录和正常的工作。但是,一旦系统提示输入密码或者输入用户名的时候
,expect就开始把击键记下来,一直到用户按下回车键。这有
效的收集了用户的密码和用户名,还避免了普通的冒充程序的"Incorrect
password-tryagain"。而且,如果用户连接到另外一个主机上,那些额外的登录
也会被记录下来。

    spawn tip /dev/tty17        ;# open connection to
    set tty $spawn_id        ;# tty to be spoofed

    spawn login
    set login $spawn_id

    log_user 0
    
    for {} {1} {} {
        set ready [select $tty $login]
        
        case $login in $ready {
            set spawn_id $login
            expect         
              {"*password*" "*login*"}{
                  send_user $expect_match
                  set log 1
                 }    
              "*"        ;# ignore everything
else
            set spawn_id    $tty;
            send $expect_match
        }
        case $tty in $ready {
            set spawn_id    $tty
            expect "* *"{
                    if $log {
                      send_user $expect_match
                      set log 0
                    }
                   }    
                "*" {
                    send_user $expect_match
                   }
            set spawn_id     $login;
            send $expect_match
        }
    }
        

  
这个脚本是这样工作的。首先连接到一个login进程和终端。缺省的,所有的对
话都记录到标准输出上(通过send_user)。因为我们对此并不感
兴趣,所以,我们通过命令"log_user
0"来禁止这个功能。(有很多的命令来控制可以看见或者可以记录的东西)。

  
在循环里面,select等待终端或者login进程上的动作,并且返回一个等待输入
的spawn_id表。如果在表里面找到了一个值的话,case就执行一
个action。比如说,如果字符串"login"出现在login进程的输出中,提示就会被
记录到标准输出上,并且有一个标志被设置以便通知脚本开始
记录用户的击键,直至用户按下了回车键。无论收到什么,都会回显到终端上,
一个相应的action会在脚本的终端那一部分执行。

  
这些例子显示了expect的作业控制方式。通过把自己插入到对话里面,expect可
以在进程之间创建复杂的I/O流。可以创建多扇出,复用扇入的
,动态的数据相关的进程图。

  
相比之下,shell使得它自己一次一行的读取一个文件显的很困难。shell强迫用
户按下控制键(比如,^C,^Z)和关键字(比如fg和bg)来实现作业
的切换。这些都无法从脚本里面利用。相似的是:以非交互方式运行的shell并
不处理“历史记录”和其他一些仅仅为交互式使用设计的特征。这
也出现了和前面哪个passwd程序的相似问题。相似的,也无法编写能够回归的测
试shell的某些动作的shell脚本。结果导致shell的这些方面无
法进行彻底的测试。

  
如果使用expect的话,可以使用它的交互式的作业控制来驱动shell。一个派生
的shell认为它是在交互的运行着,所以会正常的处理作业控制
。它不仅能够解决检验处理作业控制的shell和其他一些程序的问题。还能够在
必要的时候,让shell代替expect来处理作业。可以支持使用she
ll风格的作业控制来支持进程的运行。这意味着:首先派生一个shell,然后把
命令送给shell来启动进程。如果进程被挂起,比如说,发送了
一个^Z,进程就会停下来,并把控制返回给shell。对于expect而言,它还在处
理同一个进程(原来那个shell)。

  expect的解决方法不仅具有很大的灵活性,它还避免了重复已经存在于shel
l中的作业控制软件。通过使用shell,由于你可以选择你想派
生的shell,所以你可以根据需要获得作业控制权。而且,一旦你需要(比如说检
验的时候),你就可以驱动一个shell来让这个shell以为它正在
交互式的运行。这一点对于在检测到它们是否在交互式的运行之后会改变输出的
缓冲的程序来说也是很重要的。

  为了进一步的控制,在interact执行期间,expect把控制终端(是启动expec
t的那个终端,而不是伪终端)设置成生模式以便字符能够正确
的传送给派生的进程。当expect在没有执行interact的时候,终端处于熟模式下
,这时候作业控制就可以作用于expect本身。

11.[交互式的使用expect]

  在前面,我们提到可以通过interact命令来交互式的使用脚本。基本上来说
,interact命令提供了对对话的自由访问,但我们需要一些更
精细的控制。这一点,我们也可以使用expect来达到,因为expect从标准输入中
读取输入和从进程中读取输入一样的简单。
但是,我们要使用expect_user和send_user来进行标准I/O,同时不改变spawn_i
d。

  下面的这个脚本在一定的时间内从标准输入里面读取一行。这个脚本叫做ti
med_read,可以从csh里面调用,比如说,set
answer="timed_read 30"就能调用它。

    #!/usr/local/bin/expect -f
    set timeout [lindex $argv 1]
    expect_user "* "
    send_user $expect_match

  
第三行从用户那里接收任何以新行符结束的任何一行。最后一行把它返回给标准
输出。如果在特定的时间内没有得到任何键入,则返回也为空


  
第一行支持"#!"的系统直接的启动脚本。(如果把脚本的属性加上可执行属性则
不要在脚本前面加上expect)。当然了脚本总是可以显式的用"ex
pect
scripot"来启动。在-c后面的选项在任何脚本语句执行前就被执行。比如说,不
要修改脚本本身,仅仅在命令行上加上-c
"trace...",该脚本可以加上trace功能了(省略号表示trace的选项)。

  
在命令行里实际上可以加上多个命令,只要中间以";"分开就可以了。比如说,
下面这个命令行:

    expect -c "set timeout 20;spawn foo;expect"

   一旦你把超时时限设置好而且程序启动之后,expect就开始等待文件结束
符或者20秒的超时时限。
如果遇到了文件结束符(EOF),该程序就会停下来,然后expect返回。如果是遇
到了超时的情况,expect就返回。在这两中情况里面,都隐式的
杀死了当前进程。

  
如果我们不使用expect而来实现以上两个例子的功能的话,我们还是可以学习到
很多的东西的。在这两中情况里面,通常的解决方案都是fork
另一个睡眠的子进程并且用signal通知原来的shell。如果这个过程或者读先发
生的话,shell就会杀司那个睡眠的进程。
传递pid和防止后台进程产生启动信息是一个让除了高手级shell程序员之外的人
头痛的事情。提供一个通用的方法来象这样启动多个进程会使s
hell脚本非常的复杂。
所以几乎可以肯定的是,程序员一般都用一个专门C程序来解决这样一个问题。

   expect_user,send_user,send_error(向标准错误终端输出)在比较长的,
用来把从进程来的复杂交互翻译成简单交互的expect脚本里面
使用的比较频繁。在参考[7]里面,Libs描述怎样用脚本来安全的包裹(wrap)adb
,怎样把系统管理员从需要掌握adb的细节里面解脱出来,同时
大大的降低了由于错误的击键而导致的系统崩溃。

   一个简单的例子能够让ftp自动的从一个私人的帐号里面取文件。在这种
情况里,要求提供密码。
即使文件的访问是受限的,你也应该避免把密码以明文的方式存储在文件里面。
把密码作为脚本运行时的参数也是不合适的,因为用ps命令能
看到它们。有一个解决的方法就是在脚本运行的开始调用expect_user来让用户
输入以后可能使用的密码。这个密码必须只能让这个脚本知道,
即使你是每个小时都要重试ftp。

   即使信息是立即输入进去的,这个技巧也是非常有用。比如说,你可以写
一个脚本,把你每一个主机上不同的帐号上的密码都改掉,不
管他们使用的是不是同一个密码数据库。如果你要手工达到这样一个功能的话,
你必须Telnet到每一个主机上,并且手工输入新的密码。而使
用expect,你可以只输入密码一次而让脚本来做其它的事情。

   expect_user和interact也可以在一个脚本里面混合的使用。考虑一下在
调试一个程序的循环时,经过好多步之后才失败的情况。一个ex
pect脚本可以驱动哪个调试器,设置好断点,执行该程序循环的若干步,然后将
控制返回给键盘。它也可以在返回控制之前,在循环体和条件
测试之间来回的切换。

6.[passwd和一致性检查]

  在前面,我们提到passwd程序在缺乏用户交互的情况下,不能运行,passwd
会忽略I/O重定向,也不能嵌入到管道里边以便能从别的程序或者文件里读取输
入。这个程序坚持要求真正的与用户进行交互。因为安全的原因,passwd被设计
成这样,但结果导致没有非交互式的方法来检验passwd。这样一个对系统安全
至关重要的程序竟然没有办法进行可靠的检验,真实具有讽刺意味。

  passwd以一个用户名作为参数,交互式的提示输入密码。下面的expect脚
本以用户名和密码作为参数而非交互式的运行。

    spawn oasswd [lindex $argv 1]
    set password [lindex $argv 2]
    expect "*password:"
    send "$password "
    expect "*password:"
    send "$password "
    expect eof

  第一行以用户名做参数启动passwd程序,为方便起见,第二行把密码存到
一个变量里面。和shell类似,变量的使用也不需要提前声明。

  在第三行,expect搜索模式"*password:",其中*允许匹配任意输入,所
以对于避免指定所有细节而言是非常有效的。 上面的程序里没有action,所以
expect检测到该模式后就继续运行。

  一旦接收到提示后,下一行就就把密码送给当前进程。表明回车。(实
际上,所有的C的关于字符的约定都支持)。上面的程序中有两个expect-send
序列,因为passwd为了对输入进行确认,要求进行两次输入。在非交互式程序
里面,这是毫无必要的,但由于假定passwd是在和用户进行交互,所以我们的
脚本还是这样做了。

  最后,"expect eof"这一行的作用是在passwd的输出中搜索文件结束符,
这一行语句还展示了关键字的匹配。另外一个关键字匹配就是timeout了,
timeout被用于表示所有匹配的失败而和一段特定长度的时间相匹配。在这里
eof是非常有必要的,因为passwd被设计成会检查它的所有I/O是否都成功了,
包括第二次输入密码时产生的最后一个新行。

  这个脚本已经足够展示passwd命令的基本交互性。另外一个更加完备的例
子回检查别的一些行为。比如说,下面的这个脚本就能检查passwd程序的别的
几个方面。所有的提示都进行了检查。对垃圾输入的检查也进行了适当的处
理。进程死亡,超乎寻常的慢响应,或者别的非预期的行为都进行了处理。


    spawn passwd [lindex $argv 1]
    expect     eof            {exit 1}     
        timeout            {exit 2}    
        "*No such user.*"    {exit 3}    
        "*New password:"    
    send "[lindex $argv 2 "
    expect     eof            {exit 4}    
        timeout            {exit 2}    
        "*Password too long*"    {exit 5}    
        "*Password too short*"    {exit 5}    
        "*Retype ew password:"
    send "[lindex $argv 3] "
    expect     timeout            {exit 2}    
        "*Mismatch*"        {exit 6}    
        "*Password unchanged*"    {exit 7}    
        " "        
    expect    timeout            {exit 2}    
        "*"            {exit 6}    
        eof

   
  这个脚本退出时用一个数字来表示所发生的情况。0表示passwd程序正常
运行,1表示非预期的死亡,2表示锁定,等等。使用数字是为了简单起见。
expect返回字符串和返回数字是一样简单的,即使是派生程序自身产生的消息
也是一样的。实际上,典型的做法是把整个交互的过程存到一个文件里面,只
有当程序的运行和预期一样的时候才把这个文件删除。否则这个log被留待以
后进一步的检查。

  这个passwd检查脚本被设计成由别的脚本来驱动。这第二个脚本从一个文
件里面读取参数和预期的结果。对于每一个输入参数集,它调用第一个脚本并
且把结果和预期的结果相比较。(因为这个任务是非交互的,一个普通的老式
shell就可以用来解释第二个脚本)。比如说,一个passwd的数据文件很有可能
就象下面一样。

    passwd.exp    3    bogus    -        -
    passwd.exp    0    fred    abledabl    abledab
l
    passwd.exp    5    fred    abcdefghijklm    -
    passwd.exp    5    fred    abc        -
    passwd.exp    6    fred    foobar        b
ar    
    passwd.exp    4    fred    ^C        -

  第一个域的名字是要被运行的回归脚本。第二个域是需要和结果相匹配的
退出值。第三个域就是用户名。第四个域和第五个域就是提示时应该输入的密
码。减号仅仅表示那里有一个域,这个域其实绝对不会用到。在第一个行中
,bogus表示用户名是非法的,因此passwd会响应说:没有此用户。expect在
退出时会返回3,3恰好就是第二个域。在最后一行中,^C就是被切实的送给程
序来验证程序是否恰当的退出。

  通过这种方法,expect可以用来检验和调试交互式软件,这恰恰是IEEE的
POSIX 1003.2(shell和工具)的一致性检验所要求的。进一步的说明请参考
Libes[6]。

7.[rogue 和伪终端]

  Unix用户肯定对通过管道来和其他进程相联系的方式非常的熟悉(比如说:
一个shell管道)。expect使用伪终端来和派生的进程相联系。伪终端提供了终
端语义以便程序认为他们正在和真正的终端进行I/O操作。

  比如说,BSD的探险游戏rogue在生模式下运行,并假定在连接的另一端是
一个可寻址的字符终端。可以用expect编程,使得通过使用用户界面可以玩这
个游戏。

  rogue这个探险游戏首先提供给你一个有各种物理属性,比如说力量值,的
角色。在大部分时间里,力量值都是16,但在几乎每20次里面就会有一个力量
值是18。很多的rogue玩家都知道这一点,但没有人愿意启动程序20次以获得一
个好的配置。下面的这个脚本就能达到这个目的。

    for {} {1} {} {
        spawn rogue
        expect "*Str:18*"    break    
            "*Str:16*"    
        close
        wait
    }
    interact

  第一行是个for循环,和C语言的控制格式很象。rogue启动后,expect就
检查看力量值是18还是16,如果是16,程序就通过执行close和wait来退出。
这两个命令的作用分别是关闭和伪终端的连接和等待进程退出。rogue读到一
个文件结束符就推出,从而循环继续运行,产生一个新的rogue游戏来检查。

  当一个值为18的配置找到后,控制就推出循环并跳到最后一行脚本。
interact把控制转移给用户以便他们能够玩这个特定的游戏。

  想象一下这个脚本的运行。你所能真正看到的就是20或者30个初始的配置
在不到一秒钟的时间里掠过屏幕,最后留给你的就是一个有着很好配置的游戏
。唯一比这更好的方法就是使用调试工具来玩游戏。

  我们很有必要认识到这样一点:rogue是一个使用光标的图形游戏。
expect程序员必须了解到:光标的运动并不一定以一种直观的方式在屏幕上体
现。幸运的是,在我们这个例子里,这不是一个问题。将来的对expect的改
进可能会包括一个内嵌的能支持字符图形区域的终端模拟器。

8.[ftp]

  我们使用expect写第一个脚本并没有打印出"Hello,World"。实际上,它
实现了一些更有用的功能。它能通过非交互的方式来运行ftp。ftp是用来在支
持TCP/IP的网络上进行文件传输的程序。除了一些简单的功能,一般的实现都
要求用户的参与。

  下面这个脚本从一个主机上使用匿名ftp取下一个文件来。其中,主机名
是第一个参数。文件名是第二个参数。

        spawn    ftp    [lindex $argv 1]
        expect "*Name*"
        send     "anonymous "
        expect "*Password:*"
        send [exec whoami]
        expect "*ok*ftp>;*"
        send "get [lindex $argv 2] "
        expect "*ftp>;*"

  上面这个程序被设计成在后台进行ftp。虽然他们在底层使用和expect类
似的机制,但他们的可编程能力留待改进。因为expect提供了高级语言,你可
以对它进行修改来满足你的特定需求。比如说,你可以加上以下功能:

    :坚持--如果连接或者传输失败,你就可以每分钟或者每小时,甚
        至可以根据其他因素,比如说用户的负载,来进行不定期的
        重试。
    :通知--传输时可以通过mail,write或者其他程序来通知你,甚至
        可以通知失败。
    :初始化-每一个用户都可以有自己的用高级语言编写的初始化文件
        (比如说,.ftprc)。这和C shell对.cshrc的使用很类似。

  expect还可以执行其他的更复杂的任务。比如说,他可以使用McGill大学
的Archie系统。Archie是一个匿名的Telnet服务,它提供对描述Internet上可
通过匿名ftp获取的文件的数据库的访问。通过使用这个服务,脚本可以询问
Archie某个特定的文件的位置,并把它从ftp服务器上取下来。这个功能的实
现只要求在上面那个脚本中加上几行就可以。

  现在还没有什么已知的后台-ftp能够实现上面的几项功能,能不要说所有
的功能了。在expect里面,它的实现却是非常的简单。“坚持”的实现只要求
在expect脚本里面加上一个循环。“通知”的实现只要执行mail和write就可以
了。“初始化文件”的实现可以使用一个命令,source .ftprc,就可以了,
在.ftprc里面可以有任何的expect命令。

  虽然这些特征可以通过在已有的程序里面加上钩子函数就可以,但这也不
能保证每一个人的要求都能得到满足。唯一能够提供保证的方法就是提供一种
通用的语言。一个很好的解决方法就是把Tcl自身融入到ftp和其他的程序中间
去。实际上,这本来就是Tcl的初衷。在还没有这样做之前,expect提供了一
个能实现大部分功能但又不需要任何重写的方案。

9.[fsck]

  fsck是另外一个缺乏足够的用户接口的例子。fsck几乎没有提供什么方法
来预先的回答一些问题。你能做的就是给所有的问题都回答"yes"或者都回答
"no"。

  下面的程序段展示了一个脚本如何的使的自动的对某些问题回答"yes",
而对某些问题回答"no"。下面的这个脚本一开始先派生fsck进程,然后对其
中两种类型的问题回答"yes",而对其他的问题回答"no"。

    for {} {1} {} {
        expect
            eof        break        
            "*UNREF FILE*CLEAR?"    {send "r
"}    
            "*BAD INODE*FIX?"    {send "y "}    
            "*?"            {send "n
"}    
    }

  在下面这个版本里面,两个问题的回答是不同的。而且,如果脚本遇到
了什么它不能理解的东西,就会执行interact命令把控制交给用户。用户的
击键直接交给fsck处理。当执行完后,用户可以通过按"+"键来退出或者把
控制交还给expect。如果控制是交还给脚本了,脚本就会自动的控制进程的
剩余部分的运行。

    for {} {1} {}{
        expect             
            eof        break        
            "*UNREF FILE*CLEAR?"    {send "y
"}    
            "*BAD INODE*FIX?"    {send "y "}    
            "*?"            {interact
+}    
    }

  如果没有expect,fsck只有在牺牲一定功能的情况下才可以非交互式的
运行。fsck几乎是不可编程的,但它却是系统管理的最重要的工具。许多别
的工具的用户接口也一样的不足。实际上,正是其中的一些程序的不足导致
了expect的诞生。

10.[控制多个进程:作业控制]


  expect的作业控制概念精巧的避免了通常的实现困难。其中包括了两个问
题:一个是expect如何处理经典的作业控制,即当你在终端上按下^Z键时
expect如何处理;另外一个就是expect是如何处理多进程的。

  对第一个问题的处理是:忽略它。expect对经典的作业控制一无所知。比
如说,你派生了一个程序并且发送一个^Z给它,它就会停下来(这是伪终端的
完美之处)而expect就会永远的等下去。

  但是,实际上,这根本就不成一个问题。对于一个expect脚本,没有必要
向进程发送^Z。也就是说,没有必要停下一个进程来。expect仅仅是忽略了
一个进程,而把自己的注意力转移到其他的地方。这就是expect的作业控制
思想,这个思想也一直工作的很好。

  从用户的角度来看是象这样的:当一个进程通过spawn命令启动时,变量
spawn_id就被设置成某进程的描述符。由spawn_id描述的进程就被认为是当
前进程。(这个描述符恰恰就是伪终端文件的描述符,虽然用户把它当作一个
不透明的物体)。expect和send命令仅仅和当前进程进行交互。所以,切换一
个作业所需要做的仅仅是把该进程的描述符赋给spawn_id。

  这儿有一个例子向我们展示了如何通过作业控制来使两个chess进程进行
交互。在派生完两个进程之后,一个进程被通知先动一步。在下面的循环里
面,每一步动作都送给另外一个进程。其中,read_move和write_move两个过
程留给读者来实现。(实际上,它们的实现非常的容易,但是,由于太长了所
以没有包含在这里)。

    spawn chess            ;# start player one
    set id1    $spawn_id
    expect "Chess "
    send "first "            ;# force it to go first
    read_move

    spawn chess            ;# start player two
    set id2    $spawn_id
    expect "Chess "
    
    for {} {1} {}{
        send_move
        read_move
        set spawn_id    $id1
        
        send_move
        read_move
        set spawn_id    $id2
    }

   有一些应用程序和chess程序不太一样,在chess程序里,的两个玩家
轮流动。下面这个脚本实现了一个冒充程序。它能够控制一个终端以便用户
能够登录和正常的工作。但是,一旦系统提示输入密码或者输入用户名的时
候,expect就开始把击键记下来,一直到用户按下回车键。这有效的收集了
用户的密码和用户名,还避免了普通的冒充程序的"Incorrect password-try
again"。而且,如果用户连接到另外一个主机上,那些额外的登录也会被
记录下来。

    spawn tip /dev/tty17        ;# open connection to
    set tty $spawn_id        ;# tty to be spoofed

    spawn login
    set login $spawn_id

    log_user 0
    
    for {} {1} {} {
        set ready [select $tty $login]
        
        case $login in $ready {
            set spawn_id $login
            expect         
              {"*password*" "*login*"}{
                  send_user $expect_match
                  set log 1
                 }    
              "*"        ;# ignore everything
else
            set spawn_id    $tty;
            send $expect_match
        }
        case $tty in $ready {
            set spawn_id    $tty
            expect "* *"{
                    if $log {
                      send_user $expect_match
                      set log 0
                    }
                   }    
                "*" {
                    send_user $expect_match
                   }
            set spawn_id     $login;
            send $expect_match
        }
    }
        

   这个脚本是这样工作的。首先连接到一个login进程和终端。缺省的,
所有的对话都记录到标准输出上(通过send_user)。因为我们对此并不感兴趣,
所以,我们通过命令"log_user 0"来禁止这个功能。(有很多的命令来控制
可以看见或者可以记录的东西)。

   在循环里面,select等待终端或者login进程上的动作,并且返回一个
等待输入的spawn_id表。如果在表里面找到了一个值的话,case就执行一个
action。比如说,如果字符串"login"出现在login进程的输出中,提示就会
被记录到标准输出上,并且有一个标志被设置以便通知脚本开始记录用户的
击键,直至用户按下了回车键。无论收到什么,都会回显到终端上,一个相
应的action会在脚本的终端那一部分执行。

   这些例子显示了expect的作业控制方式。通过把自己插入到对话里面,
expect可以在进程之间创建复杂的I/O流。可以创建多扇出,复用扇入的,
动态的数据相关的进程图。

   相比之下,shell使得它自己一次一行的读取一个文件显的很困难。
shell强迫用户按下控制键(比如,^C,^Z)和关键字(比如fg和bg)来实现作业的
切换。这些都无法从脚本里面利用。相似的是:以非交互方式运行的shell并
不处理“历史记录”和其他一些仅仅为交互式使用设计的特征。这也出现了和
前面哪个passwd程序的相似问题。相似的,也无法编写能够回归的测试shell
的某些动作的shell脚本。结果导致shell的这些方面无法进行彻底的测试。

   如果使用expect的话,可以使用它的交互式的作业控制来驱动shell。一
个派生的shell认为它是在交互的运行着,所以会正常的处理作业控制。它不
仅能够解决检验处理作业控制的shell和其他一些程序的问题。还能够在必要
的时候,让shell代替expect来处理作业。可以支持使用shell风格的作业控
制来支持进程的运行。这意味着:首先派生一个shell,然后把命令送给shell
来启动进程。如果进程被挂起,比如说,发送了一个^Z,进程就会停下来,并
把控制返回给shell。对于expect而言,它还在处理同一个进程(原来那个
shell)。

  expect的解决方法不仅具有很大的灵活性,它还避免了重复已经存在于
shell中的作业控制软件。通过使用shell,由于你可以选择你想派生的shell,
所以你可以根据需要获得作业控制权。而且,一旦你需要(比如说检验的时
候),你就可以驱动一个shell来让这个shell以为它正在交互式的运行。这一
点对于在检测到它们是否在交互式的运行之后会改变输出的缓冲的程序来说也
是很重要的。

  为了进一步的控制,在interact执行期间,expect把控制终端(是启动
expect的那个终端,而不是伪终端)设置成生模式以便字符能够正确的传送给
派生的进程。当expect在没有执行interact的时候,终端处于熟模式下,这时
候作业控制就可以作用于expect本身。

11.[交互式的使用expect]

  在前面,我们提到可以通过interact命令来交互式的使用脚本。基本上
来说,interact命令提供了对对话的自由访问,但我们需要一些更精细的控
制。这一点,我们也可以使用expect来达到,因为expect从标准输入中读取
输入和从进程中读取输入一样的简单。 但是,我们要使用expect_user和
send_user来进行标准I/O,同时不改变spawn_id。

  下面的这个脚本在一定的时间内从标准输入里面读取一行。这个脚本叫
做timed_read,可以从csh里面调用,比如说,set answer="timed_read 30"
就能调用它。

    #!/usr/local/bin/expect -f
    set timeout [lindex $argv 1]
    expect_user "* "
    send_user $expect_match

   第三行从用户那里接收任何以新行符结束的任何一行。最后一行把它
返回给标准输出。如果在特定的时间内没有得到任何键入,则返回也为空。

   第一行支持"#!"的系统直接的启动脚本。(如果把脚本的属性加上可执
行属性则不要在脚本前面加上expect)。当然了脚本总是可以显式的用
"expect scripot"来启动。在-c后面的选项在任何脚本语句执行前就被执行。
比如说,不要修改脚本本身,仅仅在命令行上加上-c "trace...",该脚本可
以加上trace功能了(省略号表示trace的选项)。

   在命令行里实际上可以加上多个命令,只要中间以";"分开就可以了。
比如说,下面这个命令行:

    expect -c "set timeout 20;spawn foo;expect"

   一旦你把超时时限设置好而且程序启动之后,expect就开始等待文件
结束符或者20秒的超时时限。 如果遇到了文件结束符(EOF),该程序就会停
下来,然后expect返回。如果是遇到了超时的情况,expect就返回。在这两
中情况里面,都隐式的杀死了当前进程。

   如果我们不使用expect而来实现以上两个例子的功能的话,我们还是可
以学习到很多的东西的。在这两中情况里面,通常的解决方案都是fork另一个
睡眠的子进程并且用signal通知原来的shell。如果这个过程或者读先发生的
话,shell就会杀司那个睡眠的进程。 传递pid和防止后台进程产生启动信息
是一个让除了高手级shell程序员之外的人头痛的事情。提供一个通用的方法
来象这样启动多个进程会使shell脚本非常的复杂。 所以几乎可以肯定的是,
程序员一般都用一个专门C程序来解决这样一个问题。

   expect_user,send_user,send_error(向标准错误终端输出)在比较长
的,用来把从进程来的复杂交互翻译成简单交互的expect脚本里面使用的比较
频繁。在参考[7]里面,Libs描述怎样用脚本来安全的包裹(wrap)adb,怎样
把系统管理员从需要掌握adb的细节里面解脱出来,同时大大的降低了由于错
误的击键而导致的系统崩溃。

   一个简单的例子能够让ftp自动的从一个私人的帐号里面取文件。在这
种情况里,要求提供密码。 即使文件的访问是受限的,你也应该避免把密码
以明文的方式存储在文件里面。把密码作为脚本运行时的参数也是不合适的,
因为用ps命令能看到它们。有一个解决的方法就是在脚本运行的开始调用
expect_user来让用户输入以后可能使用的密码。这个密码必须只能让这个脚
本知道,即使你是每个小时都要重试ftp。

   即使信息是立即输入进去的,这个技巧也是非常有用。比如说,你可
以写一个脚本,把你每一个主机上不同的帐号上的密码都改掉,不管他们使用
的是不是同一个密码数据库。如果你要手工达到这样一个功能的话,你必须
Telnet到每一个主机上,并且手工输入新的密码。而使用expect,你可以只输
入密码一次而让脚本来做其它的事情。

   expect_user和interact也可以在一个脚本里面混合的使用。考虑一下
在调试一个程序的循环时,经过好多步之后才失败的情况。一个expect脚本
可以驱动哪个调试器,设置好断点,执行该程序循环的若干步,然后将控制
返回给键盘。它也可以在返回控制之前,在循环体和条件测试之间来回的切
换。
文件ftp-down


CODE:[Copy to clipboard]#!/usr/bin/expect -f
set ipaddress [lindex $argv 0]
set username [lindex $argv 1]
set password [lindex $argv 2]

spawn ftp $ipaddress
expect "*Name*"
send "$username "
expect "*Password:*"
send "$password "
expect "*

 

相关文章推荐

[shell] expect完整介绍

expect是建立在tcl基础上的一个工具,它用来让一些需要交互的任务自动化地完成。我们首先从一个简单的例子开始,如同在这一节一开始就提到的,我们想设置一个自动的文件下载程序。       我...

expect_tcl_shell

  • 2014年03月14日 00:54
  • 9.29MB
  • 下载

shell expect

  • 2011年05月13日 11:38
  • 4KB
  • 下载

linux 下使用expect编写shell 脚本交互访问远程服务器

linux 下使用expect编写shell 脚本交互访问远程服务器 使用命令行登陆远程服务器一般需要ip地址以及登陆密码等,每次都手动输很不方便,expect可以满足自动输入密码。 首先安装expe...

SHELL-expect、正则表达式和sed的使用

本节所讲内容: •      实战:expect实现无交互登录 •      正则表达式 •      sed •      awk  •      awk高级应用 •      cut   exp...

shell expect使用方法

Expect的作者Don Libes在1990年开始编写Expect时对Expect做有如下定义:Expect是一个用来实现自动交互功能的软件套件(Expect [is a] software sui...

Shell 和 Expect 脚本的自动登录运行

Shell 和 Expect 脚本的自动登录运行 先转2篇文章 http://www.ibm.com/developerworks/cn/linux/l-cn-firmupgr...

shell结合expect写的批量scp脚本工具

转载链接:http://www.jb51.net/article/34005.htm expect用于自动化地执行linux环境下的命令行交互任务,例如scp、ssh之类需要用户手动输入密码然后确...

shell-expect使用笔记

需要ssh上多台主机进行相同操作,重复劳作是枯燥的,所以写个shell脚本实现。用到了expect。      网上有不少expect的教程,都大同小异,没有说得很详细的。其实expect用的是tcl...

sulogsaver with shell and expect

1. comand: #!/bin/bash logsaver tat07 1 applycommit-test-abc R2618.01.22 2. main script: #!/bin/bas...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:shell expect 的介绍
举报原因:
原因补充:

(最多只允许输入30个字)