Aspettatevi è un programma che parla ad altri programmi interattivi secondo uno script. Seguendo lo script, Expect sa cosa ci si può aspettare da un programma e quale dovrebbe essere la risposta corretta. Un linguaggio interpretato fornisce strutture di controllo ramificate e di alto livello per dirigere il dialogo. Inoltre, l'utente può assumere il controllo e interagire direttamente quando lo si desidera, restituendo successivamente il controllo allo script.
Expectk è una miscela di Expect e Tk. Si comporta proprio come il desiderio di Expect e Tk. Expect può anche essere usato direttamente in C o C ++ senza Tcl.
Il nome "Expect" deriva dall'idea di sequenze send / expect rese popolari da uucp, kermit e altri programmi di controllo modem. Tuttavia, a differenza di uucp, Expect è generalizzato in modo che possa essere eseguito come un comando a livello utente con qualsiasi programma e attività in mente. Aspettatevi possono parlare con diversi programmi allo stesso tempo.
Cosa può aspettarsi
Ad esempio, ecco alcune cose che il comando expect può fare:
- Fai in modo che il tuo computer ti ricolleghi, così puoi accedere senza pagare la chiamata.
- Avvia un gioco e se la configurazione ottimale non viene visualizzata, riavvialo ancora e ancora, finché non lo fa, quindi passa il controllo a te.
- Esegui fsck e, in risposta alle sue domande, rispondi "sì" o "no" o restituisci il controllo, in base a criteri predeterminati.
- Connettiti a un'altra rete e recupera automaticamente la posta in modo che appaia come se fosse stata originariamente inviata al tuo sistema locale.
- Trasporta variabili di ambiente, directory corrente o qualsiasi tipo di informazione attraverso rlogin, telnet, tip, su o chgrp
Ci sono una serie di motivi per cui la shell non può eseguire queste attività. Tutto è possibile con Expect.
In generale, Expect è utile per l'esecuzione di qualsiasi programma che richiede l'interazione tra il programma e l'utente. Tutto ciò che è necessario è che l'interazione possa essere caratterizzata a livello programmatico. Expect può anche restituire il controllo all'utente senza interrompere il programma controllato. Allo stesso modo, l'utente può restituire il controllo allo script in qualsiasi momento.
uso
Aspettatevi letture cmdfile per un elenco di comandi da eseguire. L'aspettativa può essere invocata implicitamente sui sistemi che supportano il #! notazione contrassegnando lo script come eseguibile e creando la prima riga nello script:
#! / usr / local / bin / expect -f
Naturalmente, il percorso deve descrivere con precisione dove vive Expect. / usr / local / bin è solo un esempio.
L'opzione -c preface un comando da eseguire prima di qualsiasi nella sceneggiatura. Il comando dovrebbe essere citato per evitare di essere suddiviso dalla shell. Questa opzione può essere utilizzata più volte. Più comandi possono essere eseguiti con un singolo -c separandoli con punto e virgola. I comandi vengono eseguiti nell'ordine in cui appaiono. Quando si utilizza Expectk, questa opzione è specificata come comando.
Il flag -d abilita alcuni output diagnostici, che in primo luogo riportano l'attività interna di comandi come expect e interact. Questo flag ha lo stesso effetto di "exp_internal 1" all'inizio di uno script Expect, più la versione di Expect viene stampata.
Il flag -D abilita un debugger interattivo. Un valore intero dovrebbe seguire. Il debugger prenderà il controllo prima della successiva procedura Tcl se il valore è diverso da zero o se viene premuto un ^ C o viene colpito un punto di interruzione o viene visualizzato un altro comando debugger appropriato nello script. Quando si utilizza Expectk, questa opzione è specificata come -Debug.
Il flag -f prefigura un file da cui leggere i comandi. La bandiera stessa è opzionale in quanto è utile solo quando si usa #! notazione, in modo che altri argomenti possano essere forniti sulla riga di comando. Quando si utilizza Expectk, questa opzione è specificata come -file.
Per impostazione predefinita, il file di comando viene letto in memoria ed eseguito nella sua interezza. Occasionalmente è preferibile leggere i file una riga alla volta. Per forzare in questo modo la gestione di file arbitrari, utilizzare l'opzione -b. Quando si utilizza Expectk, questa opzione è specificata come -buffer.
Se la stringa "-" viene fornita come nome file, viene invece letto l'input standard. Usa "./-" per leggere da un file effettivamente chiamato "-".
L'opzione -i fa in modo che Expect richieda interattivamente i comandi anziché leggerli da un file. La richiesta viene terminata tramite il comando exit o su EOF. L'indicatore -i viene assunto se non viene utilizzato né un file di comando né -c. Quando si utilizza Expectk, questa opzione è specificata come -interattiva.
- può essere usato per delimitare la fine delle opzioni. Questo è utile se vuoi passare un argomento simile al tuo script senza che sia interpretato da Expect. Questo può essere utilmente inserito nel #! linea per prevenire qualsiasi interpretazione flaglike di Expect. Ad esempio, il seguente lascerà gli argomenti originali incluso il nome dello script nella variabile argv .
#! / usr / local / bin / expect -
Nota che le solite convenzioni getopt (3) ed execve (2) devono essere osservate quando si aggiungono argomenti al #! linea.
Il file $ exp_library / expect.rc viene estratto automaticamente se presente, a meno che non venga usato il flag -N. (Quando si utilizza Expectk, questa opzione è specificata come -NORC.) Immediatamente dopo questo, il file ~ / .expect.rc viene estratto automaticamente, a meno che non venga usato il flag -n. Se la variabile di ambiente DOTDIR è definita, viene trattata come una directory e da lì viene letto .expect.rc. Quando si utilizza Expectk, questa opzione è specificata come -norc.Questo sourcing si verifica solo dopo l'esecuzione di qualsiasi flag -c.
-v fa in modo che Expect stampi il suo numero di versione ed esca. Il flag corrispondente in Expectk, che usa nomi di flag lunghi, è -version.
Gli argomenti facoltativi sono costruiti in un elenco e memorizzati nella variabile denominata argv e. argc è inizializzato alla lunghezza di argv.
Argv0 è definito come il nome dello script o binario se non viene utilizzato uno script. Ad esempio, il testo seguente mostra il nome dello script e i primi tre argomenti:
send_user "$ argv0 lrange $ argv 0 2 n"
comandi
Expect utilizza la lingua di comando degli strumenti. Tcl fornisce il flusso di controllo (if, for, break), la valutazione dell'espressione e molte altre funzionalità come la ricorsione e la definizione della procedura. I comandi usati qui ma non definiti (set, if, exec) sono comandi Tcl. Expect supporta comandi aggiuntivi. Se non diversamente specificato, i comandi restituiscono la stringa vuota.
I comandi sono elencati in ordine alfabetico in modo che possano essere individuati rapidamente. Tuttavia, i nuovi utenti potrebbero trovare più semplice iniziare leggendo le descrizioni di spawn, send, expect e interact, in questo ordine.
close -slave -onexec 0 | 1 -i spawn_id
chiude la connessione al processo corrente. La maggior parte dei programmi interattivi rileverà EOF sul loro stdin e exit; così vicino di solito è sufficiente anche per uccidere il processo. Il flag -i dichiara la chiusura del processo corrispondente al spawn_id denominato.
Sia aspettarsi che interagire rileveranno quando il processo attuale si chiude e implicitamente chiudono, ma se uccidi il processo, per esempio, "exec kill $ pid", devi chiamare esplicitamente chiudi.
Il flag -onexec determina se l'ID di spawn viene chiuso in qualsiasi nuovo processo spawn o se il processo è sovrascritto. Per lasciare aperto un ID spawn, utilizzare il valore 0. Un valore intero diverso da zero forza lo spawn chiuso in qualsiasi nuovo processo.
Il flag -slave chiude lo slave associato all'ID spawn. Quando la connessione è chiusa, lo slave viene automaticamente chiuso anche se è ancora aperto.
Indipendentemente dal fatto che la connessione venga chiusa in modo implicito o esplicito, è necessario chiamare wait per cancellare lo slot del processo kernel corrispondente. Il comando close non chiama l'attesa poiché non è garantito che la chiusura di una connessione al processo causerà l'uscita.
debug -now 0 | 1
controlla un debugger Tcl che consente di scorrere le istruzioni e impostare i breakpoint.
Senza argomenti, viene restituito 1 se il debugger non è in esecuzione, altrimenti viene restituito uno 0.
Con un argomento 1, viene avviato il debugger. Con un argomento 0, il debugger viene fermato. Se un argomento 1 è preceduto dal flag -now, il debugger viene avviato immediatamente. Altrimenti, il debugger viene avviato con la successiva istruzione Tcl.
Il comando di debug non cambia alcuna trap. Confronta questo per avviare Expect con il flag -D.
Il comando disconnect disconnette un processo biforcato dal terminale. Continua in esecuzione in background. Il processo ha il proprio gruppo di processi. L'I / O standard viene reindirizzato a / dev / null.
Il seguente frammento utilizza la disconnessione per continuare a eseguire lo script in background.
se {fork! = 0} esci da disconnetti. . .
Il seguente script legge una password e quindi esegue un programma ogni ora che richiede una password ogni volta che viene eseguita. Lo script fornisce la password in modo tale da doverla digitare solo una volta.
send_user "password? " expect_user -re "(. *) n" per {} 1 {} {se {fork! = 0} {sleep 3600; continue} disconnessione spawn priv_prog expect Password: send "$ expect_out ( 1, stringa) r ". . . Uscita }
Un vantaggio dell'utilizzo della disconnessione tramite la funzione di processo asincrono della shell (&) è che Expect può salvare i parametri del terminale prima della disconnessione e successivamente applicarli a nuovi pty. Con &, Expect non ha la possibilità di leggere i parametri del terminale poiché il terminale è già disconnesso dal momento in cui Expect riceve il controllo.
exit -opts stato
causa l'uscita di Expect o in altro modo di prepararsi a farlo.
Il -onexit flag fa in modo che l'argomento successivo sia usato come gestore di uscita. Senza un argomento, viene restituito il gestore di uscita corrente.
Il -Uscita Vietata flag cause Aspettarsi per prepararsi a uscire, ma basta per non restituire effettivamente il controllo al sistema operativo. Il gestore di uscita definito dall'utente viene eseguito come i gestori interni di Expect. Non è necessario eseguire ulteriori comandi Expect. Questo è utile se stai usando Expect con altre estensioni Tcl. L'interprete corrente (e la finestra principale se nell'ambiente Tk) rimangono in modo che altre estensioni Tcl possano essere pulite. Se Aspetta Uscita viene chiamato di nuovo (tuttavia ciò potrebbe accadere), i gestori non vengono rieseguiti.
All'uscita, tutte le connessioni ai processi spawn sono chiuse. La chiusura verrà rilevata come un EOF dai processi generati. Uscita non intraprende altre azioni oltre alla normale procedura _exit (2). Pertanto, i processi generati che non verificano EOF potrebbero continuare a essere eseguiti. (Una varietà di condizioni è importante per determinare, ad esempio, quali segnali verrà inviato un processo generato, ma questi sono dipendenti dal sistema, tipicamente documentati sotto exit (3).) I processi generati che continuano ad essere eseguiti saranno ereditati da init.
stato (o 0 se non specificato) viene restituito come stato di uscita di Aspettarsi . Uscita viene eseguito implicitamente se viene raggiunta la fine dello script.
exp_continue -continue_timer
Il comando exp_continue consente aspettarsi stesso per continuare a eseguire piuttosto che tornare normalmente. Di default exp_continue ripristina il timer di timeout. Il -continue_timer il flag impedisce il riavvio del timer. (Vedere aspettarsi per maggiori informazioni.)
valore exp_internal -f file
causa ulteriori comandi per inviare informazioni diagnostiche interne a Aspettarsi a stderr se valore è diverso da zero. Questo output è disabilitato se valore è 0. Le informazioni diagnostiche includono ogni carattere ricevuto e ogni tentativo effettuato per abbinare l'output corrente ai pattern.
Se l'opzionale file viene fornito, tutti gli output normali e di debug vengono scritti su quel file (indipendentemente dal valore di valore ). Qualsiasi file di output diagnostico precedente è chiuso.
Il -Informazioni flag fa in modo che exp_internal restituisca una descrizione degli argomenti non recenti più recenti forniti.
exp_open args -i spawn_id
restituisce un identificatore di file Tcl che corrisponde all'idro di spawn originale. L'identificativo del file può quindi essere usato come se fosse stato aperto da Tcl Aperto comando. (L'id dello spawn non dovrebbe più essere usato aspettare non dovrebbe essere eseguito
Il -lascia aperto la bandiera lascia l'id spawn aperto per l'accesso tramite i comandi Expect. UN aspettare deve essere eseguito sull'ID spawn.
exp_pid -i spawn_id
restituisce l'id del processo corrispondente al processo generato in quel momento. Se la -io viene usato il flag, il pid restituito corrisponde a quello del spawn indicato.
exp_send
è un alias per inviare .
exp_send_error
è un alias per SEND_ERROR .
exp_send_log
è un alias per send_log .
exp_send_tty
è un alias per send_tty .
exp_send_user
è un alias per send_user .
exp_version -exit versione
è utile per assicurare che lo script sia compatibile con la versione corrente di Expect.
Senza argomenti, la versione corrente di Aspettarsi viene restituito. Questa versione potrebbe quindi essere codificata nel tuo script. Se sai che non stai utilizzando le funzionalità delle versioni recenti, puoi specificare una versione precedente.
Le versioni sono composte da tre numeri separati da punti. Il primo è il numero maggiore. Script scritti per versioni di Aspettarsi con un numero maggiore diverso quasi certamente non funzionerà. exp_version restituisce un errore se i numeri maggiori non corrispondono.
Il secondo è il numero minore. Gli script scritti per una versione con un numero minore maggiore rispetto alla versione corrente potrebbero dipendere da alcune nuove funzionalità e potrebbero non essere eseguiti. exp_version restituisce un errore se i numeri maggiori corrispondono, ma il numero secondario dello script è maggiore di quello dell'esecuzione Aspettarsi .
Terzo è un numero che non ha alcun ruolo nel confronto delle versioni. Tuttavia, viene incrementato quando il Aspettarsi la distribuzione del software viene modificata in qualsiasi modo, ad esempio mediante documentazione aggiuntiva o ottimizzazione. Viene reimpostato su 0 ad ogni nuova versione secondaria.
Con il -Uscita bandiera, Aspettarsi stampa un errore ed esce se la versione non è aggiornata.
aspettati -opts pat1 body1 … -opts patn bodyn
attende che uno dei pattern corrisponda all'output di un processo generato, che sia trascorso un periodo di tempo specificato o che venga visualizzata una fine del file. Se il corpo finale è vuoto, può essere omesso.
Modelli dal più recente expect_before il comando viene utilizzato implicitamente prima di qualsiasi altro modello. Modelli dal più recente expect_after il comando viene utilizzato implicitamente dopo qualsiasi altro modello.
Se gli argomenti per l'intero aspettarsi l'istruzione richiede più di una riga, tutti gli argomenti possono essere "rinforzati" in uno in modo da evitare di terminare ogni riga con un backslash. In questo caso, le solite sostituzioni Tcl si verificano nonostante le parentesi graffe.
Se un modello è la parola chiave eof , il corpo corrispondente viene eseguito alla fine del file. Se un modello è la parola chiave tempo scaduto , il corpo corrispondente viene eseguito al timeout. Se non viene utilizzata alcuna parola chiave timeout, viene eseguita un'azione null implicita al timeout. Il periodo di timeout predefinito è 10 secondi ma può essere impostato, ad esempio su 30, mediante il comando "imposta timeout 30". Un timeout infinito può essere designato dal valore -1. Se un modello è la parola chiave predefinito , il corpo corrispondente viene eseguito al timeout o alla fine del file.
Se un modello corrisponde, viene eseguito il corpo corrispondente. aspettarsi restituisce il risultato del corpo (o la stringa vuota se nessun pattern corrisponde). Nel caso in cui più pattern combaciano, quello che appare per primo viene utilizzato per selezionare un corpo.
Ogni volta che arriva un nuovo risultato, viene confrontato con ciascun modello nell'ordine in cui sono elencati. Pertanto, è possibile verificare l'assenza di una corrispondenza rendendo l'ultimo modello qualcosa che è garantito, ad esempio un prompt. In situazioni in cui non vi è alcun prompt, è necessario utilizzare tempo scaduto (proprio come faresti se interagissi manualmente).
I modelli sono specificati in tre modi. Per impostazione predefinita, i modelli sono specificati come quelli di Tcl corrispondenza delle stringhe comando. (Tali modelli sono anche simili alle espressioni regolari C-shell di solito indicate come pattern "glob"). Il gl il flag può essere usato per proteggere i pattern che potrebbero altrimenti corrispondere aspettarsi bandiere da farlo. Qualsiasi modello che inizia con un "-" dovrebbe essere protetto in questo modo. (Tutte le stringhe che iniziano con "-" sono riservate per le opzioni future.)
Ad esempio, il seguente frammento cerca un login riuscito. (Nota che abortire si presume che sia una procedura definita altrove nella sceneggiatura).
aspettati {busy {puts busy n; exp_continue} failed abort "invalid password" abort timeout abort connected}
Le virgolette sono necessarie sul quarto motivo poiché contiene uno spazio, che altrimenti separerebbe il modello dall'azione.I pattern con la stessa azione (come la 3a e la 4a) richiedono di elencare nuovamente le azioni. Questo può essere evitato usando schemi di stile regexp (vedi sotto). Ulteriori informazioni sulla formazione di modelli glob-style sono disponibili nel manuale Tcl.
I pattern in stile Regexp seguono la sintassi definita da Tcl's regexp (abbreviazione di "espressione regolare") comando. i modelli regexp sono introdotti con la bandiera -ri . L'esempio precedente può essere riscritto usando un regexp come:
aspettati {busy {puts busy n; exp_continue} -re "failed | password non valida" abort timeout abort connected}
Entrambi i tipi di modelli sono "non curati". Ciò significa che i pattern non devono necessariamente corrispondere all'intera stringa, ma possono iniziare e terminare la corrispondenza in qualsiasi punto della stringa (purché tutto il resto corrisponda). Usare ^ per abbinare l'inizio di una stringa e $ per abbinare la fine. Si noti che se non si attende la fine di una stringa, le risposte possono facilmente finire nel mezzo della stringa mentre vengono echeggiate dal processo generato. Mentre continua a produrre risultati corretti, l'output può sembrare innaturale. Pertanto, l'uso di $ è incoraggiato se puoi descrivere esattamente i caratteri alla fine di una stringa.
Si noti che in molti editor, i tasti ^ e $ corrispondono rispettivamente all'inizio e alla fine delle righe. Tuttavia, poiché expect non è orientato alla linea, questi caratteri corrispondono all'inizio e alla fine dei dati (in contrapposizione alle linee) attualmente nel buffer di corrispondenza previsto. (Vedi anche la nota in basso su "indigestione del sistema".)
Il -ex flag fa corrispondere il pattern come una stringa "esatta". Nessuna interpretazione di *, ^, etc è fatta (anche se le solite convenzioni Tcl devono ancora essere osservate). I modelli esatti sono sempre disancorati.
Il -nocase contrassegna i caratteri maiuscoli dell'output per confrontare come se fossero caratteri minuscoli. Il modello non è interessato.
Durante la lettura dell'output, più di 2000 byte possono forzare i byte precedenti a essere "dimenticati". Questo può essere cambiato con la funzione match_max . (Si noti che valori eccessivamente grandi possono rallentare il pattern matcher.) Se patlist è full_buffer , il corpo corrispondente viene eseguito se match_max i byte sono stati ricevuti e nessun altro pattern è stato abbinato. Se o non il full_buffer viene utilizzata la parola chiave, i caratteri dimenticati vengono scritti in expect_out (buffer).
Se patlist è la parola chiave nullo e i valori nulli sono consentiti (tramite il file remove_nulls comando), il corpo corrispondente viene eseguito se un singolo ASCII 0 è abbinato. Non è possibile associare 0 byte tramite glob o pattern regexp.
Quando si abbina un modello (o eof o full_buffer), qualsiasi risultato corrispondente e precedentemente non abbinato viene salvato nella variabile expect_out (buffer) . Fino a 9 corrispondenze di sottostringhe regexp vengono salvate nelle variabili expect_out (1, stringa) attraverso expect_out (9, stringa) . Se la -indices il flag viene utilizzato prima di un pattern, gli indici di inizio e di fine (in un formato adatto a lrange ) delle 10 stringhe sono memorizzate nelle variabili expect_out (X, inizio) e expect_out (X, end) dove X è una cifra, corrisponde alla posizione della sottostringa nel buffer. 0 fa riferimento a stringhe che corrispondono al modello intero e vengono generate per motivi glob e modelli regexp. Ad esempio, se un processo ha prodotto l'output di "abcdefgh n", il risultato di:
aspetta "cd"
è come se le seguenti dichiarazioni fossero state eseguite:
set expect_out (0, stringa) cd set expect_out (buffer) abcd
e "efgh n" è lasciato nel buffer di output. Se un processo ha prodotto l'output "abbbcabkkkka n", il risultato di:
expect -indices -re "b (b *). * (k +)"
è come se le seguenti dichiarazioni fossero state eseguite:
set expect_out (0, start) 1 set expect_out (0, end) 10 set expect_out (0, stringa) bbbcabkkkk set expect_out (1, start) 2 set expect_out (1, end) 3 set expect_out (1, stringa) bb set expect_out (2, start) 10 set expect_out (2, end) 10 set expect_out (2, stringa) k set expect_out (buffer) abbbcabkkkk
e "a n" è lasciato nel buffer di output. Il pattern "*" (e -re ". *") Svuota il buffer di output senza leggere ulteriori output dal processo.
Normalmente, l'output abbinato viene scartato dai buffer interni di Expect. Questo può essere evitato con il prefisso di un modello con il -notransfer bandiera. Questo flag è particolarmente utile nella sperimentazione (e può essere abbreviato in "-not" per comodità durante la sperimentazione).
L'ID di spawn associato all'output corrispondente (o eof o full_buffer) è memorizzato in expect_out (spawn_id) .
Il -tempo scaduto flag fa in modo che il comando current expect utilizzi il seguente valore come un timeout invece di utilizzare il valore della variabile di timeout.
Per impostazione predefinita, i modelli vengono confrontati con l'output del processo corrente, tuttavia il -io flag dichiara che l'output dall'elenco spawn_id denominato deve corrispondere a tutti i seguenti pattern (fino al successivo) -io ). L'elenco spawn_id deve essere un elenco di spawn_ids separato o una variabile che fa riferimento a un elenco di spawn_ids.
Ad esempio, il seguente esempio attende "connesso" dal processo corrente, o "occupato", "non riuscito" o "password non valida" dal spawn_id indicato da $ proc2.
aspetta {-i $ proc2 occupato {mette occupato n; exp_continue} -re "failed | password non valida" abort timeout abort connected}
Il valore della variabile globale any_spawn_id può essere usato per abbinare i pattern a qualsiasi spawn_ids che hanno un nome con tutti gli altri -io bandiere nella corrente aspettarsi comando. Lo spawn_id di a -io flag senza schema associato (ad esempio, seguito immediatamente da un altro -io ) è reso disponibile per qualsiasi altro modello nello stesso aspettarsi comando associato a any_spawn_id.
Il -io flag può anche nominare una variabile globale nel qual caso la variabile viene letta per un elenco di spawn id. La variabile viene riletta ogni volta che cambia. Ciò fornisce un modo di cambiare la sorgente I / O mentre il comando è in esecuzione. Gli id creati in questo modo sono chiamati ID di spawn "indiretti".
Azioni come rompere e Continua causare strutture di controllo (ad es. per , proc ) comportarsi nel solito modo. Il comando exp_continue consente aspettarsi stesso per continuare a eseguire piuttosto che tornare normalmente.
Questo è utile per evitare loop espliciti o dichiarazioni di aspettativa ripetute. L'esempio seguente fa parte di un frammento per automatizzare rlogin. Il exp_continue evita di dover scrivere un secondo aspettarsi istruzione (per cercare di nuovo il prompt) se il rlogin richiede una password.
expect {Password: {stty -echo send_user "password (per $ utente) su $ host:" expect_user -re "(. *) n" send_user " n" invia "$ expect_out (1, stringa) r" stty echo exp_continue} errato {send_user "password non valida o account n" exit} timeout {send_user "connessione a $ host scaduto n" exit} eof {send_user "connessione all'host fallita: $ expect_out (buffer)" exit} - re $ prompt}
Ad esempio, il seguente frammento potrebbe aiutare un utente a guidare un'interazione che è già completamente automatizzata. In questo caso, il terminale viene messo in modalità raw. Se l'utente preme "+", una variabile viene incrementata. Se si preme "p", al processo vengono inviati diversi ritorni, forse per attirarlo in qualche modo, e "i" consente all'utente di interagire con il processo, rubando efficacemente il controllo dallo script. In ogni caso, il exp_continue consente la corrente aspettarsi per continuare la corrispondenza del modello dopo aver eseguito l'azione corrente.
stty raw -echo expect_after {-i $ user_spawn_id "p" {invia " r r r"; exp_continue} "+" {incr foo; exp_continue} "i" {interact; exp_continue} "quit" exit}
Di default, exp_continue ripristina il timer di timeout. Il timer non viene riavviato, se exp_continue è chiamato con il -continue_timer bandiera.
expect_after expect_args
funziona in modo identico al expect_before tranne che se modelli da entrambi aspettarsi e expect_after può abbinare, il aspettarsi il modello è usato. Vedere il expect_before comando per ulteriori informazioni.
expect_background expect_args
prende gli stessi argomenti diaspettarsi , tuttavia ritorna immediatamente. I pattern vengono testati ogni volta che arriva un nuovo input. Il modellotempo scaduto epredefinito sono privi di significato perexpect_background e sono silenziosamente scartati. Altrimenti, ilexpect_background comando usaexpect_before eexpect_after modelli comeaspettarsi lo fa.
quandoexpect_background le azioni sono in fase di valutazione, l'elaborazione in background per lo stesso ID di spawn è bloccata. L'elaborazione in background è sbloccata al termine dell'azione. Mentre l'elaborazione in background è bloccata, è possibile eseguire una (in primo piano)aspettarsi sullo stesso id spawn.
Non è possibile eseguire unaspettarsi mentre unexpect_background è sbloccato.expect_background per un determinato spawn id viene cancellato dichiarando un nuovo expect_background con lo stesso spawn id. dichiarareexpect_background senza schemi rimuove l'id generato dalla capacità di abbinare i pattern in background.
expect_before expect_args
prende gli stessi argomenti diaspettarsi , tuttavia ritorna immediatamente. Coppie di pattern-action dal più recenteexpect_before con lo stesso ID spawn sono implicitamente aggiunti a qualsiasi seguenteaspettarsi comandi. Se un modello corrisponde, viene trattato come se fosse stato specificato nel fileaspettarsi comando stesso, e il corpo associato viene eseguito nel contesto delaspettarsi comando. Se modelli da entrambiexpect_before easpettarsi può abbinare, ilexpect_before il modello è usato.
Se non viene specificato alcun modello, l'id dello spawn non viene controllato per nessun motivo.
Salvo sovrascrizione di a-io bandiera,expect_before i modelli corrispondono all'idro di spawn definito al momento in cui ilexpect_before comando è stato eseguito (non quando il suo modello è abbinato).
La bandiera di -info causaexpect_before per restituire le specifiche correnti di quali modelli corrisponderà. Per impostazione predefinita, riporta l'id dello spawn corrente. Può essere fornita una specifica id di spawn per informazioni su quell'idro di spawn. Per esempio
expect_before -info -i $ proc
Al massimo può essere data una specifica di spawn id. Il flag -indirect sopprime gli ID di spawn diretti che provengono solo da specifiche indirette.
Invece di una specifica di identificazione spawn, la flag "-all" farà sì che "-info" riporti su tutti gli ID spawn.
L'output del flag -info può essere riutilizzato come argomento su expect_before.
expect_tty expect_args
è comeaspettarsi ma legge caratteri da / dev / tty (cioè le sequenze di tasti dell'utente). Per impostazione predefinita, la lettura viene eseguita in modalità cotta. Pertanto, le righe devono terminare con un reso peraspettarsi vederli. Questo può essere cambiato tramitestty (vedi ilstty comando di seguito).
expect_user expect_args
è comeaspettarsi ma legge i caratteri da stdin (cioè le sequenze di tasti dell'utente). Per impostazione predefinita, la lettura viene eseguita in modalità cotta. Pertanto, le righe devono terminare con un reso peraspettarsi vederli.Questo può essere cambiato tramitestty (vedi ilstty comando di seguito).
forchetta
crea un nuovo processo. Il nuovo processo è una copia esatta della correnteAspettarsi processi. In caso di successo,forchetta restituisce 0 al nuovo processo (figlio) e restituisce l'ID di processo del processo figlio al processo padre. In caso di fallimento (invariabilmente a causa della mancanza di risorse, ad esempio, spazio di scambio, memoria),forchetta restituisce -1 al processo principale e non viene creato alcun processo figlio.
I processi a forcella escono tramite ilUscita comando, proprio come il processo originale. I processi forked sono autorizzati a scrivere nei file di log. Se non disabiliti il debug o la registrazione nella maggior parte dei processi, il risultato può essere confuso.
Alcune implementazioni pty possono essere confuse da più lettori e scrittori, anche momentaneamente. Quindi, è più sicuroforchetta prima dei processi di spawning.
interact string1 body1 … stringn bodyn
fornisce il controllo del processo corrente all'utente, in modo che le sequenze di tasti vengano inviate al processo corrente e vengono restituiti lo stdout e lo stderr del processo corrente.
Le coppie corpo-stringa possono essere specificate come argomenti, nel qual caso il corpo viene eseguito quando viene inserita la stringa corrispondente. (Per impostazione predefinita, la stringa non viene inviata al processo corrente.)interprete il comando è assunto, se manca il corpo finale.
Se gli argomenti per l'interointeragire l'istruzione richiede più di una riga, tutti gli argomenti possono essere "rinforzati" in uno in modo da evitare di terminare ogni riga con un backslash. In questo caso, le solite sostituzioni Tcl si verificano nonostante le parentesi graffe.
Ad esempio, il seguente comando viene eseguito interagisce con le seguenti coppie corpo-stringa definite: Quando viene premuto ^ Z,Aspettarsi è sospeso. (Il-reset flag ripristina le modalità del terminale.) Quando viene premuto ^ A, l'utente vede "hai digitato un controllo-A" e il processo viene inviato a ^ A. Quando $ viene premuto, l'utente vede la data. Quando viene premuto ^ C,Aspettarsi uscite. Se viene inserito "foo", l'utente vede "bar". Quando ~~ viene premuto, ilAspettarsi interprete funziona in modo interattivo.
imposta CTRLZ 032 interact {-reset $ CTRLZ {exec kill -STOP pid} 001 {send_user "hai digitato un controllo-A n"; invia " 001"} $ {send_user "La data è formato orologio secondi orologio."} 003 exit foo {send_user "bar"} ~~}
Nelle coppie corpo-stringa, le stringhe sono abbinate nell'ordine in cui sono elencate come argomenti. Le stringhe parzialmente corrispondenti non vengono inviate al processo corrente in previsione del resto in arrivo. Se i caratteri vengono inseriti in modo tale che non ci sia più possibile una corrispondenza, solo la parte della stringa verrà inviata al processo che non può eventualmente iniziare un'altra corrispondenza. Pertanto, le stringhe che sono sottostringhe di corrispondenze parziali possono corrispondere più tardi, se le stringhe originali che stavano tentando di corrispondere alla fine falliscono.
Per impostazione predefinita, la corrispondenza delle stringhe è esatta senza caratteri jolly. (Al contrario, ilaspettarsi il comando usa i modelli glob-style per impostazione predefinita)-ex il flag può essere usato per proteggere i pattern che potrebbero altrimenti corrispondereinteragire bandiere da farlo. Qualsiasi modello che inizia con un "-" dovrebbe essere protetto in questo modo. (Tutte le stringhe che iniziano con "-" sono riservate per le opzioni future.)
Il-ri flag impone che la stringa venga interpretata come un modello in stile regexp. In questo caso, le sottostringhe corrispondenti vengono memorizzate nella variabile interact_out allo stesso modo del modoaspettarsi memorizza il suo output nella variabileexpect_out . Il-indices il flag è similmente supportato.
Il modelloeof introduce un'azione che viene eseguita alla fine del file. Un separatoeof il modello può anche seguire il-produzione flag in tal caso è abbinato se viene rilevato un eof durante la scrittura dell'output. Il predefinitoeof l'azione è "ritorno", cosìinteragire restituisce semplicemente su qualsiasi EOF.
Il modellotempo scaduto introduce un timeout (in secondi) e un'azione che viene eseguita dopo che nessun carattere è stato letto per un dato tempo. Iltempo scaduto il modello si applica al processo specificato più di recente. Non esiste un timeout predefinito. La variabile speciale "timeout" (usata dalaspettarsi comando) non ha alcun effetto su questo timeout.
Ad esempio, la seguente dichiarazione potrebbe essere utilizzata per eseguire l'autenticazione degli utenti che non hanno digitato nulla per un'ora ma che continuano a ricevere messaggi di sistema frequenti:
interact-input $ user_spawn_id timeout 3600 return -output $ spawn_id
Se il modello è la parola chiavenullo e i valori nulli sono consentiti (tramite il fileremove_nulls comando), il corpo corrispondente viene eseguito se un singolo ASCII 0 è abbinato. Non è possibile associare 0 byte tramite glob o pattern regexp.
Prefazione di un motivo con la bandiera-Scrivo io causa la variabile interact_out (spawn_id) da impostare su spawn_id che corrisponde al modello (o eof).
Azioni comerompere eContinua causare strutture di controllo (ad es.per , proc ) comportarsi nel solito modo. peròritorno cause interagiscono per tornare al suo chiamante, mentreinter_return causeinteragire per causare un ritorno nel suo chiamante. Ad esempio, se "proc foo" ha chiamatointeragire che poi ha eseguito l'azioneinter_return , proc foo sarebbe tornato (Questo significa che seinteragire chiamateinterprete digitando in modo interattivoritorno farà in modo che l'interazione continui, mentreinter_return farà in modo che l'interazione ritorni al suo chiamante.)
Duranteinteragire , viene utilizzata la modalità raw in modo che tutti i caratteri possano essere passati al processo corrente.Se il processo corrente non rileva i segnali di controllo del lavoro, si fermerà se viene inviato un segnale di arresto (di default ^ Z). Per riavviarlo, invia un segnale di continuazione (ad esempio "kill -CONT"). Se vuoi veramente inviare un SIGSTOP a tale processo (per ^ Z), considera prima di spawnare csh e poi di eseguire il tuo programma. D'altra parte, se si desidera inviare un SIGSTOP aAspettarsi per prima cosa, chiama l'interprete (magari usando un carattere di escape), quindi premi ^ Z.
Le coppie corpo-stringa possono essere utilizzate come una scorciatoia per evitare di dover entrare nell'interprete ed eseguire comandi in modo interattivo. La modalità terminale precedente viene utilizzata mentre viene eseguito il corpo di una coppia corpo-stringa.
Per velocità, le azioni vengono eseguite in modalità raw per impostazione predefinita. Il-reset flag reimposta il terminale sulla modalità che aveva primainteragire è stato eseguito (invariabilmente, modalità cotta). Si noti che i caratteri immessi quando si passa alla modalità potrebbero andare persi (una sfortunata caratteristica del driver del terminale su alcuni sistemi). L'unica ragione per usare-reset è se la tua azione dipende dall'esecuzione in modalità cotta.
Il-eco il flag invia i caratteri che corrispondono al seguente schema al processo che li ha generati man mano che ogni carattere viene letto. Questo può essere utile quando l'utente ha bisogno di vedere il feedback da schemi parzialmente digitati.
Se un pattern viene echeggiato ma alla fine non riesce a corrispondere, i personaggi vengono inviati al processo generato. Se il processo generato viene quindi echo, l'utente vedrà i caratteri due volte.-eco è probabilmente appropriato solo in situazioni in cui è improbabile che l'utente non completi il modello. Ad esempio, il seguente estratto proviene da rftp, lo script ricorsivo-ftp, in cui all'utente viene richiesto di immettere ~ g, ~ p o ~ l, per ottenere, inserire o elencare la directory corrente in modo ricorsivo. Questi sono così lontani dai normali comandi ftp, che è improbabile che l'utente digiti ~ seguito da qualsiasi altra cosa, tranne che per errore, nel qual caso, probabilmente ignoreranno comunque il risultato.
interact {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}
Il-nobuffer il flag invia caratteri che corrispondono al modello seguente al processo di output mentre i caratteri vengono letti.
Ciò è utile quando si desidera consentire a un programma di ripetere il pattern. Ad esempio, è possibile utilizzare quanto segue per monitorare la posizione di una persona (un modem in stile Hayes). Ogni volta che "atd" viene visto lo script registra il resto della linea.
proc lognumber {} {interact -nobuffer -re "(. *) r" return puts $ log "formato orologio secondi orologio: composto $ interact_out (1, stringa)"} interact -nobuffer "atd" lognumber
Duranteinteragire , uso precedente diLOG_USER è ignorato In particolare,interagire costringerà il suo output a essere registrato (inviato allo standard output) poiché si presume che l'utente non desideri interagire ciecamente.
Il-o flag fa in modo che tutte le seguenti coppie chiave-corpo vengano applicate all'output del processo corrente. Ciò può essere utile, ad esempio, quando si tratta di host che inviano caratteri indesiderati durante una sessione telnet.
Di default,interagire si aspetta che l'utente stia scrivendo stdin e leggendo lo stdout delAspettarsi processo stesso. Il-u flag (per "utente") rendeinteragire cercare l'utente come processo chiamato dal suo argomento (che deve essere un id generato).
Ciò consente di unire due processi non collegati tra loro senza utilizzare un ciclo esplicito. Per facilitare il debug, la diagnostica Expect va sempre su stderr (o stdout per determinate informazioni di registrazione e debug). Per lo stesso motivo, ilinterprete il comando leggerà in modo interattivo da stdin.
Ad esempio, il seguente frammento crea un processo di accesso. Quindi compone l'utente (non mostrato) e infine collega i due insieme. Ovviamente, qualsiasi processo può essere sostituito per il login. Una shell, ad esempio, consentirebbe all'utente di lavorare senza fornire un account e una password.
spawn login set login $ spawn_id spawn tip modem # dial indietro all'utente # connetti l'utente al login interact -u $ login
Per inviare l'output a più processi, elencare ogni elenco di ID spawn preceduto da a-produzione bandiera. L'input per un gruppo di spawn di output può essere determinato da un elenco di spawn preceduto da a-ingresso bandiera. (Tutti e due-ingresso e-produzione può prendere liste nella stessa forma di-io bandiera nelaspettarsi comando, tranne che any_spawn_id non è significativo ininteragire .) Tutti i seguenti flag e stringhe (o pattern) si applicano a questo input finché non viene visualizzato un altro flag di input. Se no-ingresso appare,-produzione implica "-input $ user_spawn_id -output". (Allo stesso modo, con modelli che non hanno-ingresso .) Se uno-ingresso è specificato, sovrascrive $ user_spawn_id. Se un secondo-ingresso è specificato, sovrascrive $ spawn_id. addizionale-ingresso i flag possono essere specificati.
I due processi di input impliciti hanno come impostazione predefinita il fatto che i loro output siano specificati come $ spawn_id e $ user_spawn_id (al contrario). Se una-ingresso la bandierina compare con no-produzione bandiera, i caratteri di quel processo vengono scartati.
Il-io flag introduce una sostituzione per l'attuale spawn_id quando nessun altro-ingresso o-produzione le bandiere sono usate Una bandiera -i implica un flag -o.
È possibile modificare i processi con cui si interagisce utilizzando ID di spawn indiretti. (Gli id spawn indiretti sono descritti nella sezione sul comando expect.) Gli id spawn indiretti possono essere specificati con i flag -i, -u, -input o -output.
interprete args
causa la richiesta interattiva all'utenteAspettarsi e comandi Tcl. Il risultato di ogni comando è stampato.
Azioni comerompere eContinua causare strutture di controllo (ad es.per , proc ) comportarsi nel solito modo. peròritorno fa in modo che l'interprete ritorni al suo chiamante, mentreinter_return causeinterprete per causare un ritorno nel suo chiamante. Ad esempio, se "proc foo" ha chiamatointerprete che poi ha eseguito l'azioneinter_return , proc foo sarebbe tornato Qualsiasi altro comando causainterprete per continuare a richiedere nuovi comandi.
Per impostazione predefinita, il prompt contiene due numeri interi. Il primo intero descrive la profondità dello stack di valutazione (cioè, quante volte è stato chiamato Tcl_Eval). Il secondo numero intero è l'identificatore cronologico Tcl. Il prompt può essere impostato definendo una procedura chiamata "prompt1" il cui valore restituito diventa il prompt successivo. Se una dichiarazione ha apici, parentesi, parentesi o parentesi, un prompt secondario (di default "+>") viene emesso su newline. Il prompt secondario può essere impostato definendo una procedura chiamata "prompt2".
Duranteinterprete viene utilizzata la modalità cotta, anche se il relativo chiamante stava utilizzando la modalità raw.
Se lo stdin è chiuso,interprete ritornerà a meno che il-eof flag viene utilizzato, nel qual caso viene richiamato l'argomento successivo.
log_file args -a file
Se viene fornito un nome file,log_file registrerà una trascrizione della sessione (a partire da quel punto) nel file.log_file interromperà la registrazione se non viene fornito alcun argomento. Qualsiasi file di registro precedente è chiuso.
Invece di un nome di file, un identificatore di file Tcl può essere fornito usando il-Aperto o-lascia aperto bandiere. Questo è simile aluova comando. (Vedereuova per maggiori informazioni.)
Il-un il flag forza l'output da registrare che è stato soppresso dalLOG_USER comando.
Di default, illog_file comando aggiunge a vecchi file anziché troncarli, per la comodità di poter disattivare la registrazione e più volte in una sola sessione. Per troncare i file, utilizzare il-noappend bandiera.
Il-Informazioni flag fa in modo che log_file restituisca una descrizione degli argomenti non recenti più recenti forniti.
log_user -info | 0 | 1
Per impostazione predefinita, il dialogo send / expect viene registrato su stdout (e un file di registro se aperto). La registrazione su stdout è disabilitata dal comando "log_user 0" e riabilitata da "log_user 1". La registrazione nel file di registro non è stata modificata.
Il-Informazioni flag fa in modo che log_user restituisca una descrizione degli argomenti non recenti più recenti forniti.
match_max -d -i spawn_id size
definisce la dimensione del buffer (in byte) utilizzato internamente daaspettarsi . Senza taglia argomento, viene restituita la dimensione corrente.
Con il-d flag, la dimensione predefinita è impostata. (L'impostazione iniziale predefinita è 2000.) Con il-io flag, la dimensione è impostata per l'id di spawn, altrimenti è impostata per il processo corrente.
sovrapposizione - # spawn_id - # spawn_id … programma args
esegue "programma args "al posto della correnteAspettarsi programma, che termina. Un argomento di trattino nudo forza un trattino davanti al nome del comando come se fosse una shell di login. Tutti spawn_ids sono chiusi tranne quelli nominati come argomenti. Questi sono mappati sugli identificatori di file con nome.
Spawn_ids sono mappati agli identificatori di file per il nuovo programma da ereditare. Ad esempio, la riga seguente esegue gli scacchi e consente di controllarli tramite il processo corrente, ad esempio un maestro di scacchi.
overlay -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id chess
Questo è più efficiente di "interact-u", tuttavia, sacrifica la capacità di fare interazione programmata dalAspettarsi il processo non ha più il controllo.
Si noti che non viene fornito alcun terminale di controllo. Pertanto, se si scollega o si rimappa l'input standard, i programmi che eseguono il controllo dei lavori (shell, login, ecc.) Non funzioneranno correttamente.
parità -d -i spawn_id valore
definisce se la parità debba essere mantenuta o rimossa dall'output dei processi spawn. Se valore è zero, la parità è spogliata, altrimenti non viene spogliata. Senza valore argomento, viene restituito il valore corrente.
Con il-d flag, viene impostato il valore di parità predefinito. (L'impostazione iniziale predefinita è 1, cioè la parità non viene eliminata). Con-io flag, il valore di parità è impostato per l'id di spawn, altrimenti è impostato per il processo corrente.
remove_nulls -d -i spawn_id valore
definisce se i valori nulli vengono mantenuti o rimossi dall'output dei processi spawn prima della corrispondenza o dell'archiviazione del modello nella variabile expect_out o interact_out . Se valore è 1, i valori nulli vengono rimossi. Se valore è 0, i valori nulli non vengono rimossi. Senza valore argomento, viene restituito il valore corrente.
Con il-d flag, il valore predefinito è impostato. (L'impostazione iniziale predefinita è 1, vale a dire, i valori null vengono rimossi.) Con il-io flag, il valore è impostato per l'id di spawn, altrimenti è impostato per il processo corrente.
Se i valori nulli vengono rimossi o meno,Aspettarsi registrerà byte nulli nel log e nello stdout.
invia -flags stringa
invia stringa al processo attuale. Ad esempio, il comando
invia "ciao mondo r"
invia i caratteri, h e l o w o r l d al processo corrente. (Tcl include un comando simile a printf (chiamatoformato ) che può costruire stringhe arbitrariamente complesse).
I caratteri vengono inviati immediatamente anche se i programmi con input bufferizzato dalla linea non leggeranno i caratteri fino a quando non verrà inviato un carattere di ritorno. Un carattere di ritorno è denotato " r".
Il-- flag forza l'argomento successivo ad essere interpretato come una stringa piuttosto che come una bandiera.Qualsiasi stringa può essere preceduta da "-" indipendentemente dal fatto che assomigli o meno a una bandiera. Ciò fornisce un meccanismo affidabile per specificare stringhe variabili senza essere inciampato da quelle che sembrano accidentalmente come bandiere. (Tutte le stringhe che iniziano con "-" sono riservate per le opzioni future.)
Il-io flag dichiara che la stringa viene inviata al spawn_id denominato. Se lo spawn_id è user_spawn_id e il terminale si trova in modalità raw, i newline nella stringa vengono convertiti in sequenze return-newline in modo che appaiano come se il terminale fosse in modalità cotta. Il-crudo flag disabilita questa traduzione.
Il-nullo il flag invia caratteri null (0 byte). Per impostazione predefinita, viene inviato un null. Un numero intero può seguire il-nullo per indicare quanti null da inviare.
Il-rompere la bandiera genera una condizione di rottura. Questo ha senso solo se l'id spawn si riferisce a un dispositivo tty aperto tramite "spawn -open". Se hai generato un processo come suggerimento, dovresti usare la convenzione di tip per generare un'interruzione.
Il-S il flag forza l'output da inviare "lentamente", evitando così la situazione comune in cui un computer estrapola un buffer di input che è stato progettato per un essere umano che non avrebbe mai superato lo stesso buffer. Questo output è controllato dal valore della variabile "send_slow" che prende una lista di due elementi. Il primo elemento è un numero intero che descrive il numero di byte da inviare atomicamente. Il secondo elemento è un numero reale che descrive il numero di secondi entro i quali le mandate atomiche devono essere separate. Ad esempio, "set send_slow {10 .001}" forzerebbe "send -s" a inviare stringhe con 1 millisecondo tra ogni 10 caratteri inviati.
Il-h il flag forza l'output da inviare (in qualche modo) come un umano che sta effettivamente digitando. Tra i personaggi compaiono ritardi simili a quelli umani. (L'algoritmo è basato su una distribuzione di Weibull, con modifiche per soddisfare questa particolare applicazione.) Questo output è controllato dal valore della variabile "send_human" che prende una lista di cinque elementi. I primi due elementi sono un tempo di interarrivazione medio dei caratteri in secondi. Il primo è usato di default. Il secondo è usato alla fine delle parole, per simulare le pause sottili che si verificano occasionalmente in tali transizioni. Il terzo parametro è una misura della variabilità dove .1 è abbastanza variabile, 1 è ragionevolmente variabile e 10 è abbastanza invariabile. Gli estremi sono da 0 a infinito. Gli ultimi due parametri sono, rispettivamente, un tempo di interlivello minimo e massimo. Il minimo e il massimo sono usati per ultimi e "ritaglia" l'ultima volta. La media finale può essere molto diversa dalla media data se il minimo e il massimo corrispondono a valori sufficienti.
Ad esempio, il seguente comando emula un dattilografo veloce e coerente:
imposta send_human {.1 .3 1 .05 2} invia -h "Ho fame. Facciamo pranzo".
mentre il seguente potrebbe essere più adatto dopo una sbornia:
imposta send_human {.4 .4 .2 .5 100} send -h "Goodd party lash night!"
Si noti che gli errori non vengono simulati, sebbene sia possibile impostare personalmente le situazioni di correzione degli errori incorporando errori e correzioni in un argomento di invio.
I flag per l'invio di caratteri null, per l'invio di interruzioni, per forzare l'output lento e per l'output in stile umano si escludono a vicenda. Verrà utilizzato solo l'ultimo specificato. Inoltre, no stringa argomento può essere specificato con i flag per l'invio di caratteri o interruzioni null.
È una buona idea precedere il primoinviare a un processo di unaspettarsi. aspettarsi attenderà il processo per iniziare, mentreinviare non può. In particolare, se il primoinviare viene completato prima che il processo inizi a essere eseguito, si corre il rischio di ignorare i dati. Nelle situazioni in cui i programmi interattivi non offrono alcuna richiesta iniziale, puoi precedereinviare con un ritardo come in:
# Per evitare di dare suggerimenti agli hacker su come intervenire, # questo sistema non richiede una password esterna. # Attendi 5 secondi che exec completi il spawn telnet very.secure.gov sleep 5 send password r
exp_send è un alias per inviare. Se stai usando Expectk o qualche altra variante di Expect nell'ambiente Tk,inviare è definito da Tk per uno scopo completamente diverso.exp_send è fornito per la compatibilità tra gli ambienti. Alias simili sono forniti per altri comandi di invio di Expect.
stringa send_error -flags
è comeinviare , eccetto che l'output è inviato a stderr piuttosto che al processo corrente.
send_log - stringa
è comeinviare , tranne per il fatto che la stringa viene inviata solo al file di log (vedilog_file .) Gli argomenti vengono ignorati se nessun file di registro è aperto.
stringa send_tty -flags
è comeinviare , eccetto che l'output è inviato a / dev / tty piuttosto che al processo corrente.
stringa send_user -flags
è comeinviare , eccetto che l'output è inviato a stdout piuttosto che al processo corrente.
dormire secondi
provoca lo sleep dello script per il numero di secondi specificato. I secondi possono essere un numero decimale. Gli interrupt (e gli eventi Tk se si utilizza Expectk) vengono elaborati mentre Expect dorme.
spawn args program args
crea un nuovo processo in esecuzione "programma args ". Stdin, stdout e stderr sono connessi a Expect, in modo che possano essere letti e scritti da altriAspettarsi comandi. La connessione è interrotta davicino o se il processo stesso chiude uno qualsiasi degli identificatori di file.
Quando un processo è avviato dauova , la variabile spawn_id è impostato su un descrittore riferito a quel processo. Il processo descritto da spawn_id è considerato il "attuale processi" . spawn_id può essere letto o scritto, in effetti fornendo il controllo del lavoro.
user_spawn_id è una variabile globale che contiene un descrittore che si riferisce all'utente. Ad esempio, quando spawn_id è impostato su questo valore,aspettarsi si comporta comeexpect_user .
.IO error_spawn_id è una variabile globale che contiene un descrittore che si riferisce all'errore standard. Ad esempio, quando spawn_id è impostato su questo valore,inviare si comporta comeSEND_ERROR .
tty_spawn_id è una variabile globale che contiene un descrittore che si riferisce a / dev
