El comandament de Linux / Unix s'espera

Expect és un programa que parla amb altres programes interactius d'acord amb un script. Després del guió, Expect sap què es pot esperar d'un programa i quina hauria de ser la resposta correcta. Un llenguatge interpretat proporciona branques i estructures de control d'alt nivell per dirigir el diàleg. A més, l'usuari pot prendre el control i interactuar directament quan ho desitgeu, després retornar el control al script.

Expectk és una barreja de Expect i Tk. Es comporta com Expect i el desig de Tk. Esperar també es pot utilitzar directament en C o C + + sense Tcl.

El nom "Esperar" prové de la idea d'enviar / esperar seqüències popularitzades per uucp, kermit i altres programes de control de mòdem. Tanmateix, a diferència de uucp, Expect es generalitza perquè es pugui executar com a comandament a nivell d'usuari amb qualsevol programa i tasca en ment. Podeu parlar amb diversos programes al mateix temps.

Què es pot esperar?

Per exemple, aquí teniu algunes coses que l'ordre d'espera pot fer:

• Causa que l'equip torni a marcar, de manera que pugui iniciar sessió sense pagar la trucada.
• Comenceu un joc i, si la configuració òptima no apareix, torneu-la a reiniciar una i altra vegada) fins que ho faci, i després us lliuri el control.
• Executeu fsck i, en resposta a les seves preguntes, responeu "sí" o "no" o regaleu-vos el control, segons criteris predeterminats.
• Connecteu-vos a una altra xarxa i recupereu automàticament el vostre correu perquè aparegui com si s'hagués enviat originalment al vostre sistema local.
• Porteu variables d'entorn, directori actual o qualsevol tipus d'informació a rlogin, telnet, tip, su o chgrp

Hi ha una varietat de raons per les quals el shell no pot realitzar aquestes tasques. Tot és possible amb Esperar.

En general, Esperar és útil per executar qualsevol programa que requereixi una interacció entre el programa i l'usuari. Tot el que cal és que la interacció es pugui caracteritzar mitjançant programació. Esperar també pot retornar el control a l'usuari sense detenir el control del programa. De la mateixa manera, l'usuari pot tornar el control a l'script en qualsevol moment.

Ús

Espereu llegir cmdfile per obtenir una llista d'ordres per executar. Es pot invocar implicit implícitament en sistemes que suportin el #! notació marcant el script com a executable i fent la primera línia en el script:

#! / usr / local / bin / expect -f

Per descomptat, el camí ha de descriure amb precisió on viu la vida. / usr / local / bin és només un exemple.

El -c flag preveu una ordre que s'executarà abans que qualsevol en el script. S'haurà de citar l'ordre per evitar que la shell es trenqui. Aquesta opció es pot utilitzar diverses vegades. Es poden executar diverses ordres amb un sol -c separant-les amb punt i coma. Les ordres s'executen en l'ordre en què apareixen. Quan s'utilitza Expectk, aquesta opció s'especifica com -command.

L'indicador -d permet una sortida de diagnòstic, que principalment informa l'activitat interna de les ordres tals com esperar i interactuar. Aquesta bandera té el mateix efecte que "exp_internal 1" al començament d'un script d'Expect, a més s'imprimeix la versió de Expect.

La marca -D permet un depurador interactiu. Cal seguir un valor sencer. El depurador es farà càrrec abans del següent procediment de Tcl si el valor no és zero o si es prem un ^ C o es produeix un punt d'interrupció o si apareix un altre comandament de depurador adequat al script. Quan s'utilitza Expectk, aquesta opció s'especifica com - Depuració.

La bandera -f prefereix un fitxer des del qual llegir comandes. La mateixa bandera és opcional, ja que només és útil quan s'utilitza el #! notació, de manera que es puguin proporcionar altres arguments a la línia d'ordres. Quan s'utilitza Expectk, aquesta opció s'especifica com a fitxer.

Per defecte, el fitxer de comandes es llegeix a la memòria i s'executa en la seva totalitat. De vegades és desitjable llegir fitxers d'una línia alhora. Per obligar els arxius arbitraris a tractar d'aquesta manera, utilitzeu l'indicador -b. Quan s'utilitza Expectk, aquesta opció s'especifica com a variable.

Si la cadena "-" es proporciona com un nom de fitxer, es llegeix l'entrada estàndard. Utilitzeu "./-" per llegir des d'un fitxer anomenat "-".

La marca -i provoca que s'espera que les ordres interactives en lloc de llegir-les des d'un fitxer. S'acaba el missatge mitjançant l'ordre de sortida o en EOF. S'assumeix la bandera -i si no s'utilitza cap fitxer de comandament ni -c. Quan s'utilitza Expectk, aquesta opció s'especifica com -interactiva.

- es pot utilitzar per delimitar el final de les opcions. Això és útil si voleu passar un argument com a opció al vostre script sense que això sigui interpretat per Expect. Això es pot col·locar de manera útil a la #! línia per evitar qualsevol interpretació flagrant per Expect. Per exemple, el següent deixarà els arguments originals incloent el nom del script en la variable argv .

#! / usr / local / bin / expect -

Tingueu en compte que les convencions usuals getopt (3) i execve (2) s'han d'observar quan s'afegeixen arguments al #! línia

El fitxer $ exp_library / expect.rc s'origina automàticament si està present, tret que s'utilitzi la bandera -N. (Quan s'utilitza Expectk, aquesta opció s'especifica com -NORC.) Immediatament després d'això, el fitxer ~ / .expect.rc s'origina automàticament, tret que s'utilitzi la bandera -n. Si es defineix la variable d'entorn DOTDIR, es tracta com un directori i es llegeix .expect.rc. Quan s'utilitza Expectk, aquesta opció s'especifica com -norc. Aquesta font d'accés només es produeix després d'executar tots els indicadors -c.

-v causes Espereu imprimir el vostre número de versió i sortiu. La bandera corresponent a Expectk, que utilitza noms de bandera llargs, és -version.

Els args opcionals es construeixen en una llista i s'emmagatzemen a la variable anomenada argv i. argc s'inicialitza a la longitud de argv.

Argv0 es defineix com el nom del script o binari si no s'utilitza cap script. Per exemple, els següents imprimeix el nom de l'script i els tres primers arguments:

send_user "$ argv0 [lrange $ argv 0 2] \ n"

Ordres

Espereu que utilitzeu l'idioma d'ordres d'eines. Tcl proporciona un flux de control (si, per, trenca), l'avaluació de l'expressió i diverses altres funcions, com ara la recursió i la definició de procediments. Les ordres que s'utilitzen aquí, però no definides (set, if, exec) són ordres Tcl. Espereu que admet comandes addicionals. A menys que s'especifiqui el contrari, les ordres retornen la cadena buida.

Els comandaments s'enumeren alfabèticament perquè puguin localitzar-se ràpidament. Tanmateix, els nous usuaris poden trobar més fàcil començar per llegir les descripcions de generar, enviar, esperar i interactuar, en aquest ordre.

tancar [-slave] [-exec 0 | 1] [-i spawn_id]

tanca la connexió amb el procés actual. La majoria de programes interactius detectaran EOF en el seu stdin i surten; tan a prop, solen matar el procés . La bandera -i declara que el procés es tanca corresponent a l'spawn_id anomenat.

Tots dos esperen i interactuen detectaran quan el procés actual surt i implícitament es tanqui, però si mata el procés , digueu "exec kill $ pid", heu de trucar explícitament a prop .

La marca -execució determina si l'id de generació es tanca en qualsevol procés generat o si el procés està superposat. Per deixar un spawn id obert, utilitzeu el valor 0. Un valor sencer de zero que obliga a la generació tancada en qualsevol procés nou.

L'indicador -slave tanca l'esclau associat amb l'id. De generació. Quan es tanca la connexió, l'esclau també es tanca automàticament si encara està obert.

Independentment de si la connexió es tanca implícita o explícitament, haureu de trucar a esperar per netejar la ranura corresponent del procés del nucli. L'ordre de tancament no crida a esperar ja que no hi ha cap garantia que tancar una connexió de procés provocarà la sortida.

depuració [[-now] 0 | 1]

controla un depurador de Tcl que permet passar declaracions i establir punts d'interrupció.

Sense arguments, es torna un 1 si el depurador no s'està executant, en cas contrari es retornarà un 0.

Amb un argument 1, el depurador s'inicia. Amb un argument 0, el depurador es deté. Si un argument 1 és precedit pel -now flag, el depurador s'inicia immediatament. En cas contrari, el depurador s'inicia amb el següent extracte de Tcl.

L'ordre de depuració no canvia cap tramvia. Compareu-ho amb l'esperança de començar amb el pavelló -D.

L'ordre de desconexió desconecta un procés bifurcat del terminal . Continua funcionant en segon pla. El procés es lliura al seu propi grup de processos. Les E / S estàndard es redirigeixen a / dev / null .

El següent fragment utilitza la desconnexió per continuar executant l'script en segon pla.

si {[fork]! = 0} sortiu de la desconnexió. . .

El següent script llegeix una contrasenya i executa un programa cada hora que requereix una contrasenya cada vegada que s'executa. El script proporciona la contrasenya perquè només hàgiu d'escriure una vegada.

enviar_usuari "contrasenya? \" expect_user -re "(. *) \ n" per {} 1 {) {if {[fork]! = 0} (sleep 3600; continue) desconnectar spawn priv_prog esperar Contrasenya: enviar "$ expect_out ( 1, cadena) \ r ". . . sortir}

L'avantatge d'utilitzar la desconnexió en la funció de procés asíncron de la carcassa (&) és que Expect pot guardar els paràmetres del terminal abans de la desconnexió i, més tard, aplicar-los a nous ptys. Amb &, Expect no té la possibilitat de llegir els paràmetres del terminal ja que el terminal ja està desconnectat en el moment que Expect rep el control.

sortir [-opts] [estatus]

causa que s'espera sortir o d'alguna manera preparar-se per fer-ho.

