Esperar é um programa que fala com outros programas interativos de acordo com um script. Seguindo o script, o Expect sabe o que pode ser esperado de um programa e qual deve ser a resposta correta. Uma linguagem interpretada fornece estruturas de controle de ramificação e alto nível para direcionar o diálogo. Além disso, o usuário pode assumir o controle e interagir diretamente quando desejado, retornando depois o controle ao script.
Expectk é uma mistura de Expect e Tk. Ele se comporta exatamente como o desejo de Expect e Tk. Expect também pode ser usado diretamente em C ou C ++ sem Tcl.
O nome "Esperar" vem da idéia de seqüências de envio / espera popularizadas por uucp, kermit e outros programas de controle de modem. No entanto, ao contrário do uucp, o Expect é generalizado para poder ser executado como um comando no nível do usuário, com qualquer programa e tarefa em mente. A expectativa pode conversar com vários programas ao mesmo tempo.
O que esperar pode fazer
Por exemplo, aqui estão algumas coisas que o comando expect pode fazer:
- Faça com que seu computador disque de volta para que você possa efetuar login sem pagar pela chamada.
- Inicie um jogo e, se a configuração ideal não aparecer, reinicie-o novamente e novamente) até que isso aconteça e, em seguida, entregue o controle a você.
- Execute fsck, e em resposta às suas perguntas, responda "sim" ou "não" ou devolva o controle para você, com base em critérios predeterminados.
- Conecte-se a outra rede e recupere automaticamente seus e-mails para que apareçam como se tivessem sido originalmente enviados para o sistema local.
- Carregar variáveis de ambiente, diretório atual ou qualquer tipo de informação em rlogin, telnet, tip, su ou chgrp
Há vários motivos pelos quais o shell não pode executar essas tarefas. Todos são possíveis com o Expect.
Em geral, o Expect é útil para executar qualquer programa que exija interação entre o programa e o usuário. Tudo o que é necessário é que a interação possa ser caracterizada programaticamente. A expectativa também pode devolver o controle ao usuário sem interromper o controle do programa. Da mesma forma, o usuário pode retornar o controle ao script a qualquer momento.
Uso
Espere lê cmdfile para uma lista de comandos para executar. Esperar pode ser invocado implicitamente em sistemas que suportam o #! notação marcando o script como executável e fazendo a primeira linha no script:
#! / usr / local / bin / expect -f
Naturalmente, o caminho deve descrever com precisão onde esperar vidas. / usr / local / bin é apenas um exemplo.
O sinalizador -c prefacia um comando a ser executado antes de qualquer no script. O comando deve ser citado para evitar ser quebrado pelo shell. Esta opção pode ser usada várias vezes. Vários comandos podem ser executados com um único -c, separando-os com ponto e vírgula. Comandos são executados na ordem em que aparecem. Ao usar o Expectk, esta opção é especificada como -command.
O sinalizador -d ativa algumas saídas de diagnóstico, que relatam principalmente a atividade interna de comandos, como esperar e interagir. Esse sinalizador tem o mesmo efeito que "exp_internal 1" no início de um script Expect, além da versão de Expect ser impressa.
O sinalizador -D permite um depurador interativo. Um valor inteiro deve seguir. O depurador assumirá o controle antes do próximo procedimento de Tcl se o valor for diferente de zero ou se um ^ C for pressionado ou um ponto de interrupção for atingido ou outro comando de depurador apropriado aparecer no script. Ao usar o Expectk, esta opção é especificada como -Depurar.
O sinalizador -f prefacia um arquivo do qual ler comandos. A bandeira em si é opcional, pois só é útil quando se usa o #! notação, para que outros argumentos possam ser fornecidos na linha de comando. Ao usar o Expectk, essa opção é especificada como -file.
Por padrão, o arquivo de comando é lido na memória e executado em sua totalidade. É ocasionalmente desejável ler arquivos uma linha por vez. Para forçar arquivos arbitrários a serem manipulados dessa maneira, use o sinalizador -b. Ao usar o Expectk, esta opção é especificada como buffer.
Se a string "-" for fornecida como um nome de arquivo, a entrada padrão será lida. Use "./-" para ler um arquivo realmente chamado "-".
O sinalizador -i faz com que Expect interativamente solicite comandos em vez de lê-los de um arquivo. A solicitação é finalizada pelo comando de saída ou pelo EOF. O sinalizador -i é assumido se não for usado nem um arquivo de comando nem um -c. Ao usar o Expectk, esta opção é especificada como -interativa.
- pode ser usado para delimitar o final das opções. Isso é útil se você deseja passar um argumento de opção ao seu script sem que ele seja interpretado por Expect. Isso pode ser colocado de maneira útil no #! linha para evitar qualquer interpretação em forma de bandeira por Expect. Por exemplo, o seguinte deixará os argumentos originais, incluindo o nome do script na variável argv .
#! / usr / local / bin / expect -
Observe que as convenções getopt (3) e execve (2) usuais devem ser observadas ao adicionar argumentos ao #! linha.
O arquivo $ exp_library / expect.rc é originado automaticamente se presente, a menos que o sinalizador -N seja usado. (Ao usar o Expectk, essa opção é especificada como -NORC.) Imediatamente após isso, o arquivo ~ / .expect.rc é originado automaticamente, a menos que o sinalizador -n seja usado. Se a variável de ambiente DOTDIR for definida, ela será tratada como um diretório e .expect.rc será lida a partir daí. Ao usar o Expectk, esta opção é especificada como -norc.Essa fonte ocorre somente após a execução de qualquer sinalizador -c.
-v causa Expect a imprimir seu número de versão e sair. O sinalizador correspondente no Expectk, que usa nomes longos de sinalizadores, é -version.
Args opcionais são construídos em uma lista e armazenados na variável chamada argv e. argc é inicializado com o comprimento de argv.
Argv0 é definido como o nome do script ou binário se nenhum script for usado. Por exemplo, o seguinte imprime o nome do script e os três primeiros argumentos:
send_user "$ argv0 lrange $ argv 0 2 n"
Comandos
Espere usa a linguagem de comando da ferramenta. O Tcl fornece fluxo de controle (if, for, break), avaliação de expressão e vários outros recursos, como recursão e definição de procedimento. Comandos usados aqui, mas não definidos (set, if, exec) são comandos Tcl. Espera suporta comandos adicionais. A menos que especificado de outra forma, os comandos retornam a string vazia.
Os comandos são listados alfabeticamente para que possam ser localizados rapidamente. No entanto, os novos usuários podem achar mais fácil começar lendo as descrições de spawn, enviar, esperar e interagir, nessa ordem.
close -slave -onexec 0 | 1 -i spawn_id
fecha a conexão com o processo atual. A maioria dos programas interativos detectará EOF em seus stdin e exit; portanto perto geralmente é suficiente para matar o processo também. O sinalizador -i declara o processo para fechar correspondendo ao spawn_id nomeado.
Ambos esperam e interagem irão detectar quando o processo atual termina e fecham implicitamente, mas se você matar o processo, digamos, "exec kill $ pid", você precisa explicitamente chamar close.
O sinalizador -onexec determina se o id do spawn é fechado em qualquer novo processo gerado ou se o processo é sobreposto. Para deixar um id de desova aberto, use o valor 0. Um valor inteiro diferente de zero força o spawn fechado em qualquer novo processo.
O sinalizador -slave fecha o escravo associado ao id de desova. Quando a conexão é fechada, o escravo também é automaticamente fechado se ainda estiver aberto.
Não importa se a conexão está fechada de forma implícita ou explícita, você deve chamar wait para limpar o slot do processo do kernel correspondente. O comando fechar não chama esperar, pois não há garantia de que fechar uma conexão de processo fará com que ela saia.
debug -now 0 | 1
controla um depurador Tcl, permitindo-lhe percorrer instruções e definir pontos de interrupção.
Sem argumentos, um 1 será retornado se o depurador não estiver em execução, caso contrário, será retornado um 0.
Com um argumento 1, o depurador é iniciado. Com um argumento 0, o depurador é interrompido. Se um argumento 1 for precedido pelo sinalizador -now, o depurador será iniciado imediatamente. Caso contrário, o depurador é iniciado com a próxima instrução Tcl.
O comando debug não altera nenhum traps. Compare isso com o início Espere com o sinalizador -D.
O comando de desconexão desconecta um processo bifurcado do terminal. Continua rodando em segundo plano. O processo recebe seu próprio grupo de processos. AE / S padrão é redirecionada para / dev / null.
O fragmento a seguir usa a desconexão para continuar executando o script em segundo plano.
se {fork! = 0} sair da desconexão. . .
O script a seguir lê uma senha e, em seguida, executa um programa a cada hora que exige uma senha toda vez que é executada. O script fornece a senha para que você tenha que digitá-la apenas uma vez.
send_user "password? " expect_user -re "(. *) n" para {} 1 {} {if {fork! = 0} {sleep 3600; continue} desconexão spawn priv_prog expect Password: enviar "$ expect_out ( 1, string) r ". . . Saída }
Uma vantagem de usar a desconexão sobre o recurso de processo assíncrono do shell (&) é que o Expect pode salvar os parâmetros do terminal antes da desconexão e depois aplicá-los a novos ptys. Com o &, o Expect não tem a chance de ler os parâmetros do terminal, já que o terminal já está desconectado no momento em que o Expect recebe controle.
exit -opts status
faz com que Expect a sair ou se prepare para fazer isso.
o -onexite flag faz com que o próximo argumento seja usado como um manipulador de saída. Sem um argumento, o manipulador de saída atual é retornado.
o -Sem saída causas da bandeira Espero para se preparar para sair, mas parar de retornar o controle real para o sistema operacional. O manipulador de saída definido pelo usuário é executado, assim como os manipuladores internos próprios do Expect. Nenhum outro comando Expect deve ser executado. Isso é útil se você estiver executando Expect with other Tcl extensions. O intérprete atual (e a janela principal se estiver no ambiente Tk) permanecem para que outras extensões Tcl possam ser limpas. Se esperar Saída é chamado novamente (no entanto, isso pode ocorrer), os manipuladores não são executados novamente.
Ao sair, todas as conexões para processos gerados são fechadas. O fechamento será detectado como um EOF por processos gerados. Saída não toma nenhuma outra ação além do que o procedimento normal _exit (2) faz. Assim, os processos gerados que não verificam o EOF podem continuar sendo executados. (Diversas condições são importantes para determinar, por exemplo, o que sinaliza que um processo gerado será enviado, mas elas dependem do sistema, normalmente documentadas na saída (3).) Processos gerados que continuam a ser executados serão herdados pelo init.
status (ou 0 se não especificado) é retornado como o status de saída Espero . Saída é implicitamente executado se o final do script for atingido.
exp_continue -continue_timer
O comando exp_continue permite Espero para continuar executando em vez de retornar como normalmente faria. Por padrão exp_continue redefine o temporizador de tempo limite. o -continue_timer flag impede que o timer seja reiniciado. (Vejo Espero Para maiores informações.)
valor exp_internal -f file
faz com que comandos adicionais enviem informações de diagnóstico internas para Espero para stderr se valor é diferente de zero. Esta saída está desativada se valor é 0. As informações de diagnóstico incluem todos os caracteres recebidos e todas as tentativas feitas para corresponder a saída atual aos padrões.
Se o opcional Arquivo é fornecido, todas as saídas normais e de depuração são gravadas nesse arquivo (independentemente do valor de valor ). Qualquer arquivo de saída de diagnóstico anterior é fechado.
o -info flag faz com que exp_internal retorne uma descrição dos argumentos de informação não mais recentes fornecidos.
exp_open args -i spawn_id
retorna um identificador de arquivo Tcl que corresponde ao ID de desova original. O identificador de arquivo pode então ser usado como se fosse aberto pela Tcl's abrir comando. (O id do spawn não deve mais ser usado. esperar não deve ser executado.
o -deixe aberto O sinalizador deixa o id do spawn aberto para acesso através dos comandos Expect. UMA esperar deve ser executado no id do spawn.
exp_pid -i spawn_id
retorna o ID do processo correspondente ao processo atualmente gerado. Se o -Eu flag é usado, o pid retornado corresponde ao do id de desova fornecido.
exp_send
é um alias para mandar .
exp_send_error
é um alias para send_error .
exp_send_log
é um alias para send_log .
exp_send_tty
é um alias para send_tty .
exp_send_user
é um alias para send_user .
exp_version -exit versão
é útil para garantir que o script seja compatível com a versão atual do Expect.
Sem argumentos, a versão atual do Espero é retornado. Esta versão pode então ser codificada em seu script. Se você realmente souber que não está usando recursos de versões recentes, poderá especificar uma versão anterior.
As versões consistem em três números separados por pontos. Primeiro é o maior número. Scripts escritos para versões do Espero com um número maior diferente, quase certamente não funcionará. exp_version retorna um erro se os números principais não corresponderem.
Em segundo lugar é o menor número. Scripts escritos para uma versão com um número menor maior que a versão atual podem depender de algum novo recurso e podem não ser executados. exp_version retorna um erro se os números principais coincidirem, mas o número menor do script for maior que o do número em execução Espero .
O terceiro é um número que não faz parte da comparação de versões. No entanto, é incrementado quando o Espero a distribuição de software é alterada de alguma forma, como por documentação adicional ou otimização. É redefinido para 0 em cada nova versão secundária.
Com o -Saída bandeira, Espero imprime um erro e sai se a versão estiver desatualizada.
esperar -opts pat1 body1 … -opts patn bodyn
aguarda até que um dos padrões corresponda à saída de um processo gerado, que um período de tempo especificado tenha passado ou que um fim de arquivo seja visto. Se o corpo final estiver vazio, pode ser omitido.
Padrões dos mais recentes expect_before comando são implicitamente usados antes de quaisquer outros padrões. Padrões dos mais recentes expect_after comando são implicitamente usados depois de quaisquer outros padrões.
Se os argumentos para o todo Espero declaração exigir mais de uma linha, todos os argumentos podem ser "braced" em um, de modo a evitar terminar cada linha com uma barra invertida. Neste caso, as substituições usuais de Tcl ocorrerão apesar das chaves.
Se um padrão é a palavra-chave eof , o corpo correspondente é executado no final do arquivo. Se um padrão é a palavra-chave tempo esgotado , o corpo correspondente é executado no tempo limite. Se nenhuma palavra-chave timeout for usada, uma ação nula implícita será executada no tempo limite. O período de tempo limite padrão é de 10 segundos, mas pode ser definido, por exemplo, para 30, pelo comando "set timeout 30". Um tempo limite infinito pode ser designado pelo valor -1. Se um padrão é a palavra-chave padrão , o corpo correspondente é executado no tempo limite ou no final do arquivo.
Se um padrão corresponder, o corpo correspondente será executado. Espero retorna o resultado do corpo (ou a string vazia se nenhum padrão for correspondido). No caso de vários padrões coincidirem, o que aparece primeiro é usado para selecionar um corpo.
Cada vez que novas saídas chegam, elas são comparadas a cada padrão na ordem em que estão listadas. Assim, você pode testar a ausência de uma correspondência fazendo com que o último padrão tenha algo garantido, como um prompt. Em situações em que não há prompt, você deve usar tempo esgotado (assim como você faria se estivesse interagindo manualmente).
Os padrões são especificados de três maneiras. Por padrão, os padrões são especificados com os do Tcl jogo de cordas comando. (Esses padrões também são semelhantes às expressões regulares do C-shell, geralmente chamadas de padrões "glob"). o -gl bandeira pode ser usada para proteger padrões que poderiam Espero bandeiras de fazer isso. Qualquer padrão começando com um "-" deve ser protegido dessa maneira. (Todas as strings começando com "-" são reservadas para opções futuras).
Por exemplo, o fragmento a seguir procura um login bem-sucedido. (Observe que abortar Presume-se que seja um procedimento definido em outro lugar no script.)
esperar {ocupado {coloca ocupado n; exp_continue} falhou anular "senha inválida" anular o tempo limite abortar conectado}
As cotações são necessárias no quarto padrão, uma vez que contém um espaço que, de outro modo, separaria o padrão da ação.Padrões com a mesma ação (como a terceira e a quarta) exigem a listagem das ações novamente. Isso pode ser evitado usando padrões no estilo regexp (veja abaixo). Mais informações sobre como formar padrões no estilo glob podem ser encontradas no manual do Tcl.
Padrões estilo Regexp seguem a sintaxe definida pela Tcl's regexp (abreviação de "expressão regular") comando. padrões de regexp são introduzidos com a bandeira -ré . O exemplo anterior pode ser reescrito usando um regexp como:
esperar {ocupado {coloca ocupado n; exp_continue} -re "falha | senha inválida" abort timeout abort connected}
Ambos os tipos de padrões são "não ancorados". Isso significa que os padrões não precisam corresponder à string inteira, mas podem começar e terminar a correspondência em qualquer lugar da string (contanto que tudo o mais corresponda). Use ^ para corresponder ao início de uma string e $ para corresponder ao final. Observe que, se você não esperar pelo final de uma string, suas respostas poderão ser facilmente finalizadas no meio da string, à medida que forem ecoadas no processo gerado. Embora ainda produza resultados corretos, a saída pode parecer pouco natural. Assim, o uso de $ é encorajado se você puder descrever exatamente os caracteres no final de uma string.
Note que em muitos editores, o ^ e $ combinam o começo e o fim das linhas respectivamente. No entanto, como esperar não é orientado por linha, esses caracteres correspondem ao início e ao final dos dados (em oposição a linhas) atualmente no buffer correspondente esperado. (Além disso, veja a nota abaixo em "indigestão do sistema".)
o -ex flag faz com que o padrão seja correspondido como uma string "exata". Nenhuma interpretação de *, ^, etc. é feita (embora as convenções usuais de Tcl ainda devam ser observadas). Padrões exatos são sempre desatualizados.
o -nenhum caso flag faz com que caracteres maiúsculos da saída sejam comparados como se fossem caracteres minúsculos. O padrão não é afetado.
Ao ler a saída, mais de 2000 bytes podem forçar os bytes anteriores a serem "esquecidos". Isso pode ser alterado com a função match_max . (Observe que valores excessivamente grandes podem retardar o correspondente de padrões). lista de participantes é full_buffer , o corpo correspondente é executado se match_max bytes foram recebidos e nenhum outro padrão foi correspondido. Seja ou não o full_buffer palavra-chave é usada, os caracteres esquecidos são gravados em expect_out (buffer).
E se lista de participantes é a palavra-chave nulo e nulos são permitidos (via remove_nulls comando), o corpo correspondente é executado se um único ASCII 0 for correspondido. Não é possível corresponder 0 bytes por padrões glob ou regexp.
Ao corresponder um padrão (ou eof ou full_buffer), qualquer resultado correspondente e previamente não correspondido é salvo na variável expect_out (buffer) . Até 9 correspondências de substring regexp são salvas nas variáveis expect_out (1, string) através expect_out (9, string) . Se o -indices flag é usado antes de um padrão, os índices inicial e final (em uma forma adequada para largar ) das 10 strings são armazenadas nas variáveis expect_out (X, iniciar) e expect_out (X, final) onde X é um dígito, corresponde à posição de substring no buffer. 0 refere-se a cadeias de caracteres que correspondem a todo o padrão e é gerado para padrões de glob, bem como padrões de expressão regular. Por exemplo, se um processo produziu saída de "abcdefgh n", o resultado de:
espere "cd"
é como se as seguintes declarações tivessem sido executadas:
set expect_out (0, string) conjunto de cd expect_out (buffer) abcd
e "efgh n" é deixado no buffer de saída. Se um processo produziu a saída "abbbcabkkkka n", o resultado de:
esperar -indices -re "b (b *). * (k +)"
é como se as seguintes declarações tivessem sido executadas:
set expect_out (0, start) 1 conjunto expect_out (0, end) 10 conjunto expect_out (0, string) bbbcabkkkk conjunto expect_out (1, start) 2 conjunto expect_out (1, end) 3 conjunto expect_out (1, string) bb set expect_out (2, start) 10 set expect_out (2, final) 10 set expect_out (2, string) k conjunto expect_out (buffer) abbbcabkkkk
e "a n" é deixado no buffer de saída. O padrão "*" (e -re ". *") Irá liberar o buffer de saída sem ler mais nenhuma saída do processo.
Normalmente, a saída correspondente é descartada dos buffers internos do Expect. Isso pode ser evitado pré-fixando um padrão com o - não transferir bandeira. Este sinalizador é especialmente útil na experimentação (e pode ser abreviado para "-não" por conveniência durante a experimentação).
O id de semente associado à saída correspondente (ou eof ou full_buffer) é armazenado em expect_out (spawn_id) .
o -tempo esgotado flag faz com que o comando expect atual use o seguinte valor como um tempo limite em vez de usar o valor da variável de tempo limite.
Por padrão, os padrões são comparados com a saída do processo atual, no entanto, -Eu flag declara que a saída da lista spawn_id nomeada deve ser comparada com os seguintes padrões (até o próximo -Eu ). A lista spawn_id deve ser uma lista de spawn_ids ou uma variável referente a essa lista de spawn_ids.
Por exemplo, o exemplo a seguir espera por "conectado" do processo atual, ou "ocupado", "falhou" ou "senha inválida" do spawn_id nomeado por $ proc2.
esperar {-i $ proc2 ocupado {coloca ocupado n; exp_continue} -re "falha | senha inválida" abort timeout abort connected}
O valor da variável global any_spawn_id pode ser usado para corresponder padrões a qualquer spawn_ids que seja nomeado com todos os outros -Eu bandeiras na corrente Espero comando. O spawn_id de um -Eu bandeira sem padrão associado (ou seja, seguido imediatamente por outro -Eu ) é disponibilizado para quaisquer outros padrões no mesmo Espero comando associado com any_spawn_id.
o -Eu flag também pode nomear uma variável global, caso em que a variável é lida para uma lista de IDs de spawn. A variável é reler sempre que muda. Isso fornece uma maneira de alterar a fonte de E / S enquanto o comando está em execução. Ids de spawn fornecidos dessa maneira são chamados ids de spawn "indiretos".
Ações como pausa e continuar causar estruturas de controle (ou seja, para , proc ) comportar-se da maneira habitual. O comando exp_continue permite Espero para continuar executando em vez de retornar como normalmente faria.
Isso é útil para evitar loops explícitos ou declarações de expectativa repetidas. O exemplo a seguir faz parte de um fragmento para automatizar o rlogin. o exp_continue evita ter que escrever um segundo Espero declaração (para procurar o prompt novamente) se o rlogin solicitar uma senha.
expect {Senha: {stty -echo send_user "password (para $ user) em $ host:" expect_user -re "(. *) n" send_user " n" envia "$ expect_out (1, string) r" stty echo exp_continue} incorreta {send_user "senha inválida ou conta n" exit} tempo limite {send_user "conexão com $ host expirou n" exit} eof {send_user "conexão com o host falhou: $ expect_out (buffer)" exit} - re $ prompt}
Por exemplo, o fragmento a seguir pode ajudar um usuário a guiar uma interação que já esteja totalmente automatizada. Neste caso, o terminal é colocado no modo raw. Se o usuário pressionar "+", uma variável será incrementada. Se "p" é pressionado, vários retornos são enviados para o processo, talvez para interferir de alguma forma, e "i" permite que o usuário interaja com o processo, efetivamente roubando o controle do script. Em cada caso, o exp_continue permite a corrente Espero para continuar a correspondência de padrões depois de executar a ação atual.
stty raw -echo expect_after {-i $ user_spawn_id "p" {enviar " r r r"; exp_continue} "+" {incr foo; exp_continue} "i" {interagem; exp_continue} "sair" sair}
Por padrão, exp_continue redefine o temporizador de tempo limite. O temporizador não é reiniciado, se exp_continue é chamado com o -continue_timer bandeira.
expect_after expect_args
funciona de forma idêntica ao expect_before exceto que se padrões de ambos Espero e expect_after pode combinar, o Espero padrão é usado. Veja o expect_before comando para mais informações.
expect_background expect_args
leva os mesmos argumentos queEspero , no entanto, retorna imediatamente. Padrões são testados sempre que novas entradas chegam. O padrãotempo esgotado epadrão são sem sentido paraexpect_background e são descartados silenciosamente. Caso contrário, oexpect_background o comando usaexpect_before eexpect_after padrões apenas comoEspero faz.
Quandoexpect_background as ações estão sendo avaliadas, o processamento em segundo plano para o mesmo ID de geração é bloqueado. O processamento em segundo plano é desbloqueado quando a ação é concluída. Enquanto o processamento em segundo plano é bloqueado, é possível fazer um (primeiro plano)Espero no mesmo ID de desova.
Não é possível executar umaEspero enquanto umexpect_background está desbloqueado.expect_background para um id de desova específico é excluído, declarando um novo expect_background com o mesmo ID de desova. Declarandoexpect_background sem padrão remove o id de desova fornecido da capacidade de corresponder padrões no plano de fundo.
expect_before expect_args
leva os mesmos argumentos queEspero , no entanto, retorna imediatamente. Pares de ação padrão dos mais recentesexpect_before com o mesmo id spawn são implicitamente adicionados a qualquer seguinteEspero comandos. Se um padrão corresponder, ele será tratado como se tivesse sido especificado noEspero comando em si, e o corpo associado é executado no contexto doEspero comando. Se padrões de ambosexpect_before eEspero pode combinar, oexpect_before padrão é usado.
Se nenhum padrão for especificado, o ID de geração não será verificado para nenhum padrão.
A menos que substituído por um-Eu bandeira,expect_before padrões de jogo contra o id spawn definido no momento em que oexpect_before comando foi executado (não quando seu padrão é correspondido).
A bandeira de informação causaexpect_before para retornar as especificações atuais de quais padrões serão correspondentes. Por padrão, ele informa sobre o id de desova atual. Uma especificação de ID de geração opcional pode ser fornecida para informações sobre esse id de desova. Por exemplo
expect_before -info -i $ proc
No máximo, uma especificação de id do spawn pode ser fornecida. O sinalizador -indirect suprime os IDs de spawn diretos que vêm somente de especificações indiretas.
Em vez de uma especificação de id de spawn, o sinalizador "-all" fará com que "-info" relate todos os ids de spawn.
A saída do sinalizador -info pode ser reutilizada como o argumento para expect_before.
expect_tty expect_args
é comoEspero mas ele lê caracteres de / dev / tty (ou seja, pressionamentos de tecla do usuário). Por padrão, a leitura é executada no modo cozido. Assim, as linhas devem terminar com um retorno para queEspero vê-los. Isso pode ser alterado viastty (Veja ostty comando abaixo).
expect_user expect_args
é comoEspero mas ele lê caracteres de stdin (ou seja, pressionamentos de tecla do usuário). Por padrão, a leitura é executada no modo cozido. Assim, as linhas devem terminar com um retorno para queEspero vê-los.Isso pode ser alterado viastty (Veja ostty comando abaixo).
garfo
cria um novo processo. O novo processo é uma cópia exata do atualEspero processo. No sucesso,garfo retorna 0 para o novo processo (filho) e retorna o ID do processo filho para o processo pai. Em caso de falha (invariavelmente devido à falta de recursos, por exemplo, espaço de troca, memória),garfo retorna -1 para o processo pai e nenhum processo filho é criado.
Processos bifurcados saem pelaSaída comando, assim como o processo original. Processos bifurcados têm permissão para gravar nos arquivos de log. Se você não desativar a depuração ou o login na maioria dos processos, o resultado poderá ser confuso.
Algumas implementações podem ser confundidas por múltiplos leitores e escritores, mesmo que momentaneamente. Assim, é mais segurogarfo antes de processos de desova.
interaja string1 corpo1 … stringn bodyn
fornece o controle do processo atual ao usuário, de modo que os pressionamentos de tecla sejam enviados ao processo atual e o stdout e stderr do processo atual sejam retornados.
Pares de corpo de string podem ser especificados como argumentos, caso em que o corpo é executado quando a string correspondente é inserida. (Por padrão, a string não é enviada para o processo atual).intérprete comando é assumido, se o corpo final estiver faltando.
Se os argumentos para o todointeragir declaração exigir mais de uma linha, todos os argumentos podem ser "braced" em um, de modo a evitar terminar cada linha com uma barra invertida. Neste caso, as substituições usuais de Tcl ocorrerão apesar das chaves.
Por exemplo, o comando a seguir executa a interação com os seguintes pares de corpo de string definidos: Quando ^ Z é pressionado,Espero está suspenso. (O-restabelecer flag restaura os modos de terminal.) Quando ^ A é pressionado, o usuário vê "você digitou um controle-A" e o processo é enviado a ^ A. Quando $ é pressionado, o usuário vê a data. Quando ^ C é pressionado,Espero sai. Se "foo" for inserido, o usuário verá "bar". Quando ~~ é pressionado, oEspero O interpretador é executado interativamente.
setar CTRLZ 032 interativa {-reset $ CTRLZ {exec kill -STOP pid} 001 {send_user "você digitou um controle-A n"; envie " 001"} $ {send_user "A data é formato do relógio segundos do relógio."} 003 exit foo {send_user "bar"} ~~}
Nos pares de corpo de string, as strings são correspondidas na ordem em que são listadas como argumentos. Cadeias de caracteres que correspondem parcialmente não são enviadas para o processo atual em antecipação do restante. Se forem inseridos caracteres de tal forma que não seja mais possível corresponder, somente a parte da string será enviada para o processo que possivelmente não poderá iniciar outra correspondência. Assim, as sequências que são substrings de correspondências parciais podem corresponder mais tarde, se as sequências originais que estavam tentando ser correspondências falharem no final.
Por padrão, a correspondência de sequências é exata, sem nenhum curinga. (Em contraste, oEspero comando usa padrões estilo glob por padrão.)-ex bandeira pode ser usada para proteger padrões que poderiaminteragir bandeiras de fazer isso. Qualquer padrão começando com um "-" deve ser protegido dessa maneira. (Todas as strings começando com "-" são reservadas para opções futuras).
o-ré flag força a string a ser interpretada como um padrão no estilo regexp. Nesse caso, as substrings correspondentes são armazenadas na variável interact_out de forma semelhante ao caminhoEspero armazena sua saída na variávelexpect_out . o-indices flag é igualmente suportado.
O padrãoeof introduz uma ação que é executada no final do arquivo. Uma separaçãoeof padrão também pode seguir o-saída flag, caso em que é correspondido se um eof for detectado durante a gravação da saída. O padrãoeof a ação é "retorno", de modo queinteragir simplesmente retorna em cima de qualquer EOF.
O padrãotempo esgotado introduz um tempo limite (em segundos) e uma ação que é executada após nenhum caractere ter sido lido em um determinado momento. otempo esgotado padrão se aplica ao processo especificado mais recentemente. Não há tempo limite padrão. A variável especial "timeout" (usada peloEspero comando) não tem efeito sobre este tempo limite.
Por exemplo, a seguinte declaração poderia ser usada para autologar usuários que não digitaram nada por uma hora, mas que ainda recebem mensagens frequentes do sistema:
interativa -input $ user_spawn_id timeout 3600 return -output $ spawn_id
Se o padrão é a palavra-chavenulo e nulos são permitidos (viaremove_nulls comando), o corpo correspondente é executado se um único ASCII 0 for correspondido. Não é possível corresponder 0 bytes por padrões glob ou regexp.
Prefacing um padrão com a bandeira-Eu escrevo faz com que a variável interact_out (spawn_id) para ser definido como o spawn_id que corresponde ao padrão (ou eof).
Ações comopausa econtinuar causar estruturas de controle (ou seja,para , proc ) comportar-se da maneira habitual. ContudoRetorna faz com que interaja para retornar ao seu chamador, enquantointer_return causasinteragir para causar um retorno em seu chamador. Por exemplo, se "proc foo" chamadointeragir que então executou a açãointer_return , proc foo retornaria. (Isso significa que seinteragir chamadasintérprete digitando interativamenteRetorna fará com que a interação continue, enquantointer_return fará com que a interação retorne ao seu chamador.)
Duranteinteragir , o modo raw é usado para que todos os caracteres possam ser passados para o processo atual.Se o processo atual não capturar sinais de controle de trabalho, ele será interrompido se for enviado um sinal de parada (por padrão ^ Z). Para reiniciá-lo, envie um sinal de continuação (por exemplo, "kill -CONT"). Se você realmente quiser enviar um SIGSTOP para tal processo (por ^ Z), considere gerar o csh primeiro e depois rodar o seu programa. Por outro lado, se você quiser enviar um SIGSTOP paraEspero em si, primeiro chamar intérprete (talvez usando um caractere de escape) e, em seguida, pressione ^ Z.
Pares de corpo de cadeia podem ser usados como uma abreviação para evitar ter que entrar no interpretador e executar comandos interativamente. O modo de terminal anterior é usado enquanto o corpo de um par de corpo de string está sendo executado.
Para velocidade, as ações são executadas no modo raw por padrão. o-restabelecer bandeira redefine o terminal para o modo que tinha antesinteragir foi executado (invariavelmente, modo cozido). Observe que os caracteres digitados quando o modo está sendo alternado podem ser perdidos (um recurso infeliz do driver de terminal em alguns sistemas). A única razão para usar-restabelecer é se a sua ação depende da execução no modo cozido.
o-eco flag envia caracteres que correspondem ao padrão a seguir de volta ao processo que os gerou à medida que cada caractere é lido. Isso pode ser útil quando o usuário precisa ver o feedback de padrões parcialmente tipados.
Se um padrão estiver sendo ecoado, mas eventualmente não corresponder, os caracteres serão enviados para o processo gerado. Se o processo gerado, em seguida, os ecoa, o usuário verá os caracteres duas vezes.-eco provavelmente é apropriado apenas em situações em que é improvável que o usuário conclua o padrão. Por exemplo, o trecho a seguir é do rftp, o script recursive-ftp, no qual o usuário é solicitado a inserir ~ g, ~ p ou ~ l para obter, colocar ou listar o diretório atual recursivamente. Estes são tão distantes dos comandos normais do ftp, que é improvável que o usuário digite ~ seguido por qualquer outra coisa, exceto equivocadamente, neste caso, eles provavelmente irão simplesmente ignorar o resultado.
interagir {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}
o-nobuffer flag envia caracteres que correspondem ao padrão a seguir para o processo de saída conforme os caracteres são lidos.
Isso é útil quando você deseja permitir que um programa retorne o padrão. Por exemplo, o seguinte pode ser usado para monitorar onde uma pessoa está discando (um modem estilo Hayes). Cada vez que "atd" é visto, o script registra o restante da linha.
proc lognumber {} {interagir -nobuffer -re "(. *) r" return coloca $ log "formato do relógio clock segundos: discado $ interact_out (1, string)"} interage -nobuffer "atd" lognumber
Duranteinteragir , uso prévio delog_user é ignorado. Em particular,interagir forçará sua saída a ser registrada (enviada para a saída padrão), uma vez que se presume que o usuário não deseja interagir cegamente.
o-o flag faz com que quaisquer pares de corpo-chave a seguir sejam aplicados à saída do processo atual. Isso pode ser útil, por exemplo, ao lidar com hosts que enviam caracteres indesejados durante uma sessão de telnet.
Por padrão,interagir espera que o usuário esteja escrevendo stdin e lendo stdout doEspero processo em si. o-você flag (para "usuário") fazinteragir procure o usuário como o processo nomeado por seu argumento (que deve ser um id gerado).
Isso permite que dois processos não relacionados sejam unidos sem usar um loop explícito. Para ajudar na depuração, o Expect Diagnostics sempre vai para stderr (ou stdout para determinadas informações de log e depuração). Pela mesma razão, ointérprete o comando lerá interativamente do stdin.
Por exemplo, o fragmento a seguir cria um processo de login. Em seguida, disca para o usuário (não mostrado) e, finalmente, conecta os dois juntos. Claro, qualquer processo pode ser substituído por login. Um shell, por exemplo, permitiria que o usuário trabalhasse sem fornecer uma conta e senha.
spawn login set login $ spawn_id spawn dica de modem # disca de volta para o usuário # conecta usuário para fazer login interaja -u $ login
Para enviar saída para vários processos, liste cada lista de ID de spawn precedida por um-saída bandeira. A entrada para um grupo de IDs de geração de saída pode ser determinada por uma lista de ID de desova precedida por um-entrada bandeira. (Ambos-entrada e-saída pode ter listas da mesma forma que o-Eu bandeira noEspero comando, exceto que any_spawn_id não é significativointeragir .) Todos os sinalizadores e seqüências de caracteres (ou padrões) a seguir se aplicam a essa entrada até que outro sinalizador de entrada seja exibido. Se não-entrada aparece,-saída implica "-input $ user_spawn_id -output". (Da mesma forma, com padrões que não têm-entrada .) Se um-entrada é especificado, ele substitui $ user_spawn_id. Se um segundo-entrada é especificado, ele substitui $ spawn_id. Adicional-entrada sinalizadores podem ser especificados.
Os dois processos de entrada implícitos padrão têm suas saídas especificadas como $ spawn_id e $ user_spawn_id (ao contrário). Se um-entrada bandeira aparece sem-saída flag, os caracteres desse processo são descartados.
o-Eu flag introduz um substituto para o atual spawn_id quando nenhum outro-entrada ou-saída bandeiras são usadas. Um sinalizador -i implica um sinalizador -o.
É possível alterar os processos que estão sendo interagidos usando ids de desova indiretos. (IDs de geração indireta são descritas na seção sobre o comando expect.) IDs de geração indireta podem ser especificadas com os sinalizadores -i, -u, -input ou -output.
intérprete args
faz com que o usuário seja solicitado interativamenteEspero e comandos Tcl. O resultado de cada comando é impresso.
Ações comopausa econtinuar causar estruturas de controle (ou seja,para , proc ) comportar-se da maneira habitual. ContudoRetorna faz com que o intérprete retorne ao chamador, enquantointer_return causasintérprete para causar um retorno em seu chamador. Por exemplo, se "proc foo" chamadointérprete que então executou a açãointer_return , proc foo retornaria. Qualquer outro comando causaintérprete para continuar solicitando novos comandos.
Por padrão, o prompt contém dois inteiros. O primeiro inteiro descreve a profundidade da pilha de avaliação (ou seja, quantas vezes Tcl_Eval foi chamado). O segundo inteiro é o identificador do histórico Tcl. O prompt pode ser definido definindo um procedimento chamado "prompt1", cujo valor de retorno se torna o próximo prompt. Se uma instrução tiver aspas abertas, parênteses, chaves ou colchetes, um prompt secundário (por padrão "+>") será emitido na nova linha. O prompt secundário pode ser definido pela definição de um procedimento chamado "prompt2".
Duranteintérprete , modo cozido é usado, mesmo se o seu chamador estava usando o modo raw.
Se stdin estiver fechado,intérprete retornará a menos que o-eof flag é usado, caso em que o argumento subsequente é invocado.
arquivo log_file args -a
Se um nome de arquivo for fornecido,arquivo de log irá gravar uma transcrição da sessão (começando nesse ponto) no arquivo.arquivo de log irá parar de gravar se nenhum argumento for dado. Qualquer arquivo de log anterior é fechado.
Em vez de um nome de arquivo, um identificador de arquivo Tcl pode ser fornecido usando o-abrir ou-deixe aberto bandeiras. Isso é semelhante aodesovar comando. (Vejodesovar para mais informações.)
o-uma sinalizador força a saída a ser registrada que foi suprimida pelolog_user comando.
Por padrão, oarquivo de log comando acrescenta para arquivos antigos em vez de truncá-los, para a conveniência de poder desativar o logging e ativá-lo várias vezes em uma sessão. Para truncar arquivos, use o-noappend bandeira.
o-info flag faz com que log_file retorne uma descrição dos argumentos mais recentes não informados.
log_user -info | 0 | 1
Por padrão, o diálogo de envio / espera é registrado no stdout (e um arquivo de log, se aberto). O registro em log para stdout é desativado pelo comando "log_user 0" e reativado por "log_user 1". O log no arquivo de log é inalterado.
o-info flag faz com que log_user retorne uma descrição dos argumentos mais recentes não informados.
match_max -d -i spawn_id tamanho
define o tamanho do buffer (em bytes) usado internamente porEspero . Com nenhum Tamanho argumento, o tamanho atual é retornado.
Com o-d flag, o tamanho padrão é definido. (O padrão inicial é 2000.) Com o-Eu flag, o tamanho é definido para o ID de desova nomeado, caso contrário, é definido para o processo atual.
overlay - # spawn_id - # spawn_id … programa args
executa "programa args "no lugar da correnteEspero programa, que termina. Um argumento hífen nua força um hífen na frente do nome do comando como se fosse um shell de login. Todos os spawn_ids são fechados, exceto aqueles nomeados como argumentos. Estes são mapeados nos identificadores de arquivos nomeados.
Spawn_ids são mapeados para identificadores de arquivo para o novo programa herdar. Por exemplo, a linha a seguir executa o xadrez e permite que ele seja controlado pelo processo atual - digamos, um mestre de xadrez.
sobreposição -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id xadrez
Isto é mais eficiente que "interaja -u", no entanto, ele sacrifica a habilidade de fazer interação programada desde oEspero o processo não está mais no controle.
Note que nenhum terminal de controle é fornecido. Assim, se você desconectar ou remapear a entrada padrão, os programas que fazem o controle do trabalho (shells, login, etc) não funcionarão corretamente.
paridade -d -i spawn_id valor
define se a paridade deve ser retida ou removida da saída de processos gerados. E se valor é zero, a paridade é removida, caso contrário não é removida. Com nenhum valor argumento, o valor atual é retornado.
Com o-d flag, o valor de paridade padrão é definido. (O padrão inicial é 1, ou seja, a paridade não é removida).-Eu flag, o valor de paridade é definido para o ID de desova nomeado, caso contrário, é definido para o processo atual.
remove_nulls -d -i spawn_id valor
define se os nulos são retidos ou removidos da saída de processos gerados antes da correspondência de padrões ou do armazenamento na variável expect_out ou interact_out . E se valor é 1, os nulos são removidos. E se valor é 0, os nulos não são removidos. Com nenhum valor argumento, o valor atual é retornado.
Com o-d flag, o valor padrão é definido. (O padrão inicial é 1, ou seja, os nulos são removidos).-Eu flag, o valor é definido para o ID de spawn nomeado, caso contrário, é definido para o processo atual.
Se os nulos são removidos ou não,Espero irá gravar bytes nulos para o log e stdout.
send -flags string
Envia corda para o processo atual. Por exemplo, o comando
envie "hello world r"
envia os caracteres, para o processo atual. (Tcl inclui um comando tipo printf (chamadoformato ) que pode construir strings arbitrariamente complexas.
Os caracteres são enviados imediatamente, embora os programas com entrada com buffer de linha não leiam os caracteres até que um caractere de retorno seja enviado. Um caractere de retorno é denotado " r".
o-- flag força o próximo argumento a ser interpretado como uma string em vez de um flag.Qualquer string pode ser precedida por "-", se realmente se parece com um sinalizador. Isso fornece um mecanismo confiável para especificar cadeias variáveis sem ser ativado por aqueles que acidentalmente se parecem com sinalizadores. (Todas as strings começando com "-" são reservadas para opções futuras).
o-Eu flag declara que a string é enviada para o spawn_id nomeado. Se o spawn_id for user_spawn_id , e o terminal está no modo raw, as novas linhas na string são traduzidas para retornar as seqüências da nova linha, de modo que elas apareçam como se o terminal estivesse no modo cozido. o-cru flag desabilita esta tradução.
o-nulo sinalizador envia caracteres nulos (0 bytes). Por padrão, um nulo é enviado. Um inteiro pode seguir o-nulo para indicar quantos nulos para enviar.
o-pausa flag gera uma condição de quebra. Isso só faz sentido se o id do spawn se referir a um dispositivo tty aberto via "spawn -open". Se você gerou um processo como a dica, deve usar a convenção da dica para gerar uma pausa.
o-s sinalizador força a saída a ser enviada "lentamente", evitando assim a situação comum em que um computador ultrapassa um buffer de entrada que foi projetado para um ser humano que nunca ultrapassaria o mesmo buffer. Essa saída é controlada pelo valor da variável "send_slow", que recebe uma lista de dois elementos. O primeiro elemento é um inteiro que descreve o número de bytes a enviar atomicamente. O segundo elemento é um número real que descreve o número de segundos pelos quais os envios atômicos devem ser separados. Por exemplo, "set send_slow {10 .001}" forçaria "send -s" a enviar strings com 1 milissegundo entre cada 10 caracteres enviados.
o-h flag forças saída para ser enviada (um pouco) como um ser humano realmente digitando. Atrasos humanos aparecem entre os personagens. (O algoritmo é baseado em uma distribuição Weibull, com modificações para atender a essa aplicação específica.) Esta saída é controlada pelo valor da variável "send_human", que recebe uma lista de cinco elementos. Os dois primeiros elementos são um tempo médio entre os caracteres em segundos. O primeiro é usado por padrão. O segundo é usado em terminações de palavras, para simular as pausas sutis que ocasionalmente ocorrem em tais transições. O terceiro parâmetro é uma medida de variabilidade em que .1 é bastante variável, 1 é razoavelmente variável e 10 é bastante invariável. Os extremos são 0 ao infinito. Os dois últimos parâmetros são, respectivamente, um tempo mínimo e máximo entre chegadas. O mínimo e o máximo são usados por último e "recortam" a hora final. A média final pode ser bem diferente da média dada se os valores mínimos e máximos do clipe forem suficientes.
Como exemplo, o comando a seguir emula um datilógrafo rápido e consistente:
set send_human {.1 .3 1 .05 2} send -h "Estou com fome. Vamos almoçar."
enquanto o seguinte pode ser mais adequado após uma ressaca:
set send_human {.4 .4 .2 .5 100} enviar -h "Goodd party lash night!"
Observe que os erros não são simulados, embora você mesmo possa configurar situações de correção de erros incorporando erros e correções em um argumento de envio.
Os sinalizadores para enviar caracteres nulos, para enviar quebras, para forçar saída lenta e para saída de estilo humano são mutuamente exclusivos. Apenas o último especificado será usado. Além disso, não corda argumento pode ser especificado com os sinalizadores para enviar caracteres nulos ou quebras.
É uma boa ideia preceder o primeiromandar para um processo por umEspero. Espero vai esperar o processo começar, enquantomandar não podes. Em particular, se o primeiromandar antes de o processo começar a ser executado, você corre o risco de ignorar seus dados. Em situações em que os programas interativos não oferecem um aviso inicial, você pode precedermandar por um atraso como em:
# Para evitar dar dicas aos hackers sobre como entrar, # este sistema não solicita uma senha externa. # Aguarde 5 segundos para exec completar spawn telnet very.secure.gov sono 5 enviar senha
exp_send é um alias para mandar. Se você estiver usando o Expectk ou alguma outra variante do Expect no ambiente Tk,mandar é definido por Tk para um propósito totalmente diferente.exp_send é fornecido para compatibilidade entre ambientes. Aliases semelhantes são fornecidos para outros outros comandos de envio do Expect.
send_error -flags string
é comomandar , exceto que a saída é enviada para stderr em vez do processo atual.
send_log - string
é comomandar , exceto que a string é enviada apenas para o arquivo de logarquivo de log .) Os argumentos são ignorados se nenhum arquivo de log estiver aberto.
send_tty -flags string
é comomandar , exceto que a saída é enviada para / dev / tty em vez do processo atual.
send_user -flags string
é comomandar , exceto que a saída é enviada para stdout em vez do processo atual.
segundos de sono
faz com que o script durm