La marca -executar fa que el següent argument s'utilitzi com a controlador de sortida. Sense un argument, es torna el controlador de sortida actual.

El senyal -noexit provoca que s'espera que es prepari per sortir però que deixi de tornar el control del sistema operatiu. El controlador de sortida definit per l'usuari s'executa així com els controladors interns de Expect mateixos. No s'haurien d'executar més comandaments Expect. Això és útil si esteu executant Expect amb altres extensions de Tcl. L'intèrpret actual (i la finestra principal si en l'entorn Tk) romanen de manera que altres extensions de Tcl es puguin netejar. Si es torna a trucar a la sortida d' Expect (això pot passar), els controladors no es tornen a executar.

Al sortir, es tanquen totes les connexions als processos generats. El tancament es detectarà com un EOF per processos generats. la sortida no pren cap altra acció més enllà del que fa el procediment normal _exit (2). Per tant, els processos generats que no comproven EOF poden continuar funcionant. (Una varietat de condicions són importants per determinar, per exemple, quins senyals generarà un procés generat, però aquests són dependents del sistema, generalment documentats a la sortida (3)). Els processos generats que continuen funcionant seran heretats per init.

L'estat (o 0 si no s'especifica) es retorna com a estat de sortida de Expect . la sortida s'executa implícitament si s'aconsegueix el final de la seqüència d'ordres.

exp_continue [-continue_timer]
La comanda exp_continue permet esperar que continuï executant en comptes de tornar com ho faria normalment. De manera predeterminada exp_continue restablirà el temporitzador de temps d'espera. La bandera -continue_timer impedeix que el temporitzador es reiniciï. (Mireu l' esperança per obtenir més informació.)

exp_internal [-f fitxer] valor
fa que altres comandaments enviïn informació de diagnòstic intern a Esperar a stderr si el valor no és zero. Aquesta sortida està desactivada si el valor és 0. La informació de diagnòstic inclou tots els caràcters rebuts i tots els intents realitzats per ajustar la sortida actual als patrons.

Si s'ofereix el fitxer opcional, tota la sortida normal i de depuració s'escriu en aquest fitxer (independentment del valor del valor ). Qualsevol fitxer anterior de sortida de diagnòstic està tancat.

El signe -info fa que exp_internal retorni una descripció dels arguments no informatius més recents donats.

exp_open [args] [-i spawn_id]
torna un identificador de fitxer Tcl que correspon a l'id. de generació original. L'identificador de fitxer es pot utilitzar com si estigués obert per l'ordre obert de Tcl. (La id. Generada no s'hauria d'utilitzar més. No s'ha d'executar una espera .

La marca -leaveopen deixa l'obertura d'obertura per accedir a través dels comandaments Expect. S'ha d'executar una espera a l'id. De spawn.

exp_pid [-i spawn_id]
retorna la id de procés corresponent al procés actual generat. Si s'utilitza la bandera -i , el pid retornat correspon a l'id. Generada.

exp_send
és un àlies per enviar .

exp_send_error
és un àlies de send_error .

exp_send_log
és un àlies de send_log .

exp_send_tty
és un àlies per enviar_tty .

exp_send_user
és un àlies per enviar_usuari .

exp_version [[-exit] version]
és útil per assegurar que el script és compatible amb la versió actual de Expect.

Sense arguments, es torna la versió actual de Expect . Aquesta versió es pot codificar al vostre script. Si realment sap que no està utilitzant característiques de versions recents, podeu especificar una versió anterior.

Les versions consisteixen en tres números separats per punts. Primer és el nombre més important. Les seqüències d'ordres escrites per a versions de Expect amb un nombre major diferent gairebé no funcionaran. exp_version retorna un error si els nombres principals no coincideixen.

El segon és el nombre menor. Les seqüències d'ordres escrites per a una versió amb un menor nombre menor que la versió actual poden dependre d'una funció nova i no es pugui executar. exp_version retorna un error si els nombres principals coincideixen, però el número de seqüència de comandaments és major que el de l'execució en execució.

Tercer és un nombre que no té cap part en la comparació de versions. No obstant això, s'incrementa quan la distribució de programari Expect es canvia de qualsevol manera, com ara documentació addicional o optimització. Es reinicia a 0 en cada nova versió menor.

Amb l'indicador -exit , Expect imprimeix un error i surt si la versió està fora de data.

espera [[-opts] pat1 body1] ... [-opts] patn [bodyn]
espera fins que un dels patrons coincideixi amb la sortida d'un procés generat, un període de temps especificat ha passat o es veu un fi de fitxer. Si el cos final està buit, es pot ometre.

Els patrons de l'ordre expect_before més recent s'utilitzen implícitament abans de qualsevol altre patró. Els patrons de l'ordre expect_after més recent s'utilitzen implícitament després de qualsevol altre patró.

Si els arguments a tota la instrucció esperada requereixen més d'una línia, tots els arguments es poden "integrar" en un d'ells per tal d'evitar la finalització de cada línia amb una barra invertida. En aquest cas, es produiran les substitucions habituals de Tcl malgrat les claus.

Si un patró és la paraula clau eof , el cos corresponent s'executa al final de fitxer. Si un patró és el temps d'espera de la paraula clau, el cos corresponent s'executa amb el temps d'espera. Si no s'utilitza cap paraula clau de temps d'espera, s'executa una acció nul·la implícita en el temps d'espera. El període de temps d'espera predeterminat és de 10 segons, però es pot establir, per exemple, a 30, mitjançant l'ordre "set timeout 30". Es pot designar un temps d'espera infinit pel valor -1. Si un patró és la paraula clau per defecte , el cos corresponent s'executa amb el temps d'espera o final de fitxer.

Si un patró coincideix, s'executa el cos corresponent. espera retornar el resultat del cos (o la cadena buida si no hi ha cap patró empatat). En cas que coincideixin diversos patrons, el que apareix primer s'utilitza per seleccionar un cos.

Cada vegada que arriba la sortida nova, es compara amb cada patró en l'ordre en què s'enumeren. Per tant, podeu provar l'absència d'una coincidència fent que l'últim patró sigui garantit per aparèixer, com ara un indicador. En situacions on no hi ha cap indicació, heu d'utilitzar el temps d'espera (tal com ho faria si interaccionava manualment).

Els patrons s'especifiquen de tres maneres. De manera predeterminada, els patrons s'especifiquen com amb l'ordre de coincidència de cadenes de Tcl. (Aquests patrons també són semblants a les expressions regulars de la C-shell normalment denominades patrons de "glob"). Es pot utilitzar l'indicador -gl per protegir els patrons que d'una altra manera podrien coincidir amb les esperades banderes. Qualsevol patró que comenci amb un "-" ha de ser protegit d'aquesta manera. (Totes les cadenes que comencen per "-" estan reservades per a futures opcions.)

Per exemple, el següent fragment busca un inici de sessió reeixit. (Tingueu en compte que es considera que l' avortament és un procediment definit en un altre lloc de l'script).

espera {ocupat {posa ocupat \ n; exp_continue} ha fallat en avortar "contrasenya no vàlida" abortar el temps d'espera avortat connectat}

Les quotes són necessàries en el quart patró ja que conté un espai que, d'altra manera, separaria el patró de l'acció. Els patrons amb la mateixa acció (com el 3 i 4) requereixen tornar a incloure les accions. Això es pot evitar utilitzant patrons d'estil regexp (vegeu a continuació). Podeu trobar més informació sobre la formació de patrons d'estil globus al manual de Tcl.

Els patrons d'estil de Regexp segueixen la sintaxi definida per la comanda regexp de Tcl (abreviatura de "expressió regular"). Els patrons de regexp s'introdueixen amb el pavelló -re . L'exemple anterior es pot reescriure utilitzant un regexp com:

espera {ocupat {posa ocupat \ n; exp_continue} -re "fallat | contrasenya no vàlida" abort timeout abort connectat}

Tots dos tipus de patrons són "sense coincidències". Això vol dir que els patrons no han de coincidir amb la cadena sencera, però pot començar i acabar la coincidència en qualsevol lloc de la cadena (sempre que la resta coincideixi). Utilitzeu ^ perquè coincideixi amb l'inici d'una cadena i $ coincideixi amb el final. Tingueu en compte que si no espereu el final d'una cadena, les vostres respostes poden acabar fàcilment al centre de la cadena, ja que es fan ressons del procés generat. Tot i que encara produeix resultats correctes, la sortida pot semblar antinatural. D'aquesta manera, s'utilitza l'ús de $ si es pot descriure exactament els caràcters al final d'una cadena.

Tingueu en compte que, en molts editors, els ^ i $ coincideixen amb el principi i el final de les línies, respectivament. Tanmateix, com que esperar no està orientat a la línia, aquests caràcters coincideixen amb el principi i el final de les dades (a diferència de les línies) actualment a la memòria intermèdia esperada. (A més, vegeu la nota de sota sobre "indigestió del sistema").

L'indicador -ex fa que el patró sigui igualat com una cadena "exacta". No es fa cap interpretació de *, ^, etc. (tot i que encara cal observar les convencions habituals de Tcl). Els patrons exactes sempre són incorrectes.

El indicador -nocase fa que els caràcters en majúscula de la sortida es comparin com si fossin caràcters en minúscules. El patró no es veu afectat.

Mentre es llegeix la sortida, més de 2000 bytes poden forçar els bytes anteriors a ser "oblidats". Això es pot canviar amb la funció match_max . (Tingueu en compte que els valors excessivament grans poden alentir el patró de patrons). Si la llista de patrons és full_buffer , s'executa el cos corresponent si s'han rebut bytes match_max i no s'han trobat cap altre patró. Si s'utilitza o no la paraula clau full_buffer , els caràcters oblidats s'escriuen a expect_out (buffer).

Si la llista de patents és la paraula clau nul·la , i es permeten nul·les (a través de l'ordre remove_nulls ), el cos corresponent s'executa si hi coincideix un ASCII 0 únic. No és possible fer coincidir 0 bytes a través de patrons globus o regexp.

En combinar un patró (o eof o full_buffer), es guarda qualsevol sortida coincident i prèviament incomparable a la variable expect_out (buffer) . Fins a 9 coincidències de subcadenes de regexp es guarden a les variables expect_out (1, string) a través d' expect_out (9, string) . Si s'utilitza l'indicador d'índexs abans d'un patró, els índexs d'inici i final (en una forma adequada per a l' interval ) de les 10 cadenes s'emmagatzemen a les variables expect_out (X, start) i expect_out (X, end) on X és un dígit, correspon a la posició de subcadena en el buffer. 0 es refereix a cadenes que coincideixen amb el patró sencer i es generen per als patrons glob, així com els patrons de regexp. Per exemple, si un procés ha produït una sortida de "abcdefgh \ n", el resultat de:

espera "cd"

és com si s'haguessin executat les següents afirmacions:

establir expect_out (0, cadena) cd set expect_out (buffer) abcd

i "efgh \ n" queda al buffer de sortida. Si un procés produïa la sortida "abbbcabkkkka \ n", el resultat de:

espera -indices -re "b (b *). * (k +)"

és com si s'haguessin executat les següents afirmacions:

establir expect_out (0, start) 1 set expect_out (0, end) set set expect_out (0, string) bbbcabkkkk set expect_out (1, start) 2 set expect_out (1, end) set set expect_out (1, string) set set expect_out (2, inici) set set expect_out (2, final) set set expect_out (2, string) k set expect_out (buffer) abbbcabkkkk

i "a \ n" queda al buffer de sortida. El patró "*" (i -re ". *") Eliminarà el buffer de sortida sense llegir cap sortida del procés.

Normalment, la sortida coincident es descarta dels buffers interns de Expect. Això es pot prevenir prefixant un patró amb l'indicador -notransferir . Aquesta bandera és especialment útil a l'hora d'experimentar (i es pot abreviar a "-not" per a la seva conveniència mentre s'està experimentant).

L'identificador spawn associat amb la sortida coincident (o eof o full_buffer) s'emmagatzema a expect_out (spawn_id) .

El senyal de temps d'espera fa que l'ordre esperada actual utilitzi el valor següent com a temps d'espera en comptes d'utilitzar el valor de la variable de temps d'espera.

Per defecte, els patrons coincideixen amb la sortida del procés actual, però la bandera -i declara que la sortida de la llista spawn_id anomenada es compara amb els patrons següents (fins a la següent -i ). La llista spawn_id ha de ser una llista separada d'espai spawn_ids o una variable que faci referència a aquesta llista de spawn_id.

Per exemple, el següent exemple espera "connectat" del procés actual, o "ocupat", "fallat" o "contrasenya no vàlida" de la spawn_id anomenada per $ proc2.

espera {-i $ proc2 ocupat {posa ocupat \ n; exp_continue} -re "fallat | contrasenya no vàlida" abort timeout abort connectat}

El valor de la variable global any_spawn_id pot utilitzar-se per igualar els patrons a qualsevol spawn_ids que es nomeni amb tots els altres- i banderes en l'ordre esperat actual. El spawn_id d'una bandera -i sense un patró associat (és a dir, seguit immediatament per un altre -i ) es posa a disposició de qualsevol altre patró en la mateixa comanda d' espera associada amb qualsevol_spawn_id.

La bandera -i també pot nomenar una variable global, en aquest cas la variable es llegeix per obtenir una llista d'identitats generades. La variable es rellegirà cada vegada que canvia. Això proporciona una manera de canviar la font d'E / S mentre la comanda està en execució. Els identificadors de spawn proporcionats d'aquesta manera es diuen com a identificadors de generació "indirectes".

Les accions com ara trencar i continuar provoquen estructures de control (és a dir, per a , proc ) comportar-se de la manera habitual. La comanda exp_continue permet esperar que continuï executant en comptes de tornar com ho faria normalment.

Això és útil per evitar bucles explícits o declaracions de expectatives repetides. El següent exemple forma part d'un fragment per automatitzar el rlogin. L' exp_continue evita haver d'escriure una segona declaració d' espera (per buscar l'indicador de nou) si el rlogin demana una contrasenya.

Espero {Password: (stty -echo send_user "password (per $ user) a $ host:" expect_user -re "(. *) \ n" send_user "\ n" enviar "$ expect_out (1, cadena) \ r" stty echo exp_continue} incorrecta {send_user "contrasenya o compte no vàlida \ n" exit} timeout {send_user "connexió a $ host ha caducat \ n" exit} eof {send_user \ "connexió a host fallat: $ expect_out (buffer)" exit) - missatge re $)

Per exemple, el següent fragment podria ajudar a un usuari a guiar una interacció que ja està totalment automatitzada. En aquest cas, el terminal es posa en mode brut. Si l'usuari premeu "+", s'incrementa una variable. Si es prem la tecla "p", es enviaran diverses devolucions al procés, potser per fer-ho d'alguna manera i "i" permet que l'usuari interactuï amb el procés, estalviant de manera efectiva el control del script. En cada cas, l' exp_continue permet que l'actual espera continuar la coincidència de patrons després d'executar l'acció actual.

stty raw -echo expect_after {-i $ user_spawn_id "p" {enviar "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {interactueu; exp_continue} "deixar" sortir

De manera predeterminada, exp_continue restablirà el temporitzador de temps d'espera. El temporitzador no es reinicia, si exp_continue es crida amb l'indicador -continue_timer .

expect_after [expect_args]
funciona de manera idèntica a l' expectativa_pero abans, excepte si els patrons d' espera i expect_after poden coincidir, s'utilitza el patró d' espera . Vegeu l'ordre expect_before per obtenir més informació.

expect_background [expect_args]
pren els mateixos arguments que esperen , però torna immediatament. Els patrons es comproven cada vegada que arriba una nova entrada. El temps d' execució del patró i el valor predeterminat no tenen sentit a expect_background i es rebutgen en silenci. En cas contrari, l'ordre expect_background usarà expect_before i expect_after patrons com ho fa esperar .

Quan s'estan avaluant les accions de expect_background , es bloqueja el processament de fons per a la mateixa identificació de generació. El procés de fons es desbloqueja quan s'acaba l'acció. Tot i que el bloqueig del procés de fons està bloquejat, és possible fer una expectació (primer pla) a la mateixa identificació de generació.

No es pot executar una espera mentre es desbloqueja un expect_background . expect_background per a un identificador genètic determinat se suprimeix declarant un nou expect_background amb el mateix identificador spawn. Declarar expect_background sense patró elimina l'id. De generació donada de la capacitat de coincidir amb els patrons en segon pla.

espera_prevés [expect_args]
pren els mateixos arguments que esperen , però torna immediatament. Els parells de patrons d'acció dels esperats més recents, abans, amb el mateix id. De generació, s'afegeixen implícitament a les ordres esperades següents. Si un patró coincideix, es tracta com si s'hagués especificat a la comanda expect , i el cos associat s'executa en el context de l'ordre expect . Si els patrons de both expect_before i expect poden coincidir, s'utilitza el patró expect_before .

Si no s'especifica cap patró, l'id de generació no està marcada per cap patró.

A no ser que s'hagi anul·lat per una bandera -i , espereu que els patrons coincideixin amb l'id de generació definida en el moment en què es va executar l'ordre expect_before (no quan el patró coincideix).

El indicador -info causa expect_perfore retornar les especificacions actuals de quins patrons coincidiran. De manera predeterminada, informa sobre l'id. Actual de generació. Es pot donar una especificació opcional d'identificació de generació per obtenir informació sobre l'id. Per exemple

expect_before -info -i $ proc

Com a màxim es pot donar una especificació de generació d'identificació. L'indicador flag-suppresses suprimeix ids de generació directa que només provenen de les especificacions indirectes.

En lloc d'especificar un identificador de spawn, la bandera "-tot" farà que "-info" informi sobre tots els identificadors de spawn.

La sortida de la marca -info pot ser reutilitzada com a argument a esperar_vaure.

expect_tty [expect_args]
és com esperar, però llegeix els caràcters de / dev / tty (és a dir, pulsacions de tecles de l'usuari). Per defecte, la lectura es realitza en mode cuinat. Per tant, les línies han de finalitzar amb una devolució per poder esperar veure'ls. Això es pot canviar a través de stty (vegeu l'ordre stty següent).

expect_user [expect_args]
és com esperar, però llegeix els personatges de stdin (és a dir, les pulsacions de teclat de l'usuari). Per defecte, la lectura es realitza en mode cuinat. Per tant, les línies han de finalitzar amb una devolució per poder esperar veure'ls. Això es pot canviar a través de stty (vegeu l'ordre stty següent).

forquilla
crea un nou procés . El nou procés és una còpia exacta del procés actual de Expect . En l'èxit, la bifurcació torna 0 al procés nou (fill) i retorna l'ID del procés del procés secundari al procés primari. En fracassar (invariablement per manca de recursos, per exemple, intercanviar espai, memòria), la bifurcació torna -1 al procés primari i no es crea cap procés secundari.

Els processos de bifurcació surten a través de l'ordre de sortida , igual que el procés original. Es permet escriure als fitxers de registre els processos de bifurcació. Si no inhabiliteu la depuració o el registre de la majoria de processos, el resultat pot ser confús.

Alguns desenvolupaments de pty poden ser confosos per diversos lectors i escriptors, fins i tot momentàniament. Per tant, és més segur de forquilla abans dels processos de generació.

interactueu [string1 body1] ... [stringn [bodyn]]
dóna el control del procés actual a l'usuari, de manera que les pulsacions de tecles s'envien al procés actual i es tornen els processos actuals i estndards del procés actual.

Els parells de cos de cadena es poden especificar com a arguments, en aquest cas el cos s'executa quan s'introdueix la cadena corresponent. (De manera predeterminada, la cadena no s'envia al procés actual.) Se suposa que el comandament de l' intèrpret , si falta el cos final.

Si els arguments a tota la instrucció d' interacció requereixen més d'una línia, tots els arguments es poden "integrar" en un d'ells per tal d'evitar la finalització de cada línia amb una barra invertida. En aquest cas, es produiran les substitucions habituals de Tcl malgrat les claus.

Per exemple, la següent ordre s'executa interactuant amb els següents parells de cos de cordes definits: Quan ^ Z es pressiona, s'espera que estigui suspès. (L'indicador -resetor restaura els modes de terminal.) Quan ^ A es pressiona, l'usuari veu "heu teclejat un control-A" i el procés s'envia a ^ A. Quan es pressiona $, l'usuari veu la data. Quan ^ C es prem, espereu sortides. Si s'introdueix "foo", l'usuari veu la "barra". Quan ~~ es pressiona, l'intèrpret Expect s'executa de manera interactiva.

configureu CTRLZ \ 032 interactueu {-reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "heu teclejat un control-A \ n"; enviar "\ 001"} $ {send_user "La data és [format de rellotge [segells de rellotge]].}} \ 003 sortir foo {send_user" bar "} ~~}

En els parells de cadenes de cos, les cadenes coincideixen en l'ordre en què es classifiquen com a arguments. Les cadenes que coincideixen parcialment no s'envien al procés actual amb vista a la resta. Si els caràcters s'introdueixen de manera que ja no pot ser una coincidència, només s'enviarà la part de la cadena al procés que possiblement no pugui començar una altra coincidència. D'aquesta manera, les cadenes que són subcadenes de coincidències parcials poden coincidir més endavant, si les cadenes originals que intentava ser coincidència fracassen en última instància.

Per defecte, la combinació de cadenes és exacta, sense targetes salvatges . (En contrast, la comanda expect utilitza els patrons d'estil global de manera predeterminada). L'indicador -ex pot ser utilitzat per protegir els patrons que d'altra manera podrien coincidir amb les marques d' interacció . Qualsevol patró que comenci amb un "-" ha de ser protegit d'aquesta manera. (Totes les cadenes que comencen per "-" estan reservades per a futures opcions.)

El indicador -re forces la cadena a interpretar-se com un patró d'estil regexp. En aquest cas, les subcadenes coincidents s'emmagatzemen a la variable interact_out de manera similar a la manera en què espera emmagatzema la seva sortida a la variable expect_out . La bandera -indices també és compatible.

El patró eof introdueix una acció que s'executa al final de fitxer. Un patró d' eof independent també pot seguir el indicador -output , en aquest cas es combina si es detecta un eof mentre s'escriu la sortida. L'acció predeterminada és "tornar", de manera que interactuar només torna sobre qualsevol EOF.

El temps d'espera del patró introdueix un temps d'espera (en segons) i l'acció que s'executa després que no s'hagi llegit cap caràcter durant un temps determinat. El patró d' espera s'aplica al procés especificat més recentment. No hi ha un temps d'espera predeterminat. La variable especial "temps d'espera" (utilitzada per la comanda expect ) no afecta cap a aquest temps d'espera.

Per exemple, es podria utilitzar la següent instrucció per autologout usuaris que no hagin escrit res durant una hora, però que encara reben missatges freqüents del sistema:

interactuar-entrada $ user_spawn_id timeout 3600 return -output \ $ spawn_id

Si el patró és la paraula clau nul·la , i es permeten nul·les (a través de l'ordre remove_nulls ), s'executa el cos corresponent si es coincideix un ASCII 0 únic. No és possible fer coincidir 0 bytes a través de patrons globus o regexp.

Prefaciar un patró amb la marca -write fa que la variable interact_out (spawn_id) s'estableixi a spawn_id que coincideixi amb el patró (o eof).

Les accions com ara trencar i continuar provoquen estructures de control (és a dir, per a , proc ) comportar-se de la manera habitual. Tanmateix, la rendibilitat causa que l'interaccioni torni a la seva persona que truca, mentre que inter_return provoca que la interacció produeixi una devolució en la seva persona que truca. Per exemple, si "proc foo" anomenava interacció que després executava l'acció inter_return , proc foo tornaria. (Això vol dir que si interacciona l' intèrpret interactivament, escrivint retorn tornarà a continuar l'interacció, mentre que inter_return farà que l'interacció torni a la seva persona que truca).

Durant el mode interactiu , s'utilitza el mode cru per a que tots els caràcters es puguin passar al procés actual. Si el procés actual no capta senyals de control de treball, s'aturarà si s'envia un senyal de parada (per defecte ^ Z). Per reiniciar-lo, envieu un senyal de continuar (com per exemple "kill -CONT"). Si realment voleu enviar un SIGSTOP a un procés d'aquest tipus (per ^ Z), considereu primer la generació de csh i després executeu el vostre programa. D'altra banda, si voleu enviar un SIGSTOP a esperar , l'intèrpret de primera trucada (potser usant un personatge d'escapament) i, a continuació, premeu ^ Z.

Els parells de cos de cordes es poden utilitzar com a taquigrafia per evitar haver d'entrar al intèrpret i executar comandaments interactivament. El mode de terminal anterior s'utilitza mentre s'executa el cos d'un parell de cos de cadena.

Per a la velocitat, les accions s'executen en mode sense processar de manera predeterminada. El ressaltat de la bandera restablirà el terminal a la manera que tenia abans que es va executar l' interacció (invariablement, el mode cuinat). Tingueu en compte que els caràcters que es van introduir quan es commou el mode es poden perdre (una característica desafortunada del controlador de terminal en alguns sistemes). L'única raó per utilitzar- resoldre és si la vostra acció depèn de la seva execució en mode cuinat.

L'indicador -echo envia caràcters que coincideixen amb el següent patró al procés que els va generar a mesura que es llegeix cada caràcter. Això pot ser útil quan l'usuari necessita veure comentaris des dels patrons que s'utilitzen parcialment.

Si un patró es fa ressò però eventualment no coincideix, els caràcters s'envien al procés generat. Si el procés generat els fa ressò, l'usuari veurà els caràcters dues vegades. -echo és probable que només sigui apropiat en situacions en què l'usuari no pugui completar el patró. Per exemple, el següent extracte és de rftp, l'script recursive-ftp, on es demana a l'usuari que introdueixi ~ g, ~ p, o ~ l, per obtenir, posar o llistar el directori actual recursivament. Aquests estan tan allunyats de les ordres ftp normals, que és poc probable que l'usuari escrigui ~ seguit d'una altra cosa, excepte per error, en aquest cas, probablement simplement ignorareu el resultat de totes maneres.

interactueu {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}

L'indicador -nobuffer envia caràcters que coincideixen amb el següent patró en el procés de sortida a mesura que es llegeixen els caràcters.

Això és útil quan voleu que un programa faci retrocedir el patró. Per exemple, es pot utilitzar el següent per controlar on està marcant una persona (un mòdem d'estil Hayes). Cada vegada que es veu "atd", el script registra la resta de la línia.

proc lognumber {} {interact -nobuffer -re "(. *) \ r" return posa $ log "[format de rellotge [segells de rellotge]]: marcats $ interact_out (1, cadena)"} interactuen -nobuffer "atd" lognumber

Durant l' interacció , l'ús anterior de log_user s'ignora. En particular, interactuar obligarà a la seva sortida a ser registrada (enviada a la sortida estàndard) ja que es presumeix que l'usuari no vol interactuar a cegues.

La marca -o provoca que s'apliquin els següents parells de tecles i cos a la sortida del procés actual. Això pot ser útil, per exemple, quan es tracta de màquines que envien caràcters no desitjats durant una sessió de telnet.

Per defecte, interactuar espera que l'usuari escrigui stdin i que llegeixi el codi obert del procés de Expect . La bandera -u (per a "usuari") fa que l'usuari busqui l' interacció com el procés anomenat pel seu argument (que ha de ser un id generat).

Això permet unir dos processos no relacionats sense utilitzar un bucle explícit. Per ajudar a la depuració, esperar que els diagnòstics sempre passin a stderr (o estanc per a certa informació de registre i depuració). Per la mateixa raó, l'ordre de l' intèrpret llegirà de forma interactiva des de stdin.

Per exemple, el fragment següent crea un procés d' inici de sessió. A continuació, marca l'usuari (no es mostra) i, finalment, connecta els dos junts. Per descomptat, qualsevol procés pot ser substituït per iniciar sessió. Un intèrpret d'ordres, per exemple, permetria a l'usuari treballar sense subministrar un compte i contrasenya.

engega l'inici de sessió d'inici de sessió $ spawn_id spawn tip modem # marcar de nou a l'usuari # connectar l'usuari per iniciar la sessió interactua -u $ login

Per enviar una sortida a diversos processos, enumera cada llista d'identificació generada prèviament per un indicador -output . L'entrada per a un grup d'identificadors de generació de sortida pot estar determinada per una llista d'identificació generada per un indicador d'entrada. (Ambdós -putput i -output poden prendre llistes de la mateixa forma que la bandera -i en l'ordre expected, excepte que qualsevol_spawn_id no té sentit en interactuar .) Tots els següents banderins i cadenes (o patrons) s'apliquen a aquesta entrada fins que es produeixin altres - apareix l'indicador d'entrada. Si no hi ha cap input , -una entrada implica "-input $ user_spawn_id -output". (De la mateixa manera, amb patrons que no tenen -input .) Si s'especifica un input , reemplaça $ user_spawn_id. Si s'especifica una entrada de segon, inverteix $ spawn_id. Es poden especificar banderes d' entrada addicionals.

Els dos processos d'entrada implicats per defecte tenen les seves sortides especificades com $ spawn_id i $ user_spawn_id (en reversa). Si apareix un indicador d'entrada sense un indicador de sortida, es descarten els caràcters d'aquest procés .

La bandera -i introdueix un reemplaçament per a l'spawn_id actual quan no s'utilitzen cap altre indicador d'entrada o sortida . Una bandera -i implica una bandera-o.

És possible canviar els processos que s'estan interactuant amb els identificadors indirectes de generació. (Els identificadors de spawn indirecte es descriuen a la secció de la comanda expect.) Els identificadors indirectes de spawn es poden especificar amb els indicadors -i, -u, -input o -output.

intèrpret [args]
fa que l'usuari sigui interaccionat interactivament per als comandaments Expect i Tcl. S'imprimeix el resultat de cada comanda.

Les accions com ara trencar i continuar provoquen estructures de control (és a dir, per a , proc ) comportar-se de la manera habitual. Tanmateix, el retorn fa que l'intèrpret torni a la seva persona que truca, mentre que inter_return fa que l' intèrpret produeixi una tornada en la seva persona que truca. Per exemple, si "proc foo" s'anomena intèrpret que després executa l'acció inter_return , proc foo tornaria. Qualsevol altra ordre fa que l' intèrpret continuï demanant comandaments nous.

Per defecte, l'indicatiu conté dos enters. El primer enter descriu la profunditat de la pila d'avaluació (és a dir, quantes vegades s'ha anomenat Tcl_Eval). El segon enter és l'identificador de la història de Tcl. L'indicatiu es pot definir mitjançant la definició d'un procediment anomenat "prompt1", el valor de devolució es converteix en el següent indicador. Si una declaració té cometes obertes, parèntesis, claudàtors o claudàtors, un indicador secundari (per defecte "+>") s'emet a la nova línia. L'indicador secundari es pot definir mitjançant la definició d'un procediment anomenat "prompt2".

Durant l' intèrpret , s'utilitza el mode cuinat, fins i tot si la persona que truca està utilitzant el mode en brut.

Si stdin està tancat, l' intèrpret tornarà a menys que s'utilitzi la bandera, en aquest cas es invoca l'argument posterior.

log_file [args] [[-a] fitxer]
Si es proporciona un nom de fitxer, log_file registrarà una transcripció de la sessió (començant en aquest punt) al fitxer. log_file deixarà de gravar si no es dóna cap argument. Qualsevol fitxer de registre anterior està tancat.

En lloc d'un nom de fitxer, es pot proporcionar un identificador de fitxer Tcl utilitzant els indicadors -open o -leaveopen . Això és similar al comandament de spawn . (Vegeu spawn per obtenir més informació.)

El directori -a obliga a la sortida a registrar que ha estat suprimit per l'ordre log_user .

De manera predeterminada, la comanda log_file s'uneix als fitxers anteriors en comptes de truncar-los, per la comoditat de poder activar el registre i en diverses ocasions en una sessió. Per truncar fitxers, utilitzeu l'indicador -noappend .

El indicador -info fa que el log_file retorni una descripció dels arguments no informatius més recents donats.

log_user-info | 0 | 1
Per defecte, el diàleg enviar / esperar es registra a stdout (i un fitxer de registre si està obert). El registre a l'estoc està desactivat per l'ordre "log_user 0" i es torna a activar per "log_user 1". El registre al fitxer de registre no canvia.

El indicador -info fa que log_user retorni una descripció dels arguments no informatius més recents donats.

match_max [-d] [-i spawn_id] [size]
defineix la mida del buffer (en bytes) que s'utilitza internament per esperar . Sense cap argument de mida , es torna la mida actual.

Amb l'indicador -d , s'estableix la mida predeterminada. (El valor predeterminat inicial és 2000.) Amb el símbol -i , la mida està establerta per a l'id. Generada de generació, en cas contrari s'estableix per al procés actual.

superposició [- # spawn_id] [- # spawn_id] [...] programa [args]
executa " args del programa " en lloc del programa Expect actual, que finalitza. Un argument de guions nets obliga a un guionet al davant del nom de l'ordre com si es tractés d'un intèrpret d'ordres d'inici de sessió. Tots els spawn_ids estan tancats excepte els anomenats arguments. Aquests es mapegen en els identificadors de fitxers amb nom.

Spawn_ids està mapejat per identificar els identificadors del nou programa per heretar. Per exemple, la següent línia executa escacs i permet controlar-la pel procés actual, per exemple, un mestre d'escacs.

superposició -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id escacs

Això és més eficient que "interactuar-u", però, sacrifica la capacitat de fer la interacció programada, ja que el procés de Expect ja no controla.

Tingueu en compte que no es proporciona cap terminal de control. D'aquesta manera, si desconnecta o reapareix l'entrada estàndard, els programes que fan el control del treball (petxines, inici de sessió, etc.) no funcionaran correctament.

paritat [-d] [-i spawn_id] [valor]
defineix si la paritat s'ha de conservar o eliminar de la sortida dels processos generats. Si el valor és zero, la paritat es desposseirà, en cas contrari no es desposseirà. Sense argument de valor , es torna el valor actual.

Amb l'indicador -d , s'estableix el valor de paritat predeterminat. (El valor inicial per defecte és 1, és a dir, la paritat no es desposseeix). Amb el símbol -i , el valor de paritat s'estableix per a l'identificador de spa generat, en cas contrari s'estableix per al procés actual.

remove_nulls [-d] [-i spawn_id] [value]
defineix si els nul·les es mantenen o s'eliminen de la sortida dels processos generats abans de fer coincidir el patró o emmagatzemar-se a la variable expect_out o interact_out . Si el valor és 1, els nuls són eliminats. Si el valor és 0, els nuls no s'eliminen. Sense argument de valor , es torna el valor actual.

Amb l'indicador -d , s'estableix el valor predeterminat. (El valor predeterminat inicial és 1, és a dir, els nuls són eliminats). Amb el símbol -i , el valor s'estableix per a l'id. Generat de generació, en cas contrari s'estableix per al procés actual.

Si s'eliminen o no nuls, es preveu que gravi nuls bytes al registre i a l'estoc.

envieu [-flags] cadena
Envia el cadena al procés actual. Per exemple, l'ordre

envia "hola món \ r"

envia els caràcters, helloworld al procés actual. (Tcl inclou una ordre like- printf ( format anomenat) que pot generar cadenes complexes arbitràriament).

Els caràcters s'envien immediatament, tot i que els programes amb entrada amb buffer de línia no llegiran els caràcters fins que no s'enviïn un caràcter de retorn. Es denota un caràcter de retorn "\ r".

La " bandera" obliga al següent argument a interpretar-se com una cadena en lloc d'una bandera. Qualsevol cadena pot anar precedida per "-" si realment es veu com una bandera. Això proporciona un mecanisme fiable per especificar les cadenes de variables sense que siguin interferits per aquells que accidentalment es veuen com a banderes. (Totes les cadenes que comencen per "-" estan reservades per a futures opcions.)

La bandera -i declara que la cadena s'envia a spawn_id. Si el spawn_id és user_spawn_id , i el terminal està en mode brut, les línies noves de la cadena es tradueixen a seqüències return-newline perquè apareguin com si el terminal estigués en mode cuinat. La marca -raw desactiva aquesta traducció.

L'indicador simple envia caràcters nuls (0 bytes). De manera predeterminada, s'envia un nul. Un enter pot seguir el -null per indicar quants nul·les voleu enviar.

El marcador -break genera un estat de ruptura. Això només té sentit si l'id de generació es refereix a un dispositiu tty obert a través de "spawn-opens". Si heu engendrat un procés com ara un consell, heu d'utilitzar la convenció de la punta per generar un descans.

La bandera de -s força a la sortida per a enviar-la "lentament", per la qual cosa eviteu la situació comuna en què una computadora desempaqueta un buffer d'entrada dissenyat per a un ésser humà que no superaria mai la mateixa memòria intermèdia . Aquesta sortida es controla pel valor de la variable "send_slow" que porta una llista de dos elements. El primer element és un enter que descriu la quantitat de bytes a enviar atòmicament. El segon element és un número real que descriu el nombre de segons pels quals l'enviament atòmic s'ha de separar. Per exemple, "set send_slow (10 .001)" obligaria a "enviar-s" a enviar cadenes amb 1 mil·lisegon entre cada 10 caràcters enviats.

La bandera -h força la sortida a ser enviada (una miqueta) com una persona en realitat escrivint. Es mostren retards entre humans entre els personatges. (L'algoritme es basa en una distribució de Weibull, amb modificacions que s'adapten a aquesta aplicació particular). Aquesta sortida es controla pel valor de la variable "send_man" que porta una llista d'cinc elements. Els dos primers elements són temps mitjà de caràcter interreligiós de caràcters en segons. El primer s'utilitza per defecte. El segon s'utilitza en termes de paraules, per simular les pauses subtils que ocasionalment es produeixen en aquestes transicions. El tercer paràmetre és una mesura de variabilitat on .1 és força variable, 1 és raonablement variable i 10 és força invariable. Els extrems són 0 fins a l'infinit. Els dos últims paràmetres són, respectivament, un temps interarrival mínim i màxim. El mínim i el màxim s'utilitzen per última vegada i "clip" l'última vegada. La mitjana final pot ser bastant diferent de la mitjana donada si el valor mínim i màxim és suficient.

Com a exemple, el següent comandament emula un mecanisme ràpid i consistent:

configure send_human {.1 .3 1 .05 2} enviar -h "tinc gana, anem a dinar".

mentre que el següent podria ser més adequat després d'una ressaca:

configure send_human {.4 .4 .2 .5 100} enviar-h "Goodd party lash night!"

Tingueu en compte que els errors no es simulen, tot i que podeu configurar situacions de correcció d'errors per incrustar errors i correccions en un argument d'enviament.

Les banderes per a l'enviament de caràcters nuls, per a l'enviament de pauses, per obligar a la sortida lenta i per a la producció d'estil humà són excloents mútuament. Només s'utilitzarà el que s'hagi especificat. A més, no es pot especificar cap argument de cadena amb les banderes per a l'enviament de caràcters nuls o interrupcions.

És una bona idea precedir el primer enviament a un procés per l' esperança . Esperem esperar que el procés comenci, mentre que l' enviament no es pot fer. En particular, si el primer enviament finalitza abans que el procés comenci a funcionar, corre el risc que les dades s'ignorin. En situacions en què els programes interactius no ofereixen un missatge inicial, pot precedir l' enviament per un retard com en:

# Per evitar donar consells als pirates informàtics sobre com interrompre, # aquest sistema no sol·licita una contrasenya externa. # Espereu durant 5 segons per executar per completar el telnet generat very.secure.gov el so 5 envieu la contrasenya \ r

exp_send és un àlies per enviar. Si esteu utilitzant Expectk o alguna altra variant d'Expect en l'entorn Tk, Tk defineix l' enviament per a un propòsit completament diferent. Exp_send es proporciona per a la compatibilitat entre entorns. S'ofereixen àlies similars per a altres comandaments d'enviament de l'Expect.

send_error [-flags] string
és com enviar , excepte que la sortida s'envia a stderr en lloc del procés actual.

enviar_log [-] cadena
és com enviar , excepte que la cadena només s'envia al fitxer de registre (vegeu log_file ). Els arguments s'ignoren si no hi ha cap fitxer de registre obert.

enviar_tty [-flags] cadena
és com enviar , excepte que la sortida s'envia a / dev / tty en comptes del procés actual.

enviar_usuari [-flags] cadena
és com enviar , excepte que la sortida s'envia a stdout en lloc del procés actual.

dormir segons
fa que el guió s'adormi durant un nombre de segons determinat. Els segles poden ser un nombre decimal. Les interrupcions (i esdeveniments Tk si esteu utilitzant Expectk) es processen mentre s'espera dormir.

engendra [args] programa [args]
crea un nou procés que executa " args del programa ". El seu stdin, stdout i stderr estan connectats a Expect, perquè puguin ser llegits i escrits per altres comandaments de Expect . La connexió es trenca amb el tancament o si el procés tanca qualsevol dels identificadors de fitxers.

Quan s'inicia un procés per generar , la variable spawn_id s'estableix en un descriptor que fa referència a aquest procés . El procés descrit per spawn_id es considera el " procés actual ". spawn_id es pot llegir o escriure, en efecte, proporciona control de feina.

user_spawn_id és una variable global que conté un descriptor que fa referència a l'usuari. Per exemple, quan spawn_id està establert en aquest valor, s'espera que es comporti com expect_user .

.I error_spawn_id és una variable global que conté un descriptor que fa referència a l'error estàndard. Per exemple, quan spawn_id està establert en aquest valor, l' enviament es comporta com send_error .

tty_spawn_id és una variable global que conté un descriptor que fa referència a / dev / tty. Si / dev / tty no existeix (com en un script cron, at, o batch), llavors tty_spawn_id no està definit. Això es pot provar com:

si {{info vars tty_spawn_id]} {# / dev / tty existeix} else {# / dev / tty no existeix # probablement en cron, batch o script}

spawn torna l'ID del procés UNIX. Si no es genera cap procés , es retorna 0. La variable spawn_out (esclau, nom) està establerta en el nom del dispositiu esclau pty.

De manera predeterminada, spawn fa ressò del nom i arguments de la comanda. La bandera -noecho s'atura per fer-ho.

La bandera del console fa que la sortida de la consola sigui redirigida al procés generat. Això no és compatible amb tots els sistemes.

Internament, spawn utilitza un pty, inicialitzat de la mateixa manera que el tty de l'usuari. Això s'inicialitza addicionalment perquè totes les configuracions siguin "correctes" (d'acord amb stty (1)). Si la variable stty_init està definit, s'interpreta a l'estil dels arguments stty com a configuració addicional. Per exemple, "set stty_init raw" farà que els terminals dels processos generats s'iniciïn en mode sense processar. -Nottycopy omet la inicialització basada en el tty de l'usuari. -nottyinit supera la inicialització "sana".

Normalment, el spawn triga poc temps a executar-se. Si observeu que genera una quantitat considerable de temps, és probable que trobi ptys que estiguin enganxats. S'han executat diverses proves en ptys per evitar enredaments amb processos errants. (Aquests triguen 10 segons per pty wedged). Executar Expect amb l'opció -d mostrarà si s'espera trobar molts pty en estats senars. Si no podeu matar els processos als quals estan associats aquests pty, és possible que el vostre únic recurs sigui reiniciar-se.

Si el programa no es pot generar correctament perquè exec (2) falla (per exemple, quan el programa no existeix), el missatge d'error es retornarà per la propera comanda interactiva o esperada com si s'hagués executat el programa i que generés el missatge d'error com a sortida. Aquest comportament és una conseqüència natural de la implementació de la generació . Internament, es genera forks, després de la qual cosa el procés generat no té cap forma de comunicar-se amb el procés original de Expect , excepte per la comunicació a través de spawn_id.

La marca -open obre el següent argument per interpretar-se com un identificador de fitxer Tcl (és a dir, retornat per obert .) L'id de generació pot utilitzar-se com si fos un procés generat. (L'identificador de fitxer ja no s'ha d'utilitzar.) Això us permet tractar els dispositius sense processar, els fitxers i les canonades com a processos generats sense utilitzar un pty. Es torna 0 per indicar que no hi ha cap procés associat. Quan es tanca la connexió al procés generat, també ho és l'identificador de fitxer Tcl. La bandera -leaveopen és similar a -open, excepte que -leaveopen fa que l'identificador de fitxer sigui obert fins i tot després de tancar l'id. De generació.

La bandera buida provoca que s'obri un pty, però no es genera cap procés . Es torna 0 per indicar que no hi ha cap procés associat. Spawn_id s'estableix com de costum.

La variable spawn_out (esclau, fd) està establerta en un identificador de fitxer corresponent a l'esclau pty. Es pot tancar amb "close -slave".

El -ignore flag nomena un senyal que s'ha d'ignorar en el procés generat. En cas contrari, els senyals obtenen el comportament predeterminat. Les senyals es nomenen com a comandaments de trampa , excepte que cada senyal requereix un indicador independent.

nivell d'estret
fa que s'imprimeixin les declaracions abans d'executar-se. (Les restriccions de traça de la comanda de seguiment de Tcl). El nivell indica el nivell de baixada de la pila de trucades. Per exemple, s'executa la següent ordre Expectant mentre es tracen els primers 4 nivells de trucades, però cap d'a sota.

espera -c "script 4 de strace" .exp

El indicador -info fa que l' estret torni una descripció dels arguments no informatius més recents donats.

Stty args
canvia els modes de terminal de manera similar a la comanda stty externa.

Per defecte, s'accedeix al terminal de control. Es pot accedir a altres terminals afegint "Sol·licituds d'estat retornar-lo com a resultat de la comanda. Si no es demana cap estatut i s'accedeix al terminal de control, l'estat anterior dels atributs de resum i de retorn es tornen en un formulari que pot ser posteriorment utilitzat per la comanda.

Per exemple, els arguments raw o -cooked posen el terminal en mode brut. Els arguments -monts o cuits- posen el terminal en mode cuinat. Els arguments d' eco i -cho posen el terminal en mode de ressò i de soroll, respectivament.

El següent exemple mostra com desactivar temporalment l'eco. Això es podria utilitzar en scripts automàticament per evitar incrustar-hi les contrasenyes. (Vegeu més discussions sobre això a EXPECT HINTS a continuació).

stty -echo send_user "Contrasenya:" expect_user -re "(. *) \ n" configureu la contrasenya $ expected_out (1, string) echo estanc

sistema args
dóna arguments a sh (1) com a entrada, tal com si s'hagués escrit com a comandament des d'un terminal. Esperi esperar fins que finalitzi la closca. L'estat de retorn de sh es gestiona de la mateixa manera que exec gestiona el seu estat de retorn.

A diferència d' exec que redirigeix ​​stdin i stdout al script, el sistema no realitza cap redirecció (a part del que indica la pròpia cadena). Per tant, és possible utilitzar programes que han de parlar directament amb / dev / tty. Pel mateix motiu, els resultats del sistema no es registren al registre.

marca de temps [args]
torna una marca de temps. Sense arguments, es torna el nombre de segons des de l'època.

L'indicador -format introdueix una cadena que es torna però amb substitucions realitzades d'acord amb les regles POSIX per a la resta de temps. Per exemple,% a és reemplaçat per un nom abreviat del dia de la setmana (és a dir, Sat). Altres són:

% un nom del dia de la setmana abreujat% Un nom del dia de la setmana complet% b abreviat el nom del mes% B el nombre del mes complet% c data-hora com a: dc 6 d'octubre 11:45:56 1993% d dia del mes (01-31% H hora (00-23)% I hora (01-12)% j dia (001-366)% m mes (01-12)% M minuts (00-59)% p am o pm% S segon (00-61) % u dia (1-7, el dilluns és el primer dia de la setmana)% U setmanes (00-53, primer diumenge primer dia de la setmana)% V setmana (01-53, estil ISO 8601)% w dia (0- 6)% W setmana (00-53, primer dilluns és el primer dia de la primera setmana)% x data d'inici com a: Dim Oct 6 1993% X temps com a: 23:59:59% i any (00-99) % Y any com en: 1993% Z horari (o res si no determinable) %% un signe de percentatge desglossat

Hi ha altres% de especificacions no definides. Altres caràcters es passaran sense interacció. Només s'admet la configuració regional de C.

El segell d'inscripcions segueix uns segons des de l'època que s'utilitzarà com a font des del qual es pot formatar. En cas contrari, s'utilitza el temps actual.

El pavelló- GMT força la sortida de marca de temps per utilitzar la zona horària GMT . Sense bandera, s'utilitza la zona horària local.

trampa senyals [[comandament]]
fa que s'executi la comanda donada a la recepció futura de qualsevol de les senyals donades. La comanda s'executa en l'àmbit global. Si l' ordre està absent, es torna l'acció del senyal. Si l' ordre és la cadena SIG_IGN, s'ignoren els senyals. Si l' ordre és la cadena SIG_DFL, els senyals resulten a la configuració predeterminada del sistema. Els senyals són un senyal únic o una llista de senyals. Les senyals es poden especificar numèricament o simbòlicament segons el senyal (3). Es pot ometre el prefix "SIG".

Sense arguments (o l'argument -número), la trampa retorna el nombre de senyal de la comanda trampa que s'està executant.

El codi-codi utilitza el codi de retorn de la comanda en lloc del codi que Tcl estigui a punt de tornar quan la comanda es va començar a executar originalment.

El indicador -interp fa que l'ordre sigui avaluat utilitzant l'intèrpret actiu en el moment en què la comanda es va començar a executar en comptes de quan es va declarar la trampa.

El nom-nom fa que l'ordre trampa retorni el nom del senyal de la comanda trampa que s'està executant.

El indicador -max fa que l'ordre trampa retorni el número de senyal més gran que es pot establir.

Per exemple, l'ordre "trap {send_user" Ouch! "} SIGINT" imprimirà "Ouch!" cada vegada que l'usuari preme ^ C.

Per defecte, SIGINT (que generalment es pot generar prement ^ C) i SIGTERM provoca que s'espera sortir. Això es deu a la següent trampa, creada per defecte quan s'inicia Esperar.

sortida de trampa {SIGINT SIGTERM}

Si utilitzeu el pavelló -D per iniciar el depurador, SIGINT es redefineix per iniciar el depurador interactiu. Això es deu a la següent trampa:

trampa {exp_debug 1} SIGINT

La trampa del depurador es pot canviar establint la variable d'entorn EXPECT_DEBUG_INIT en una nova ordre de trampa.

Podeu, per descomptat, anul·lar-ne ambdós afegint ordres de trampa al vostre script. En particular, si teniu la vostra pròpia "sortida de trampa SIGINT", això anul·larà la trampa del depurador. Això és útil si voleu evitar que els usuaris arribin al depurador.

Si voleu definir la vostra pròpia trampa en SIGINT però encara atrapar al depurador quan s'estigui executant, utilitzeu:

si {! [exp_debug]} {trap mystuff SIGINT}

D'altra banda, podeu atrapar al depurador mitjançant un altre senyal.

la trampa no us permetrà substituir l'acció de SIGALRM ja que s'utilitza internament per esperar . La comanda de desconexió estableix SIGALRM a SIG_IGN (ignora). Podeu tornar a activar-lo sempre que ho desactiveu durant els següents comandaments de generació.

Consulteu el senyal (3) per obtenir més informació.

espera [args]
es retarda fins que finalitza un procés generat (o el procés actual si no n'ha nomenat cap).

espereu normalment retorna una llista de quatre enters. El primer enter és el pid del procés que s'ha esperat. El segon sencer és l'id. De generació corresponent. El tercer enter és -1 si s'ha produït un error en el sistema operatiu, o 0 en cas contrari. Si el tercer enter era 0, el quart integer és l'estat retornat pel procés generat. Si el tercer enter era -1, el quart integer és el valor de errno definit pel sistema operatiu. També s'estableix la variable global errorCode.

Els elements addicionals poden aparèixer al final del valor retornat d' esperar . Un cinquè element opcional identifica una classe d'informació. Actualment, l'únic valor possible per a aquest element és CHILDKILLED, en aquest cas els dos valors següents són el nom del senyal d'estil C i una breu descripció textual.

La bandera -i declara el procés d'espera corresponent a l'spawn_id anomenat (NO l'identificador del procés ). A l'interior d'un controlador SIGCHLD, és possible esperar un procés generat utilitzant el spawn id -1.

El indicador -nowait fa que l'espera torni immediatament amb la indicació d'una espera exitosa. Quan el procés surt (més endavant), desapareixerà automàticament sense necessitat d'una espera explícita.

L'ordre wait també es pot utilitzar esperar per un procés bifurcat utilitzant els arguments "-i -1". A diferència del seu ús amb processos generats, aquesta ordre es pot executar en qualsevol moment. No hi ha cap control sobre el procés que es coseixi. Tanmateix, es pot comprovar el valor retornat de l'id del procés .

BIBLIOTEQUES

Espereu que es coneix automàticament sobre dues biblioteques integrades per a les seqüències d'ordres Expect. Aquests són definits pels directoris anomenats a les variables exp_library i exp_exec_library. Ambdós estan destinats a contenir fitxers d'utilitat que poden ser utilitzats per altres scripts.

exp_library conté fitxers independents d'arquitectura. exp_exec_library conté fitxers dependents de l'arquitectura. Depenent del vostre sistema, els dos directoris poden estar totalment buits. L'existència del fitxer $ exp_exec_library / cat-buffers descriu si els buffers de bin / cat s'utilitzen per defecte.

PRETTY-PRINTING

Hi ha disponible una definició de vgrind per a la impressió de guions de guions bastant bonics. Si suposem que la definició de vgrind subministrada amb la distribució Expect està correctament instal·lada, podeu utilitzar-la com a:

vgrind-arxiu flexible

EXEMPLES

Molts no són aparents com posar tot el que la pàgina de l' home descriu. Us animo a llegir i provar els exemples del directori d'exemple de la distribució Expect . Alguns d'ells són programes reals. Uns altres són simplement il·lustratius de certes tècniques i, per descomptat, una parella són només hacks ràpids. El fitxer INSTALL té una visió general ràpida d'aquests programes.

Els documents Expect (veure VEURE TAMBÉ) també són útils. Tot i que alguns documents utilitzen la sintaxi corresponent a les versions anteriors de Expect, les racionalitats que acompanyen segueixen sent vàlides i s'introdueixen en molt més detall que la pàgina d'aquest home.

CAVEATS

Les extensions poden col·lisionar amb els noms de comandaments d'Expect. Per exemple, Tk defineix l' enviament per un propòsit completament diferent. Per aquest motiu, la majoria dels comandaments Expect també estan disponibles com a "exp_XXXX". Les ordres i les variables que comencen per "exp", "inter", "spawn" i "timeout" no tenen àlies. Utilitzeu els noms d'ordre ampliats si necessiteu aquesta compatibilitat entre entorns.

Esperem que tingui una visió més aviat liberal de l'abast. En particular, es buscaran les variables llegides per comandaments específics del programa Expect , primer de l'àmbit local i, si no es troben, en l'àmbit global. Per exemple, això evita la necessitat de col·locar el "temps d'espera global" en tots els procediments que escriviu que usi espera . D'altra banda, les variables escrites sempre estan en l'àmbit local (a menys que s'hagi emès un comandament "global"). El problema més comú que això comporta és quan el spawn s'executa en un procediment. Fora del procediment, spawn_id ja no existeix, de manera que el procés generat ja no és accessible simplement per l'abast. Afegiu un "spawn_id global" a aquest procediment.

Si no podeu habilitar la capacitat de multispawning (és a dir, el vostre sistema no admet cap selecció (BSD *. *), Enquesta (SVR> 2), ni una cosa equivalent), Expect només serà capaç de controlar un sol procés a la vegada. En aquest cas, no intenteu definir spawn_id , ni heu d'executar processos a través d'exec mentre s'està executant un procés generat. A més, no podrà esperar de múltiples processos (inclòs l'usuari com un) al mateix temps.

Els paràmetres del terminal poden tenir un gran efecte en les seqüències d'ordres. Per exemple, si s'escriu un script per buscar ressò, es comportarà de forma incorrecta si la ressonància està desactivada. Per aquest motiu, Expect força els paràmetres terminals sans per defecte. Lamentablement, això pot fer que les coses siguin desagradables per a altres programes. Com a exemple, l'intèrpret d'emacs vol canviar les assignacions "habituals": les línies noves es mapegen a les línies noves en comptes de les línies noves de retorn de carro i el ressò està desactivat. Això permet utilitzar emacs per editar la línia d'entrada. Desafortunadament, espereu que això no és possible.

Podeu demanar que s'espera que no anul·li la configuració predeterminada dels paràmetres del terminal, però, aleshores, cal tenir molta cura en escriure scripts per a aquests entorns. En el cas dels emacs, eviteu depenent de coses com fer ressò i assignacions de final de línia.

Les ordres que accepten els arguments es van incloure en una única llista (les variants d' expectatives i interactuen ) utilitzen una heurística per decidir si la llista és en realitat un argument o molts. L'heurística només pot fallar en el cas en què la llista realment representa un únic argument que té diversos caràcters no integrats entre ells. Això sembla prou inverosímil, però l'argument "-nobrace" pot ser utilitzat per obligar a un sol argument a tractar-se com un únic argument. Això podria ser concebible amb el codi Expect generat per la màquina. De la mateixa manera, -brace obliga a un únic argument a ser manejat com múltiples patrons / accions.

ERRORS

Va ser realment temptador anomenar el programa "sexe" (ja sigui per a "Smart EXec" o "Send-Expect"), però va prevaler el bon sentit (o potser el puritanisme).

En alguns sistemes, quan es genera un intèrpret d'ordres, es queixa de no poder accedir al tty, però s'executa de totes maneres. Això significa que el vostre sistema té un mecanisme per obtenir el controlador que Expect no coneix. Descobriu què és i envieu-me aquesta informació.

Ultrix 4.1 (almenys les darreres versions al voltant) considera que els temps d'espera de més de 1000000 equivalen a 0.

Digital UNIX 4.0A (i probablement altres versions) es nega a assignar pty si defineix un controlador SIGCHLD. Consulteu la pàgina de la beca per obtenir més informació.

IRIX 6.0 no controla els permisos de pty correctament, de manera que si s'espera assignar un pty anteriorment usat per una altra persona, es produeix un error. Actualització a IRIX 6.1.

Telnet (verificat només sota SunOS 4.1.2) es bloqueja si no s'estableix TERM. Aquest és un problema amb els scripts cron, at i in cgi, que no defineixen TERM. Per tant, heu d'establir-lo explícitament: per quin tipus sol ser irrellevant. Només cal fixar-se en alguna cosa. El següent és probablement suficient per a la majoria dels casos.

config env (TERM) vt100

Consell (verificat només sota BSDI BSD / OS 3.1 i386) es bloqueja si SHELL i HOME no estan configurats. Aquest és un problema en scripts cron , at i in cgi , que no defineixen aquestes variables d'entorn. Per tant, heu d'establir-los explícitament: per quin tipus sol ser irrellevant. Només cal fixar-se en alguna cosa. El següent és probablement suficient per a la majoria dels casos.

config env (SHELL) / bin / sh set env (HOME) / usr / local / bin

Algunes implementacions de pty estan dissenyades de manera que el nucli elimina qualsevol sortida no llegida després de 10 a 15 segons (el nombre real dependrà de la implementació) després que el procés hagi tancat el descriptor de fitxer. Així, espereu programes com

genera la data de son 20 espera

fallarà. Per evitar això, invoca programes no interactius amb exec en lloc de generar . Si bé aquestes situacions són concebibles, en la pràctica mai he trobat una situació en què es perdria la producció final d'un programa realment interactiu a causa d'aquest comportament.

D'altra banda, les unitats Cray UNICOS eliminen qualsevol sortida sense llegir immediatament després que el procés hagi tancat el descriptor de fitxer. Ho he informat a Cray i estan treballant en una solució.

De vegades, es requereix un retard entre un missatge ràpid i una resposta, com quan una interfície tty està canviant la configuració de UART o les taxes de baudas coincidents buscant els bits d'inici i de parada. En general, tot això requereix és dormir durant un segon o dos. Una tècnica més sòlida és tornar a intentar fins que el maquinari estigui preparat per rebre entrades. El següent exemple utilitza dues estratègies:

envieu "velocitat 9600 \ r"; espera 1 espera {temps d'espera {enviar "\ r"; exp_continue} $ prompt}

El codi de trampa no funcionarà amb cap comanda que es trobi en el bucle d'esdeveniments de Tcl, com ara el son. El problema és que en el bucle d'esdeveniments, Tcl descarta els codis de retorn dels controladors d'esdeveniments asíncrons. Una solució és establir una bandera en el codi de trampa. A continuació, marqueu la bandera immediatament després de la comanda (és a dir, dormir).

La comanda expect_background ignora els arguments de temps i no té cap concepte de temps d'espera en general.

& # 34; EXPECT HINTS & # 34;

Hi ha un parell de coses sobre Esperar que no siguin intuïtives. Aquesta secció intenta abordar algunes d'aquestes coses amb un parell de suggeriments.

Un problema d'espera comú és com reconèixer avisos de shell. Atès que aquestes es personalitzen de manera diferent per persones de manera diferent i amb diferents intèrprets, l'automatització automàtica de rlogin pot ser difícil sense conèixer l'indicatiu. Una convenció raonable és que els usuaris emmagatzemen una expressió regular que descrigui el seu prompt (en particular, el final d'aquest) a la variable d'entorn EXPECT_PROMPT. Es pot utilitzar codi com el següent. Si EXPECT_PROMPT no existeix, el codi encara té moltes possibilitats de funcionar correctament.

set prompt "(% | # | \\ $) $"; # catch prompt prompt (config set $ env (EXPECT_PROMPT)) expect -re $ prompt

Us animo a escriure patrons d' esperança que incloguin el final del que espereu veure. Això evita la possibilitat de respondre una pregunta abans de veure tot. A més, si bé podeu respondre preguntes abans de veure'ls completament, si responeu primerencament, la vostra resposta pot aparèixer a la meitat de la pregunta. Dit d'una altra manera, el diàleg resultant serà correcte però es veurà revocat.

La majoria de les instruccions inclouen un caràcter d'espai al final. Per exemple, l'indicador de ftp és 'f', 't', 'p', '>' i. Per fer coincidir aquest missatge, heu de tenir en compte cadascun d'aquests caràcters. És un error comú no incloure l'espai en blanc. Posi el blanc explícitament.

Si utilitzeu un patró del formulari X *, el * coincideix amb la totalitat de la sortida rebuda del final de X a l'última cosa rebuda. Això sembla intuïtiu, però pot ser una mica confús perquè la frase "última cosa rebuda" pot variar depenent de la velocitat de l'ordinador i del processament de les E / S tant pel nucli com pel controlador del dispositiu.

En particular, els humans tendeixen a veure la sortida del programa arribant a grans trossos (atòmicament) quan, en realitat, la majoria de programes produeixen una línia de sortida a la vegada. Si se suposa que aquest és el cas, el * en el patró del paràgraf anterior només pot coincidir amb el final de la línia actual, tot i que sembla haver-hi més, ja que en el moment de la partida era tota la sortida que s'havia rebut.

Esperem que no hi hagi cap manera de saber que hi surten més resultats, tret que el vostre patró ho expliqui específicament.

Fins i tot, depenent del buffering orientat a la línia, és imprudent. No només els programes rarament fan promeses sobre el tipus de buffering que fan, però la indigestió del sistema pot trencar les línies de sortida perquè les línies es trenquin en llocs aparentment aleatoris. Per tant, si podeu expressar els darrers caràcters d'un indicador quan escriviu patrons, és convenient fer-ho.

Si esteu esperant un patró en l'última sortida d'un programa i el programa emeti una altra cosa, no podreu detectar-ho amb la paraula clau de temps d'espera . La raó és que esperem que no s'acabi el temps d'espera, sinó que obtindrà una indicació eof . Utilitza això en el seu lloc. Encara millor, utilitzeu tots dos. D'aquesta manera si aquesta línia sempre es mou, no haurà d'editar la línia en si mateixa.

Les línies noves normalment es converteixen en retorn de carro, seqüències de línia de sortida quan surten el controlador del terminal. Per tant, si voleu un patró que coincideixi explícitament amb les dues línies, de, per exemple, printf ("foo \ nbar"), haureu d'usar el patró "foo \ r \ nbar".

Una traducció similar es produeix quan es llegeix l'usuari, a través d' expect_user . En aquest cas, quan premeu Retorn, es traduirà a una línia nova. Si expect , passa a un programa que estableix el seu terminal en mode brut (com telnet), hi haurà un problema, ja que el programa espera un retorn veritable. (Alguns programes són realment indulgents perquè automàticament tradueixen línies noves a les devolucions, però la majoria no ho fan). Desafortunadament, no hi ha manera de descobrir que un programa posi el seu terminal en mode brut.

En lloc de substituir manualment les línies noves amb retorns, la solució és utilitzar la comanda "stty raw", que aturarà la traducció. Tingueu en compte, però, que això significa que ja no obtindreu les funcions d'edició de línies cuites.

interactua implícitament, estableix el vostre terminal en mode brut perquè no sorgeixi aquest problema.

Sovint és útil emmagatzemar contrasenyes (o altra informació privada) a Expect scripts. Això no es recomana perquè qualsevol cosa emmagatzemada en un ordinador és susceptible de ser accessible per qualsevol persona. D'aquesta manera, provocar de manera interactiva les contrasenyes d'un script és una idea més intel·ligent que no pas inserir-les literalment. No obstant això, de vegades aquesta incrustació és l'única possibilitat.

Malauradament, el sistema de fitxers UNIX no té cap manera directa de crear scripts que siguin executables, però que no es puguin llegir. Els sistemes que admeten les seqüències d'ordres setgid shell poden simular-ho de manera indirecta de la manera següent:

Creeu l'script Expect (que conté les dades secretes) com de costum. Feu que els seus permisos siguin 750 (-rwxr-x ---) i siguin propietat d'un grup de confiança, és a dir, un grup que pugui llegir-lo. Si cal, creeu un grup nou per a aquest propòsit. A continuació, creeu un script / bin / sh amb permisos 2751 (-rwxr-s - x) propietat del mateix grup que abans.

El resultat és un script que pot ser executat (i llegit) per qualsevol persona. Quan s'invoca, executa l'script de Expect .

& # 34; VEURE TAMBÉ & # 34;

Tcl (3), libexpect (3)
"Explorant l'esperança: un kit d'eines basat en Tcl per a l'automatització de programes interactius" de Don Libes, pp. 602, ISBN 1-56592-090-2, O'Reilly and Associates, 1995.
"espera: guarir aquells accessos incontrolables d'interactivitat" de Don Libes, Actes de la conferència USENIX d'estiu de 1990, Anaheim, Califòrnia, del 11 al 15 de juny de 1990.
. "Utilitzant l' esperança per automatitzar les tasques d'administració del sistema" de Don Libes, procediments de la Conferència d'Administració de sistemes d'instal·lació de USENIX de 1990, Colorado Springs, Colorado, del 17 al 19 d'octubre de 1990.
. "Tcl: Un llenguatge de comandament integrat" de John Ousterhout, Actes de la conferència USENIX d'hivern 1990, Washington, DC, del 22 al 26 de gener de 1990. "Espero: scripts per controlar programes interactius" de Don Libes, Sistemes Informàtics , Vol. 4, núm. 2, Revistes de premsa de la Universitat de Califòrnia, novembre de 1991. "Proves de regressió i programes d'avaluació de la conformitat per a programes interactius", a càrrec de Don Libes, Actes de la Conferència USENIX de l'estiu de 1992, pp. 135-144, San Antonio, TX, 12-15 de juny de 1992. "Kibitz - Connectant diversos programes interactius junts", de Don Libes, Programari - Pràctica i experiència, John Wiley & Sons, West Sussex, Anglaterra, Vol.

23, N ° 5, maig de 1993. "Depurador per a aplicacions Tcl", de Don Libes, Actes del Taller Tcl / Tk de 1993, Berkeley, CA, del 10 al 11 de juny de 1993.

AUTOR

Don Libes, Institut Nacional d'Estàndards i Tecnologia

AGRAÏMENTS

Gràcies a John Ousterhout per Tcl, i Scott Paisley per inspiració. Gràcies a Rob Savoye per al codi d'autoconfiguració d'Expect.

L'arxiu de HISTÒRIA documenta bona part de l'evolució de l' esperança . Fa una lectura interessant i pot donar-li més informació sobre aquest programari. Gràcies a les persones esmentades que em van enviar correccions d'errors i van donar altres ajudes.

El disseny i la implementació de Expect va ser pagat en part pel govern dels EUA i, per tant, en el domini públic. Tanmateix, l'autor i el NIST voldrien obtenir crèdits si s'utilitza aquest programa i documentació o parts d'ells.