ожидайте Linux / Unix командные инструкции и примеры

Содержание

1 Что ожидать можно сделать
2 использование
3 команды
4 Библиотеки
5 Довольно-печать
6 Примеры
7 Предостережения
8 ошибки
9 Ожидайте подсказки
10 Рекомендации

Expect — это программа, которая общается с другими интерактивными программами по сценарию. Следуя сценарию, Expect знает, чего можно ожидать от программы и каков должен быть правильный ответ. Интерпретированный язык предоставляет ветвящиеся и высокоуровневые структуры управления для управления диалогом. Кроме того, пользователь может взять на себя управление и взаимодействовать напрямую при желании, а затем вернуть управление сценарию.

Expectk представляет собой смесь Expect и Tk. Он ведет себя так же, как Expect и желание Tk. Expect также может быть использован непосредственно в C или C ++ без Tcl.

Название «Expect» происходит от идеи последовательностей отправки / ожидания, популяризируемых uucp, kermit и другими программами управления модемами. Однако, в отличие от uucp, Expect обобщен, поэтому его можно запускать как команду пользовательского уровня с учетом любых программ и задач. Expect может разговаривать с несколькими программами одновременно.

Что ожидать можно сделать

Например, вот некоторые вещи, которые может выполнять команда ожидающих:

Заставьте ваш компьютер перезвонить вам, чтобы вы могли войти в систему, не оплачивая звонок.
Запустите игру и, если оптимальная конфигурация не появится, перезапустите ее снова и снова), пока она не появится, а затем передайте управление вам.
Запустите fsck и, отвечая на его вопросы, ответьте «да» или «нет» или верните контроль, основываясь на заранее определенных критериях.
Подключитесь к другой сети и автоматически получите свою почту, чтобы она выглядела так, как если бы она была первоначально отправлена в вашу локальную систему.
Перенос переменных среды, текущего каталога или любой другой информации через rlogin, telnet, tip, su или chgrp

Существует множество причин, по которым оболочка не может выполнять эти задачи. Все возможно с Expect.

В общем, Expect полезен для запуска любой программы, которая требует взаимодействия между программой и пользователем. Все, что необходимо, — это то, что взаимодействие можно охарактеризовать программно. Expect также может вернуть контроль пользователю, не останавливая контролируемую программу. Точно так же пользователь может вернуть управление скрипту в любое время.

использование

Ожидайте чтения cmdfile для получения списка команд для выполнения. Expect может быть вызван неявно в системах, которые поддерживают #! обозначение, помечая скрипт как исполняемый и делая первую строку в скрипте:

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

Конечно, путь должен точно описывать, где ожидает Expect. / usr / local / bin это просто пример.

Флаг -c предшествует команде, которая будет выполнена перед любой в сценарии. Команда должна быть заключена в кавычки, чтобы предотвратить ее разрушение оболочкой. Эта опция может использоваться несколько раз. Несколько команд могут быть выполнены с одним -c, разделяя их точкой с запятой. Команды выполняются в порядке их появления. При использовании Expectk эта опция указывается как -команда.

Флаг -d включает некоторые диагностические данные, которые в первую очередь сообщают о внутренней активности команд, таких как ожидают и взаимодействуют. Этот флаг имеет тот же эффект, что и «exp_internal 1» в начале сценария Expect, плюс печатается версия Expect.

Флаг -D включает интерактивный отладчик. Целочисленное значение должно следовать. Отладчик получит управление перед следующей процедурой Tcl, если значение не равно нулю, или если нажата ^ C, или достигнута точка останова, или в сценарии появляется другая соответствующая команда отладчика. При использовании Expectk эта опция указывается как —Debug.

Флаг -f предшествует файлу, из которого читаются команды. Сам флаг является необязательным, поскольку он полезен только при использовании #! нотации, так что другие аргументы могут быть предоставлены в командной строке. При использовании Expectk эта опция указывается как -file.

По умолчанию командный файл считывается в память и выполняется полностью. Иногда желательно читать файлы по одной строке за раз. Чтобы принудительно обрабатывать произвольные файлы, используйте флаг -b. При использовании Expectk эта опция указывается как -buffer.

Если в качестве имени файла указана строка «-», вместо него читается стандартный ввод. Используйте «./-» для чтения из файла с именем «-».

Флаг -i заставляет Expect интерактивно запрашивать команды вместо чтения их из файла. Подсказка прекращается с помощью команды выхода или после EOF. Флаг -i предполагается, если не используется ни командный файл, ни -c. При использовании Expectk эта опция указывается как -interactive.

— может использоваться для определения конца параметров. Это полезно, если вы хотите передать опциональный аргумент в ваш скрипт без интерпретации Expect. Это можно с пользой поместить в #! строка, чтобы предотвратить любую флагоподобную интерпретацию Expect. Например, следующее оставит исходные аргументы, включая имя скрипта, в переменной argv.

#! / usr / local / bin / Ожидается -

Обратите внимание, что обычные соглашения getopt (3) и execve (2) должны соблюдаться при добавлении аргументов в #! линия.

Файл $ exp_library / wait.rc автоматически создается при его наличии, если не используется флаг -N. (При использовании Expectk этот параметр указывается как -NORC.) Сразу после этого файл ~ / .expect.rc поступает автоматически, если не используется флаг -n. Если переменная окружения DOTDIR определена, она обрабатывается как каталог и оттуда читается .expect.rc. При использовании Expectk эта опция указывается как -norc. Этот источник происходит только после выполнения любых флагов -c.

-v заставляет Expect распечатать свой номер версии и выйти. Соответствующий флаг в Expectk, который использует длинные имена флагов, это -version.

Необязательные аргументы составляются в виде списка и хранятся в переменной с именем argv и. argc инициализируется до длины argv.

Argv0 определяется как имя сценария или двоичный файл, если сценарий не используется. Например, следующий текст выводит имя скрипта и первые три аргумента:

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

команды

Expect использует Tool Command Language. Tcl обеспечивает поток управления (если, для, разрыв), оценку выражения и ряд других функций, таких как рекурсия и определение процедуры. Команды, используемые здесь, но не определенные (set, if, exec), являются командами Tcl. Expect поддерживает дополнительные команды. Если не указано иное, команды возвращают пустую строку.

Команды перечислены в алфавитном порядке, чтобы их можно было быстро найти. Тем не менее, новым пользователям может быть легче начать с чтения описаний порождения, отправки, ожидания и взаимодействия в указанном порядке.

закрыть [-slave] [-onexec 0 | 1] [-i spawn_id]

закрывает соединение с текущим процессом. Большинство интерактивных программ обнаруживают EOF на своем стандартном входе и выходят; таким образом близко обычно достаточно, чтобы убить процесс. Флаг -i объявляет процесс закрытия в соответствии с именованным spawn_id.

Как ожидают, так и взаимодействуют, обнаружат, когда текущий процесс завершает работу, и неявно закрывают его, но если вы убьете процесс, скажем, «exec kill $ pid», вам нужно явно вызвать close.

Флаг -onexec определяет, закрыт ли идентификатор появления в каких-либо новых порожденных процессах или процесс перекрывается. Чтобы оставить идентификатор спавна открытым, используйте значение 0. Ненулевое целочисленное значение приводит к закрытию спавна в любых новых процессах.

Флаг -slave закрывает подчиненное устройство, связанное с идентификатором появления. Когда соединение закрыто, ведомое устройство также автоматически закрывается, если оно все еще открыто.

Независимо от того, закрыто ли соединение неявно или явно, вы должны вызвать wait, чтобы очистить соответствующий слот процесса ядра. Команда close не вызывает wait, поскольку нет гарантии, что закрытие соединения с процессом приведет к его выходу.

отладка [[-now] 0 | 1]

управляет отладчиком Tcl, позволяя вам проходить через операторы и устанавливать точки останова.

Без аргументов возвращается 1, если отладчик не запущен, в противном случае возвращается 0.

С 1 аргументом отладчик запускается. С аргументом 0 отладчик останавливается. Если аргументу 1 предшествует флаг -now, отладчик запускается немедленно. В противном случае отладчик запускается со следующей инструкцией Tcl.

Команда отладки не меняет никаких ловушек. Сравните это с запуском Expect с флагом -D.

Команда отсоединения отключает разветвленный процесс от терминала. Он продолжает работать в фоновом режиме. Процесс имеет свою собственную группу процессов. Стандартный ввод / вывод перенаправляется в / dev / null.

Следующий фрагмент использует отключение для продолжения работы сценария в фоновом режиме.

 if {[fork]! = 0} выйти
 Отключить
 . . .

Следующий скрипт читает пароль и затем запускает программу каждый час, которая требует пароль каждый раз, когда он запускается. Сценарий предоставляет пароль, поэтому вам нужно будет ввести его только один раз.

 send_user "пароль? \"
 wait_user -re "(. *) \ n"
 для {} 1 {} {
 if {[fork]! = 0} {sleep 3600; продолжить}
 Отключить
 spawn priv_prog
 ожидать пароль:
 отправьте "$pect_out (1, string) \ r"
 . . .
 Выход
 }

Преимущество использования отключения по сравнению с функцией асинхронного процесса оболочки () заключается в том, что Expect может сохранить параметры терминала перед отключением, а затем применить их к новым ptys. С участием , Expect не имеет возможности прочитать параметры терминала, так как терминал уже отключен к тому времени, когда Expect получает управление.

выход [-opts] [статус]

Причины Ожидать выхода или иным образом подготовиться к этому.

-OnExit Флаг заставляет следующий аргумент использоваться в качестве обработчика выхода. Без аргумента текущий обработчик выхода возвращается.

-выхода нет флаг причины ожидать подготовиться к выходу, но не остановиться на фактическом возвращении управления операционной системе. Определяемый пользователем обработчик выхода запускается так же, как и собственные внутренние обработчики Expect. Дальнейшие команды Expect не должны выполняться. Это полезно, если вы используете Expect с другими расширениями Tcl. Текущий интерпретатор (и главное окно, если оно находится в среде Tk) остается таким образом, что другие расширения Tcl могут очищаться. Если ожидать Выход вызывается снова (однако это может произойти), обработчики не запускаются повторно.

При выходе все соединения с порожденными процессами закрываются. Закрытие будет обнаружено как EOF порожденными процессами. Выход не предпринимает никаких других действий, кроме того, что делает обычная процедура _exit (2). Таким образом, порожденные процессы, которые не проверяют EOF, могут продолжать работать. (Различные условия важны для определения, например, сигналов, которые будут отправлены порожденные процессы, но они зависят от системы, как правило, документированы в exit (3).) Порожденные процессы, которые продолжают выполняться, будут наследоваться init.

статус (или 0, если не указан) возвращается как статус выхода ожидать . Выход выполняется неявно, если достигнут конец сценария.

exp_continue [-continue_timer]

Команда exp_continue позволяет ожидать Сам продолжать выполнение, а не возвращаться, как обычно. По умолчанию exp_continue сбрасывает таймер тайм-аута. Флаг -continue_timer предотвращает перезапуск таймера. (Видеть ожидать для дополнительной информации.)

exp_internal [-f file] значение

вызывает дальнейшие команды для отправки диагностической информации внутри ожидать в stderr, если значение не равно нулю. Этот вывод отключается, если значение равно 0. Диагностическая информация включает в себя каждый полученный символ и каждую попытку, сделанную для сопоставления текущего вывода с шаблонами.

Если указан необязательный файл, все обычные и отладочные выходные данные записываются в этот файл (независимо от значения value). Любой предыдущий диагностический выходной файл закрыт.

-Информация флаг заставляет exp_internal возвращать описание самых последних неинформационных аргументов.

exp_open [args] [-i spawn_id]

возвращает идентификатор файла Tcl, который соответствует исходному идентификатору spawn. Идентификатор файла может быть использован, как если бы он был открыт Tcl открытый команда. (Идентификатор появления больше не должен использоваться. A Подождите не должен быть выполнен.

-leaveopen флаг оставляет открытый идентификатор для доступа через команды Expect. Подождите должен быть выполнен на ИД вызова.

exp_pid [-i spawn_id]

возвращает идентификатор процесса, соответствующий текущему процессу. Если -я используется флаг, возвращаемый pid соответствует идентификатору данного идентификатора spawn.

exp_send

это псевдоним для Отправить .

exp_send_error

это псевдоним для SEND_ERROR .

exp_send_log

это псевдоним для send_log .

exp_send_tty

это псевдоним для send_tty .

exp_send_user

это псевдоним для send_user .

exp_version [[-exit] версия]

полезно для гарантии того, что скрипт совместим с текущей версией Expect.

Без аргументов текущая версия ожидать возвращается Эта версия может быть закодирована в вашем скрипте. Если вы действительно знаете, что не используете функции последних версий, вы можете указать более раннюю версию.

Версии состоят из трех чисел, разделенных точками. Во-первых, это основной номер. Скрипты написаны для версий ожидать с другим основным номером почти наверняка не сработает. exp_version возвращает ошибку, если основные числа не совпадают.

Второе — младший номер. Сценарии, написанные для версии с большим младшим номером, чем текущая версия, могут зависеть от какой-либо новой функции и могут не работать. exp_version возвращает ошибку, если основные номера совпадают, но младший номер скрипта больше, чем у запущенного ожидать .

Третье — число, которое не играет никакой роли в сравнении версий. Тем не менее, он увеличивается, когда ожидать Распространение программного обеспечения изменяется любым способом, например, путем дополнительной документации или оптимизации. Он сбрасывается в 0 при каждой новой минорной версии.

С -Выход флаг, ожидать выдает ошибку и завершает работу, если версия устарела.

ожидайте [[-opts] pat1 body1] … [-opts] patn [bodyn]

ожидает, пока один из шаблонов не совпадет с выводом порожденного процесса, пройдет указанный период времени или не будет обнаружен конец файла. Если окончательное тело пусто, оно может быть опущено.

Шаблоны из самых последних expect_before Команда неявно используется перед любыми другими шаблонами. Шаблоны из самых последних expect_after Команда неявно используется после любых других шаблонов.

Если аргументы для всего ожидать Для оператора требуется более одной строки, все аргументы могут быть «заключены» в одну, чтобы избежать завершения каждой строки обратной косой чертой. В этом одном случае обычные замены Tcl будут происходить, несмотря на скобки.

Если шаблон является ключевым словом ВФ , соответствующее тело выполняется в конце файла. Если шаблон является ключевым словом тайм-аут, соответствующее тело выполняется по таймауту. Если ключевое слово timeout не используется, по истечении времени ожидания выполняется неявное нулевое действие. Период ожидания по умолчанию составляет 10 секунд, но его можно установить, например, 30, командой «установить время ожидания 30». Бесконечное время ожидания может быть обозначено значением -1. Если шаблон является ключевым словом по умолчанию , соответствующее тело выполняется по истечении времени ожидания или конца файла.

Если шаблон соответствует, то выполняется соответствующее тело. ожидать возвращает результат тела (или пустую строку, если не найдено ни одного шаблона). В случае совпадения нескольких шаблонов один, который появляется первым, используется для выбора тела.

Каждый раз, когда поступает новый вывод, он сравнивается с каждым шаблоном в порядке их перечисления. Таким образом, вы можете проверить отсутствие совпадения, сделав последний шаблон таким, который гарантированно появится, например, приглашение. В ситуациях, когда нет подсказки, вы должны использовать Тайм-аут (так же, как если бы вы взаимодействовали вручную).

Шаблоны указываются тремя способами. По умолчанию шаблоны указываются как с Tcl совпадение строк команда. (Такие шаблоны также похожи на регулярные выражения C-shell, обычно называемые шаблонами «glob»). -Г.Л. Флаг может быть использован для защиты шаблонов, которые в противном случае могут соответствовать ожидать флаги от этого. Любой шаблон, начинающийся с «-«, должен быть защищен таким образом. (Все строки, начинающиеся с «-», зарезервированы для будущих опций.)

Например, следующий фрагмент ищет успешный вход в систему. (Обратите внимание, что выкинуть предполагается, что это процедура, определенная в другом месте скрипта.)

 ожидать {
 занят {ставит занят \ n; exp_continue}
 не удалось прервать
 «неверный пароль» прервать
 тайм-аут
 связано
 }

Кавычки необходимы для четвертого шаблона, поскольку он содержит пробел, который в противном случае отделил бы шаблон от действия. Шаблоны с одинаковым действием (например, 3-е и 4-е) требуют повторного перечисления действий. Этого можно избежать, используя шаблоны в стиле регулярных выражений (см. Ниже). Более подробную информацию о формировании шаблонов в стиле glob можно найти в руководстве по Tcl.

Шаблоны в стиле регулярных выражений следуют синтаксису, определенному Tcl регулярное выражение (сокращение от «регулярное выражение»). Шаблоны регулярных выражений вводятся с флагом -ре . Предыдущий пример можно переписать с помощью регулярного выражения:

 ожидать {
 занят {ставит занят \ n; exp_continue}
 -"сбой | неверный пароль" прервать
 тайм-аут
 связано
 }

Оба типа паттернов являются «незанятыми». Это означает, что шаблоны не должны совпадать со всей строкой, но могут начинать и заканчивать сопоставление в любом месте строки (при условии, что все остальное совпадает). Используйте ^, чтобы соответствовать началу строки, и $, чтобы соответствовать концу. Обратите внимание, что если вы не дождетесь конца строки, ваши ответы могут легко оказаться в середине строки, поскольку они отражаются в порожденном процессе. Несмотря на то, что результаты по-прежнему правильные, результат может выглядеть неестественно Таким образом, использование $ рекомендуется, если вы можете точно описать символы в конце строки.

Обратите внимание, что во многих редакторах ^ и $ соответствуют началу и концу строк соответственно. Тем не менее, так как ожидание не ориентировано на строки, эти символы соответствуют началу и концу данных (в отличие от строк), которые в настоящее время находятся в буфере ожидаемого соответствия. (Также см. Примечание ниже о «расстройстве желудка».)

-бывший флаг заставляет образец быть сопоставленным как «точная» строка. Интерпретация *, ^ и т. Д. Не производится (хотя обычные соглашения Tcl все еще должны соблюдаться). Точные шаблоны всегда остаются без внимания.

-NoCase Параметр flag сравнивает прописные символы вывода, как если бы они были строчными. На шаблон это не влияет.

При чтении выходных данных более 2000 байтов могут заставить «забытые» ранние байты. Это может быть изменено с помощью функции match_max . (Обратите внимание, что слишком большие значения могут замедлить сопоставление с образцом.) Если patlist full_buffer , соответствующее тело выполняется, если были получены байты match_max и не найдено ни одного другого шаблона. Будь или нет full_buffer используется ключевое слово, забытые символы записываются в функцию ожидаемого выхода (буфер).

Если ключевое слово patlist значение NULL , и нули допускаются (через remove_nulls команда), соответствующее тело выполняется, если соответствует один ASCII 0. Невозможно сопоставить 0 байтов с помощью шаблонов glob или regexp.

После сопоставления с шаблоном (или eof или full_buffer) все совпадающие и ранее несопоставленные выходные данные сохраняются в переменной wait_out (buffer). До 9 совпадений подстрок regexp сохраняются в переменные между ожидаемыми (1, строка) и ожидаемыми (9, строка). Если -индексы перед шаблоном используется флаг, начальный и конечный индексы (в форме, подходящей для lrange ) из 10 строк хранятся в переменных ожидаемых (X, начало) и ожидаемых (X, конец), где X является цифрой, соответствует позиции подстроки в буфере. 0 относится к строкам, которые соответствуют всему шаблону и генерируются для шаблонов глобуса, а также шаблонов регулярных выражений. Например, если процесс выдал вывод «abcdefgh \ n», результат:

 ожидать "CD"

это как если бы следующие операторы выполнили:

 установить функцию ожидаемого выхода (0, строка)
 установить Expect_out (буфер) abcd

и «efgh \ n» остается в буфере вывода. Если процесс выдает вывод «abbbcabkkkka \ n», результат:

 ожидайте -indices -re "b (b *). * (k +)"

это как если бы следующие операторы выполнили:

 установить функцию ожидаемого выхода (0, начало) 1
 установить функцию ожидаемого выхода (0, конец) 10
 установить функцию wait_out (0, строка) bbbcabkkkk
 установить функцию ожидаемого выхода (1, начало) 2
 установить функцию ожидаемого выхода (1, конец) 3
 установить функцию wait_out (1, строка) bb
 установить функцию ожидаемого выхода (2, начало) 10
 установить функцию ожидаемого выхода (2, конец) 10
 установить функцию wait_out (2, строка) k
 установить wait_out (buffer) abbbcabkkkk

и «a \ n» остается в буфере вывода. Шаблон «*» (и -re «. *») Очистит выходной буфер, не считывая больше выходных данных процесса.

Обычно согласованный вывод отбрасывается из внутренних буферов Expect. Этого можно избежать, добавив префикс шаблона к -notransfer флаг. Этот флаг особенно полезен при экспериментировании (и может быть сокращен до «-не» для удобства при экспериментировании).

Идентификатор порождения, связанный с совпадающим выводом (или eof или full_buffer), сохраняется в wait_out (spawn_id).

-Тайм-аут флаг заставляет текущую команду ожидаемого использовать следующее значение в качестве тайм-аута вместо использования значения переменной тайм-аута.

По умолчанию шаблоны сопоставляются с выходными данными текущего процесса, однако -я флаг объявляет, что выходные данные из именованного списка spawn_id сопоставляются с любыми следующими шаблонами (до следующего -я ). Список spawn_id должен быть либо списком spawn_ids, разделенным пробелами, либо переменной, ссылающейся на такой список spawn_ids.

Например, в следующем примере ожидается «подключено» из текущего процесса или «занято», «не удалось» или «неверный пароль» из spawn_id, названного $ proc2.

 ожидать {
 -я $ proc2 занят {ставит занят \ n; exp_continue}
 -"сбой | неверный пароль" прервать
 тайм-аут
 связано
 }

Значение глобальной переменной any_spawn_id может использоваться для сопоставления шаблонов с любыми spawn_ids, которые названы со всеми другими -я флаги в текущем ожидать команда. Spawn_id от -я флаг без ассоциированного шаблона (то есть, сопровождаемый сразу другим -я ) доступен для любых других шаблонов в том же ожидать команда, связанная с any_spawn_id.

-я Флаг также может называть глобальную переменную, и в этом случае переменная считывается для списка идентификаторов порождения. Переменная перечитывается всякий раз, когда она изменяется. Это позволяет изменить источник ввода-вывода во время выполнения команды. Идентификаторы появления, предоставляемые таким способом, называются «косвенными» идентификаторами появления.

Действия, такие как сломать а также Продолжить вызывать управляющие структуры (т.е. за , процедура ) вести себя обычным образом. Команда exp_continue позволяет ожидать Сам продолжать выполнение, а не возвращаться, как обычно.

Это полезно для избежания явных циклов или повторных ожиданий. Следующий пример является частью фрагмента для автоматизации rlogin. exp_continue избегает необходимости писать вторую ожидать оператор (чтобы искать приглашение снова), если rlogin запрашивает пароль.

 ожидать {
 Пароль: {
 stty -echo
 send_user "пароль (для $ user) на $ host:"
 wait_user -re "(. *) \ n"
 send_user "\ n"
 отправьте "$pect_out (1, string) \ r"
 стое эхо
 exp_continue
 } неверный {
 send_user "неверный пароль или учетная запись \ n"
 Выход
 } timeout {
 send_user "тайм-аут соединения с $ host \ n"
 Выход
 } eof {
 send_user \
 msgstr "не удалось подключиться к хосту: $ wait_out (buffer)"
 Выход
 } -re $ prompt
 }

Например, следующий фрагмент может помочь пользователю управлять взаимодействием, которое уже полностью автоматизировано. В этом случае терминал переводится в сырой режим. Если пользователь нажимает «+», переменная увеличивается. Если нажать «p», в процесс будет отправлено несколько возвратов, возможно, чтобы каким-то образом ткнуть его, а «i» позволяет пользователю взаимодействовать с процессом, эффективно скрывая контроль над сценарием. В каждом случае exp_continue позволяет текущий ожидать продолжить сопоставление с образцом после выполнения текущего действия.

 stty raw -echo
 ожидать_после {
 -я $ user_spawn_id
 "p" {send "\ r \ r \ r"; exp_continue}
 "+" {incr foo; exp_continue}
 "я" {взаимодействовать; exp_continue}
 «выйти» выход
 }

По умолчанию, exp_continue сбрасывает таймер тайм-аута. Таймер не перезапускается, если exp_continue называется с -continue_timer флаг.

wait_after [Ожидаемые_арги]

работает идентично expect_before за исключением того, что если шаблоны из обоих ожидать а также expect_after может соответствовать, ожидать шаблон используется. Увидеть expect_before Команда для получения дополнительной информации.

wait_background [Ожидаемые_арги]

принимает те же аргументы, что и ожидать , Однако это возвращается немедленно. Шаблоны проверяются всякий раз, когда поступает новый ввод. Шаблон Тайм-аут а также по умолчанию бессмысленно expect_background и молча отбрасываются. В противном случае expect_background команда использует expect_before а также expect_after шаблоны так же, как ожидать делает.

когда expect_background Действия оцениваются, фоновая обработка для того же идентификатора вызова блокируется. Фоновая обработка разблокируется после завершения действия. В то время как фоновая обработка заблокирована, можно сделать (передний план) ожидать на том же самом порождении

Невозможно выполнить ожидать в то время как expect_background разблокирован expect_background для определенного спавна id удаляется, если объявить новый wait_background с тем же идентификатором spawn. декларирование expect_background без шаблона удаляет указанный идентификатор появления из способности сопоставлять шаблоны на заднем плане.

wait_before [wait_args]

принимает те же аргументы, что и ожидать, однако, это возвращается немедленно. Пары Pattern-action из самых последних expect_before с тем же идентификатором spawn неявно добавляются к любому следующему ожидать команды. Если шаблон соответствует, он обрабатывается так, как если бы он был указан в ожидать сама команда, и связанное тело выполняется в контексте ожидать команда. Если шаблоны из обоих expect_before а также ожидать может соответствовать, expect_before шаблон используется.

Прочтите: Как использовать команду установки в Linux

Если шаблон не указан, идентификатор spawn не проверяется на наличие шаблонов.

Если не отменено -я флаг, expect_before шаблоны соответствуют идентификатору порождения, определенному в то время, когда expect_before Команда была выполнена (не при совпадении ее шаблона).

Флаг -info вызывает expect_before вернуть текущие спецификации того, какие шаблоны будут соответствовать. По умолчанию он сообщает о текущем spawn id. Необязательная спецификация spawn id может быть предоставлена для информации об этом spawn id. Например

wait_before -info -i $ proc

Можно указать не более одной спецификации идентификатора вызова. Флаг -indirect подавляет идентификаторы прямого появления, которые приходят только из косвенных спецификаций.

Вместо спецификации идентификатора порождения флаг «-all» заставит «-info» сообщать обо всех идентификаторах порождения.

Вывод флага -info может быть повторно использован в качестве аргумента для ожидаемого_переда.

wait_tty [Ожидаемые_арги]

как ожидать но он читает символы из / dev / tty (то есть нажатия клавиш пользователем). По умолчанию чтение выполняется в готовом режиме. Таким образом, строки должны заканчиваться возвратом для того, чтобы ожидать чтобы увидеть их. Это может быть изменено через Запущенная (см. Запущенная команда ниже).

wait_user [Ожидаемые_арги]

как ожидать но он читает символы из стандартного ввода (то есть нажатия клавиш пользователем). По умолчанию чтение выполняется в готовом режиме. Таким образом, строки должны заканчиваться возвратом для того, чтобы ожидать чтобы увидеть их. Это может быть изменено через Запущенная (см. Запущенная команда ниже).

вилка

создает новый процесс. Новый процесс является точной копией текущего ожидать процесс. В случае успеха, вилка возвращает 0 новому (дочернему) процессу и возвращает идентификатор процесса дочернего процесса в родительский процесс. При сбое (неизменно из-за недостатка ресурсов, например, места подкачки, памяти), вилка возвращает -1 родительскому процессу, и дочерний процесс не создается.

Завершенные процессы выходят через Выход Команда, как и в оригинальном процессе. Разветвленным процессам разрешено записывать в файлы журнала. Если вы не отключите отладку или регистрацию в большинстве процессов, результат может привести к путанице.

Некоторые реализации pty могут быть сбиты с толку множеством читателей и авторов даже на мгновение. Таким образом, наиболее безопасно вилка до нерестовых процессов.

взаимодействовать [string1 body1] … [stringn [bodyn]]

дает контроль над текущим процессом пользователю, чтобы нажатия клавиш отправлялись текущему процессу, а возвращались stdout и stderr текущего процесса.

В качестве аргументов могут быть заданы пары строка-тело, и в этом случае тело выполняется при вводе соответствующей строки. (По умолчанию строка не отправляется текущему процессу.) переводчик Команда предполагается, если окончательное тело отсутствует.

Если аргументы для всего взаимодействовать Для оператора требуется более одной строки, все аргументы могут быть «заключены» в одну, чтобы избежать завершения каждой строки обратной косой чертой. В этом одном случае обычные замены Tcl будут происходить, несмотря на скобки.

Например, следующие запуски команд взаимодействуют со следующими определенными парами строка-тело: при нажатии ^ Z ожидать приостановлено (The -сброс флаг восстанавливает режимы терминала.) Когда нажимается ^ A, пользователь видит «вы ввели элемент управления-A», и процесс отправляет ^ A. Когда $ нажата, пользователь видит дату. Когда ^ C нажата, ожидать выходы. Если введено «foo», пользователь видит «bar». Когда ~~ нажата, ожидать переводчик работает в интерактивном режиме.

set CTRLZ \ 032 взаимодействовать {-reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "вы ввели элемент управления-A \ n"; send "\ 001"} $ {send_user "Дата: [формат часов [часы в секундах]]."} \ 003 exit foo {send_user "bar"} ~~}

В парах строка-тело строки сопоставляются в порядке их перечисления в качестве аргументов. Частично совпадающие строки не отправляются текущему процессу в ожидании прихода остатка. Если символы вводятся таким образом, что совпадение больше не может быть, только часть строки будет отправлена процессу, который не может начать другое совпадение. Таким образом, строки, являющиеся подстроками частичных совпадений, могут совпадать позже, если исходные строки, которые пытались найти совпадения, в конечном итоге терпят неудачу.

По умолчанию сопоставление строк является точным без подстановочных знаков. (В отличие от ожидать По умолчанию команда использует шаблоны в стиле glob.) -бывший флаг может использоваться для защиты шаблонов, которые в противном случае могли бы соответствовать взаимодействовать флаги от этого. Любой шаблон, начинающийся с «-«, должен быть защищен таким образом. (Все строки, начинающиеся с «-», зарезервированы для будущих опций.)

-ре flag заставляет строку интерпретироваться как шаблон в стиле регулярных выражений. В этом случае совпадающие подстроки сохраняются в переменной Intera_out аналогично тому, как ожидать сохраняет свой вывод в переменной expect_out . -индексы флаг поддерживается аналогичным образом.

Шаблон ВФ вводит действие, которое выполняется в конце файла. Отдельный ВФ шаблон может также следовать -выход флаг, в этом случае он совпадает, если eof обнаружен во время записи вывода. По умолчанию ВФ действие — это «возврат», так что взаимодействовать просто возвращается на любой EOF.

Шаблон Тайм-аут вводит время ожидания (в секундах) и действие, которое выполняется после того, как никакие символы не были прочитаны в течение заданного времени. Тайм-аут шаблон применяется к самому последнему указанному процессу. Тайм-аут по умолчанию отсутствует. Специальная переменная «timeout» (используется ожидать команда) не влияет на это время ожидания.

Например, следующий оператор может быть использован для автозапуска пользователей, которые ничего не печатали в течение часа, но которые все еще получают частые системные сообщения:

взаимодействовать -вход $ user_spawn_id тайм-аут 3600 return -output \ $ spawn_id

Если шаблон является ключевым словом значение NULL , и нули допускаются (через remove_nulls команда), соответствующее тело выполняется, если соответствует один ASCII 0. Невозможно сопоставить 0 байтов с помощью шаблонов glob или regexp.

Предварительная установка шаблона с флагом -Я пишу приводит к тому, что переменная interactive_out (spawn_id) устанавливается в spawn_id, который соответствует шаблону (или eof).

Действия, такие как сломать а также Продолжить вызывать управляющие структуры (т.е. за , процедура ) вести себя обычным образом. тем не мение вернуть заставляет взаимодействие возвращаться к своему вызывающему inter_return причины взаимодействовать чтобы вызвать возврат в его вызывающей стороне. Например, если «proc foo» называется взаимодействовать который затем выполнил действие inter_return , proc foo вернется. (Это означает, что если взаимодействовать звонки переводчик интерактивно печатать вернуть заставит взаимодействие продолжаться, пока inter_return заставит интерактив вернуться к своему вызывающему.)

В течение взаимодействовать , Режим raw используется для того, чтобы все символы могли быть переданы в текущий процесс. Если текущий процесс не улавливает сигналы управления заданиями, он остановится, если будет отправлен сигнал остановки (по умолчанию ^ Z). Чтобы перезапустить его, отправьте сигнал продолжения (например, «kill -CONT»). Если вы действительно хотите отправить SIGSTOP в такой процесс (с помощью ^ Z), попробуйте сначала запустить csh, а затем запустить вашу программу. С другой стороны, если вы хотите отправить SIGSTOP на ожидать сам, сначала вызовите интерпретатор (возможно, с помощью escape-символа), а затем нажмите ^ Z.

Пары «строка-тело» можно использовать как сокращение, чтобы избежать необходимости вводить интерпретатор и выполнять команды в интерактивном режиме. Предыдущий режим терминала используется во время выполнения тела пары строка-тело.

Для скорости действия выполняются в необработанном режиме по умолчанию. -сброс флаг сбрасывает терминал в режим, в котором он был раньше взаимодействовать был выполнен (неизменно, приготовленный режим). Обратите внимание, что символы, введенные при переключении режима, могут быть потеряны (неудачная функция драйвера терминала в некоторых системах). Единственная причина использовать -сброс если ваше действие зависит от запуска в готовом режиме.

-эхо flag отправляет символы, соответствующие следующему шаблону, процессу, который их сгенерировал, при чтении каждого символа. Это может быть полезно, когда пользователь должен видеть обратную связь от частично типизированных шаблонов.

Если шаблон отражается, но в конечном итоге не совпадает, символы отправляются в порожденный процесс. Если порожденный процесс затем повторяет их, пользователь увидит символы дважды. -эхо вероятно, уместно только в ситуациях, когда пользователь вряд ли не завершит шаблон. Например, следующий фрагмент взят из rftp, сценария рекурсивного ftp, где пользователю предлагается ввести ~ g, ~ p или ~ l, чтобы рекурсивно получить, поместить или вывести список текущего каталога. Они настолько далеки от обычных команд ftp, что пользователь вряд ли наберет ~, а затем что-нибудь еще, кроме по ошибке, и в этом случае они, скорее всего, просто проигнорируют результат.

взаимодействовать {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}

-nobuffer Флаг отправляет символы, соответствующие следующему шаблону, в процесс вывода при чтении символов.

Это полезно, когда вы хотите, чтобы программа повторила шаблон. Например, следующее может использоваться для отслеживания того, где набирает человек (модем в стиле Хейса). Каждый раз, когда «atd» виден, скрипт регистрирует остаток строки.

proc lognumber {} {взаимодействовать -nobuffer -re "(. *) \ r" возвращение помещает $ log "[формат часов [часы секунд]]: набранный $ взаимодействовать (1, строка)"} взаимодействовать -nobuffer "atd" номер журнала

В течение взаимодействовать , предыдущее использование log_user игнорируется В частности, взаимодействовать принудительно зарегистрирует свой вывод (отправит на стандартный вывод), поскольку предполагается, что пользователь не хочет взаимодействовать вслепую.

-о флаг заставляет любые последующие пары ключ-тело применяться к выходным данным текущего процесса. Это может быть полезно, например, при работе с хостами, которые отправляют нежелательные символы во время сеанса telnet.

По умолчанию, взаимодействовать ожидает, что пользователь будет писать стандартный ввод и читать стандартный вывод ожидать сам процесс. -U флаг (для «пользователя») делает взаимодействовать ищите пользователя как процесс, названный его аргументом (который должен быть порожденным идентификатором).

Это позволяет объединять два несвязанных процесса без использования явного цикла. Чтобы помочь в отладке, диагностическая программа Expect всегда идет в stderr (или stdout для получения определенной информации о протоколировании и отладке). По той же причине переводчик Команда будет читать в интерактивном режиме из стандартного ввода.

Например, следующий фрагмент создает процесс входа в систему. Затем он набирает пользователя (не показан) и, наконец, соединяет их вместе. Конечно, любой процесс может заменить логин. Оболочка, например, позволит пользователю работать без указания учетной записи и пароля.

spawn login set login $ spawn_id spawn tip modem # снова подключиться к пользователю # подключить пользователя для входа взаимодействовать -u $ login

Чтобы отправить вывод нескольким процессам, перечислите каждый список идентификаторов порождения, предваряемый -выход флаг. Вход для группы выходных идентификаторов порождения может быть определен списком идентификаторов порождения, предваряемым -вход флаг. (Обе -вход а также -выход может принимать списки в той же форме, что и -я флаг в ожидать команда, за исключением того, что any_spawn_id не имеет смысла в взаимодействовать .) Все следующие флаги и строки (или шаблоны) применяются к этому вводу, пока не появится другой флаг -input. Если нет -вход оказывается, -выход подразумевает «-input $ user_spawn_id -output». (Точно так же с шаблонами, которые не имеют -вход .) Если один -вход указан, он переопределяет $ user_spawn_id. Если второй -вход указан, он переопределяет $ spawn_id. дополнительный -вход флаги могут быть указаны.

По умолчанию для двух подразумеваемых процессов ввода их выходные данные определены как $ spawn_id и $ user_spawn_id (в обратном порядке). Если -вход флаг появляется без -выход флаг, символы из этого процесса отбрасываются.

-я флаг вводит замену для текущего spawn_id, когда нет других -вход или же -выход флаги используются. Флаг -i подразумевает флаг -o.

Можно изменить процессы, с которыми взаимодействуют, используя косвенные идентификаторы порождения. (Идентификаторы косвенного вызова описаны в разделе о команде ожидаемого.) Идентификаторы косвенного вызова могут быть указаны с помощью флагов -i, -u, -input или -output.

переводчик [args]

вызывает интерактивное приглашение пользователя ожидать и команды Tcl. Результат каждой команды печатается.

Действия, такие как сломать а также Продолжить вызывать управляющие структуры (т.е. за , процедура ) вести себя обычным образом. тем не мение вернуть заставляет переводчика возвращаться к вызывающему inter_return причины переводчик чтобы вызвать возврат в его вызывающей стороне. Например, если «proc foo» называется переводчик который затем выполнил действие inter_return , proc foo вернется. Любая другая команда вызывает переводчик продолжить запрашивать новые команды.

По умолчанию подсказка содержит два целых числа. Первое целое число описывает глубину стека оценки (т. Е. Сколько раз был вызван Tcl_Eval). Второе целое число — идентификатор истории Tcl. Подсказка может быть установлена путем определения процедуры с именем «prompt1», возвращаемое значение которой становится следующей подсказкой. Если в операторе есть открытые кавычки, скобки, скобки или квадратные скобки, после новой строки выдается дополнительная подсказка (по умолчанию «+>»). Вторичный запрос может быть установлен путем определения процедуры, называемой «prompt2».

В течение переводчик , Режим «кулинарный» используется, даже если вызывающий абонент использовал режим «сырой».

Если стандартный ввод закрыт, переводчик вернется, если -ВФ используется флаг, и в этом случае вызывается следующий аргумент.

файл_файла [args] [[-a] файл]

Если указано имя файла, журнальный файл запишет стенограмму сеанса (начиная с этого момента) в файл. журнальный файл остановит запись, если аргумент не указан. Любой предыдущий файл журнала закрыт.

Вместо имени файла можно указать идентификатор файла Tcl, используя -открытый или же -leaveopen флаги. Это похоже на порождать команда. (Видеть порождать для получения дополнительной информации.)

— флаг вынуждает регистрировать вывод, который был подавлен log_user команда.

По умолчанию журнальный файл Команда добавляет к старым файлам, а не обрезает их, для удобства возможности выключать и включать вход несколько раз за один сеанс. Чтобы обрезать файлы, используйте -noappend флаг.

-Информация Флаг заставляет log_file возвращать описание самых последних неинформационных аргументов.

log_user -info | 0 | 1

По умолчанию диалог отправки / ожидания записывается в стандартный вывод (и файл журнала, если он открыт). Запись в stdout отключена командой «log_user 0» и повторно включена «log_user 1». Запись в лог-файл не изменилась.

-Информация флаг заставляет log_user возвращать описание самых последних неинформационных аргументов.

match_max [-d] [-i spawn_id] [размер]

определяет размер буфера (в байтах), используемого внутри ожидать . Без аргумента размера текущий размер возвращается.

С -d флаг, размер по умолчанию установлен. (Начальное значение по умолчанию — 2000.) С -я флаг, размер устанавливается для именованного идентификатора порождения, в противном случае он устанавливается для текущего процесса.

оверлей [- # spawn_id] [- # spawn_id] […] программа [аргументы]

выполняет «программные аргументы» вместо текущего ожидать программа, которая заканчивается. Пустой аргумент дефиса ставит дефис перед именем команды, как если бы это была оболочка входа в систему. Все spawn_ids закрыты, за исключением тех, которые названы в качестве аргументов. Они отображаются на именованные идентификаторы файлов.

Spawn_ids отображаются в идентификаторы файлов для новой программы для наследования. Например, следующая строка запускает шахматы и позволяет им управлять текущим процессом — скажем, мастером по шахматам.

оверлей -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id шахматы

Это более эффективно, чем «взаимодействовать -u», однако оно жертвует возможностью выполнять запрограммированное взаимодействие, так как ожидать процесс больше не контролируется.

Обратите внимание, что управляющий терминал не предоставляется. Таким образом, если вы отключите или переназначите стандартный ввод, программы, которые выполняют управление заданиями (оболочки, логин и т. Д.), Не будут работать должным образом.

четность [-d] [-i spawn_id] [значение]

определяет, должен ли паритет сохраняться или удаляться из результатов порожденных процессов. Если значение равно нулю, четность удаляется, в противном случае она не удаляется. Если аргумент не указан, возвращается текущее значение.

С -d флаг, значение четности по умолчанию установлено. (Исходное значение по умолчанию — 1, т. Е. Четность не удаляется.) -я флаг, значение четности устанавливается для именованного идентификатора порождения, в противном случае оно устанавливается для текущего процесса.

remove_nulls [-d] [-i spawn_id] [значение]

определяет, будут ли нулевые значения сохраняться или удаляться из выходных данных порожденных процессов перед сопоставлением с образцом или сохранением в переменной Ожидаемые или Взаимодействующие. Если значение равно 1, нули удаляются. Если значение равно 0, нули не удаляются. Если аргумент не указан, возвращается текущее значение.

С -d флаг, значение по умолчанию установлено. (Начальное значение по умолчанию — 1, т. Е. Нули удаляются.) -я флаг, значение устанавливается для именованного идентификатора порождения, в противном случае оно устанавливается для текущего процесса.

Независимо от того, удаляются ли нули, ожидать будет записывать нулевые байты в журнал и стандартный вывод.

отправить строку [-flags]

Отправляет строку в текущий процесс. Например, команда

отправить "привет мир"

отправляет символы, которые будут отображаться в текущем процессе. (Tcl включает в себя команду, похожую на printf (называется формат ) которые могут строить произвольно сложные строки.)

Символы отправляются немедленно, хотя программы с входным буферизованным вводом не будут читать символы, пока не будет отправлен символ возврата. Возвращаемый символ обозначается как «\ r».

— flag заставляет следующий аргумент интерпретироваться как строку, а не как флаг. Любой строке может предшествовать «-», независимо от того, действительно ли она выглядит как флаг. Это обеспечивает надежный механизм для указания переменных строк без отключения тех, которые случайно выглядят как флаги. (Все строки, начинающиеся с «-», зарезервированы для будущих опций.)

-я Флаг объявляет, что строка отправляется по имени spawn_id. Если spawn_id равен user_spawn_id, а терминал находится в необработанном режиме, новые строки в строке преобразуются в последовательности return-newline, чтобы они выглядели так, как если бы терминал находился в готовом режиме. -сырье флаг отключает этот перевод.

-значение NULL флаг отправляет нулевые символы (0 байт). По умолчанию отправляется один ноль. Целое число может следовать за -значение NULL указать, сколько нулей отправить.

-сломать флаг генерирует условие разрыва. Это имеет смысл, только если идентификатор spawn относится к tty устройству, открытому через «spawn -open». Если вы породили такой процесс, как tip, вы должны использовать соглашение tip для генерации перерыва.

-s флаг заставляет вывод отправляться «медленно», что позволяет избежать распространенной ситуации, когда компьютер набирает тип входного буфера, который был разработан для человека, который никогда не будет превышать тот же буфер. Эти выходные данные контролируются значением переменной «send_slow», которая принимает список из двух элементов. Первый элемент — это целое число, которое описывает количество байтов, отправляемых атомарно. Второй элемент — это действительное число, которое описывает количество секунд, на которые атомные отправления должны быть разделены. Например, «set send_slow {10 .001}» заставит «send -s» отправлять строки с интервалом в 1 миллисекунду между каждыми 10 отправленными символами.

-час флаг заставляет вывод (что-то) отправлять, как будто человек печатает. Человеческие задержки появляются между персонажами. (Алгоритм основан на распределении Вейбулла с модификациями, подходящими для данного конкретного приложения.) Эти выходные данные контролируются значением переменной «send_human», которая принимает список из пяти элементов. Первые два элемента — это среднее время прохождения символов в секундах. Первый используется по умолчанию. Второй используется в конце слов, чтобы имитировать тонкие паузы, которые иногда возникают при таких переходах. Третий параметр представляет собой меру изменчивости, где .1 является достаточно переменным, 1 является достаточно переменным, а 10 является совершенно неизменным. Крайности от 0 до бесконечности. Последние два параметра — это, соответственно, минимальное и максимальное время взаимодействия. Минимум и максимум используются последним и «обрезают» последний раз. Конечное среднее значение может сильно отличаться от заданного среднего, если для минимального и максимального значения клипа достаточно.

Например, следующая команда эмулирует быструю и последовательную машинистку:

set send_human {.1 .3 1 .05 2} send -h "Я голоден. Давай пообедаем."

в то время как следующее может быть более подходящим после похмелья:

set send_human {.4 .4 .2 .5 100} send -h "Хорошая вечеринка!"

Обратите внимание, что ошибки не моделируются, хотя вы можете сами настроить ситуации с исправлением ошибок, встраивая ошибки и исправления в аргумент отправки.

Флаги для отправки нулевых символов, для отправки разрывов, для принудительного медленного вывода и для вывода в человеческом стиле являются взаимоисключающими. Будет использоваться только последний указанный. Кроме того, нельзя указывать строковый аргумент с флагами для отправки нулевых символов или разрывов.

Хорошей идеей будет предшествовать первому Отправить к процессу ожидать. ожидать будет ждать начала процесса, пока Отправить не можешь. В частности, если первый Отправить завершается до запуска процесса, вы рискуете игнорировать ваши данные. В ситуациях, когда интерактивные программы не предлагают начальную подсказку, вы можете предшествовать Отправить с задержкой как в:

# Чтобы не давать хакерам подсказки о том, как взломать, # эта система не запрашивает внешний пароль. # Подождите 5 секунд, пока exec завершит вызов spel. Telnet very.secure.gov sleep 5 send password \ r

exp_send это псевдоним для Отправить. Если вы используете Expectk или какой-либо другой вариант Expect в среде Tk, Отправить определяется Tk для совершенно другой цели. exp_send предоставляется для совместимости между средами. Подобные псевдонимы предоставляются для других команд отправки Expect.

send_error [-flags] строка

как Отправить , за исключением того, что вывод отправляется в stderr, а не в текущий процесс.

send_log [-] строка

как Отправить , за исключением того, что строка отправляется только в файл журнала (см. журнальный файл .) Аргументы игнорируются, если файл журнала не открыт.

строка send_tty [-flags]

как Отправить , за исключением того, что вывод отправляется в / dev / tty, а не в текущий процесс.

send_user [-flags] строка

как Отправить , за исключением того, что вывод отправляется на стандартный вывод, а не текущий процесс.

секунд сна

заставляет скрипт спать в течение заданного количества секунд. Секунды могут быть десятичным числом. Прерывания (и события Tk, если вы используете Expectk) обрабатываются во время ожидания Expect.

spawn [args] программа [args]

создает новый процесс, выполняющий «программные аргументы». Его stdin, stdout и stderr связаны с Expect, так что они могут быть прочитаны и записаны другими ожидать команды. Разрыв связи близко или если сам процесс закрывает какой-либо из идентификаторов файла.

Когда процесс запускается порождать , переменная spawn_id установлена в дескриптор, ссылающийся на этот процесс. Процесс, описанный spawn_id, считается «текущим процессом». spawn_id может быть прочитан или записан, фактически обеспечивая контроль работы.

user_spawn_id — это глобальная переменная, содержащая дескриптор, который ссылается на пользователя. Например, когда spawn_id установлен в это значение, ожидать ведет себя как expect_user .

.I error_spawn_id — это глобальная переменная, содержащая дескриптор, который ссылается на стандартную ошибку. Например, когда spawn_id установлен в это значение, Отправить ведет себя как SEND_ERROR .

tty_spawn_id — это глобальная переменная, содержащая дескриптор, который ссылается на / dev / tty. Если / dev / tty не существует (например, в cron, at или batch-скрипте), то tty_spawn_id не определяется. Это может быть проверено как:

если {[info vars tty_spawn_id]} {# / dev / tty существует} иначе {# / dev / tty не существует # вероятно в cron, batch или в скрипте}

порождать возвращает идентификатор процесса UNIX. Если процесс не запущен, возвращается 0. Переменная spawn_out (slave, name) устанавливается на имя устройства pty slave.

По умолчанию, порождать повторяет имя команды и аргументы. -NoEcho флаг останавливается порождать от этого.

-приставка флаг заставляет вывод консоли перенаправляться в порожденный процесс. Это поддерживается не во всех системах.

Внутренне порождать использует pty, инициализированный так же, как и пользователь tty. Это далее инициализируется так, чтобы все настройки были «нормальными» (согласно stty (1)). Если переменная stty_init определена, она интерпретируется в стиле аргументов stty как дальнейшая конфигурация. Например, «set stty_init raw» приведет к запуску терминалов других порождаемых процессов в необработанном режиме. -nottycopy пропускает инициализацию на основе tty пользователя. -nottyinit пропускает «нормальную» инициализацию.

Прочтите: Разница между Linux и GNU / Linux

Как обычно, порождать занимает мало времени, чтобы выполнить. Если вы заметили, что спавн занимает значительное время, он, вероятно, сталкивается с клиньями. Ряд тестов выполняется на ptys, чтобы избежать путаницы с ошибочными процессами. (Это занимает 10 секунд на каждый клин. Pty) -d опция покажет, если ожидать встречает много ptys в нечетных состояниях. Если вы не можете уничтожить процессы, к которым подключены эти ptys, единственным выходом может быть перезагрузка.

Если программа не может быть успешно запущена из-за сбоя exec (2) (например, когда программа не существует), сообщение об ошибке будет возвращено следующим взаимодействовать или же ожидать Команда, как если бы программа запустилась и выдало сообщение об ошибке в качестве вывода. Такое поведение является естественным следствием реализации порождать . Внутренне, порождает порождение, после которого порожденный процесс не имеет возможности связаться с оригиналом ожидать процесс кроме связи через spawn_id.

-открытый флаг заставляет следующий аргумент интерпретироваться как идентификатор файла Tcl (то есть возвращается открытый .) Идентификатор порождения может затем использоваться, как если бы это был порожденный процесс. (Идентификатор файла больше не должен использоваться.) Это позволяет вам рассматривать необработанные устройства, файлы и конвейеры как порожденные процессы без использования pty. 0 возвращается, чтобы указать, что нет никакого связанного процесса. Когда соединение с порожденным процессом закрыто, то и идентификатор файла Tcl. -leaveopen флаг похож на -открытый Кроме этого -leaveopen заставляет идентификатор файла оставаться открытым даже после закрытия spawn id.

-псевдотерминал флаг вызывает открытие pty, но процесс не запускается. 0 возвращается, чтобы указать, что нет никакого связанного процесса. Spawn_id устанавливается как обычно.

Переменная spawn_out (slave, fd) устанавливается на идентификатор файла, соответствующий pty-ведомому. Его можно закрыть с помощью «close -slave».

-игнорировать флаг называет сигнал, который должен игнорироваться в порожденном процессе. В противном случае сигналы получают поведение по умолчанию. Сигналы названы как в ловушка команда, за исключением того, что каждый сигнал требует отдельного флага.

уровень стрейс

приводит к тому, что следующие операторы будут напечатаны перед выполнением. (Команда трассировки Tcl отслеживает переменные.) Уровень указывает, насколько далеко в стеке вызовов требуется выполнить трассировку. Например, следующая команда выполняется ожидать отслеживая первые 4 уровня вызовов, но ни один из них не ниже.

ожидаем -c "strace 4" script.exp

-Информация флаг заставляет strace возвращать описание самых последних неинформационных аргументов.

Stty Args

изменяет режимы терминала аналогично внешней команде stty.

По умолчанию доступ к управляющему терминалу Доступ к другим терминалам можно получить, добавив «Запросы на статус, которые возвращаются в результате выполнения команды. Если статус не запрашивается и к управляющему терминалу обращаются, предыдущее состояние атрибутов raw и echo возвращается в форме, которая может быть позже используется командой.

Например, аргументы сырье или же -приготовленный переведите терминал в режим raw. Аргументы -сырье или же приготовленный переведите терминал в готовый режим. Аргументы эхо а также -эхо переведите терминал в режим эхо и ное эхо соответственно.

В следующем примере показано, как временно отключить эхо. Это может быть использовано в автоматических сценариях, чтобы избежать встраивания в них паролей. (Подробнее об этом см. В разделе «ОЖИДАЕМЫЕ СОВЕТЫ» ниже.)

stty -echo send_user "Пароль:" wait_user -re "(. *) \ n" установить пароль $ Ожидаем_out (1, строка) stty echo

системные аргументы

дает аргументы для sh (1) в качестве входных данных, как если бы они были набраны как команда из терминала. ожидать ждет, пока оболочка не завершится. Статус возврата из sh обрабатывается так же, как Exec обрабатывает свой статус возврата.

В отличие от Exec который перенаправляет стандартный ввод и стандартный вывод в сценарий, система не выполняет перенаправления (кроме указанного в самой строке). Таким образом, можно использовать программы, которые должны напрямую взаимодействовать с / dev / tty. По той же причине, результаты система не заносятся в журнал.

отметка времени [args]

возвращает метку времени Без аргументов — количество секунд с начала эпохи.

-формат Флаг вводит строку, которая возвращается, но с подстановками, сделанными в соответствии с правилами POSIX для strftime. Например,% a заменяется сокращенным названием дня недели (т. Е. Суббота). Другие являются:

% a сокращенное название дня недели% A полное название дня недели% b сокращенное название месяца% B полное имя месяца% c дата-время, как в: ср 6 окт. 11:45:56 1993% d день месяца (01-31% H час (00-23)% I час (01-12)% j день (001-366)% m месяц (01-12)% M минута (00-59)% p утра или вечера% S секунды (00-61) % u день (1-7, понедельник - первый день недели)% U неделя (00-53, первое воскресенье - первый день первой недели)% V неделя (01-53, стиль ISO 8601)% w день (0- 6)% W неделя (00-53, первый понедельник - первый день первой недели)% x дата-время как в: ср 6 октября 1993% X время как в: 23:59:59% y год (00-99) % Y год как в: 1993% часовой пояс Z (или ничего, если не определено) %% знак процента

Другие% спецификации не определены. Другие персонажи будут пропущены через нетронутыми. Поддерживается только локаль C

-секунд Флаг вводит количество секунд, начиная с эпохи, которая будет использоваться в качестве источника для форматирования. В противном случае используется текущее время.

-время по Гринвичу флаг заставляет вывод отметки времени использовать часовой пояс GMT. Без флага используется местный часовой пояс.

ловушка [[команда] сигналы]

заставляет данную команду быть выполненной при получении в будущем любого из данных сигналов. Команда выполняется в глобальной области видимости. Если команда отсутствует, возвращается действие сигнала. Если команда является строкой SIG_IGN, сигналы игнорируются. Если команда является строкой SIG_DFL, сигналы являются результатом по умолчанию системы. сигналы это либо один сигнал, либо список сигналов. Сигналы могут быть указаны численно или символически согласно сигналу (3). Префикс «SIG» может быть опущен.

Без аргументов (или аргумента -number), ловушка возвращает номер сигнала выполняемой в данный момент команды trap.

-код Флаг использует код возврата команды вместо того кода, который собирался вернуть Tcl, когда команда начала выполняться.

-интерп flag заставляет команду оцениваться с использованием интерпретатора, активного во время запуска команды, а не после объявления прерывания.

-имя флаг вызывает ловушка команда для возврата имени сигнала команды прерывания, выполняемой в данный момент.

-Максимум флаг вызывает ловушка команда для возврата наибольшего номера сигнала, который может быть установлен.

Например, команда «trap {send_user» Ouch! «} SIGINT» выведет «Ouch!» каждый раз, когда пользователь нажимает ^ C.

По умолчанию SIGINT (который обычно генерируется нажатием ^ C) и SIGTERM вызывают Expect для выхода. Это связано со следующей ловушкой, созданной по умолчанию при запуске Expect.

выход ловушки {SIGINT SIGTERM}

Если вы используете флаг -D для запуска отладчика, SIGINT переопределяется для запуска интерактивного отладчика. Это связано со следующей ловушкой:

trap {exp_debug 1} SIGINT

Ловушка отладчика может быть изменена путем установки переменной среды EXPECT_DEBUG_INIT новой команды прерывания.

Конечно, вы можете переопределить оба этих параметра, просто добавив команды trap в ваш скрипт. В частности, если у вас есть собственный «выход ловушки SIGINT», это отменит ловушку отладчика. Это полезно, если вы хотите вообще запретить пользователям доступ к отладчику.

Если вы хотите определить свою собственную ловушку в SIGINT, но все еще ловите ее в отладчике, когда он работает, используйте:

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

Кроме того, вы можете перехватить отладчик, используя другой сигнал.

ловушка не позволит вам переопределить действие для SIGALRM, так как оно используется внутри ожидать . Команда отсоединения устанавливает SIGALRM в SIG_IGN (игнорировать). Вы можете включить это, если отключите его во время последующих команд появления.

Смотрите сигнал (3) для получения дополнительной информации.

подождите [аргументы]

задерживается до тех пор, пока не завершится созданный процесс (или текущий процесс, если ни один из них не назван).

Подождите обычно возвращает список из четырех целых чисел. Первое целое число — это pid процесса, который ожидался. Второе целое число — соответствующий идентификатор появления. Третье целое число равно -1, если произошла ошибка операционной системы, или 0 в противном случае. Если третье целое число было 0, четвертое целое число — это состояние, возвращаемое порожденным процессом. Если третье целое число было -1, четвертое целое число является значением errno, установленным операционной системой. Глобальная переменная errorCode также установлена.

Дополнительные элементы могут появиться в конце возвращаемого значения из Подождите . Необязательный пятый элемент идентифицирует класс информации. В настоящее время единственным возможным значением для этого элемента является CHILDKILLED, в этом случае следующие два значения — это имя сигнала в стиле C и краткое текстовое описание.

-я Флаг объявляет процесс ожидания в соответствии с именованным spawn_id (НЕ идентификатор процесса). Внутри обработчика SIGCHLD можно ожидать любого порожденного процесса, используя идентификатор порождения -1.

-Нет, подождите флаг заставляет ожидание немедленно вернуться с указанием успешного ожидания. Когда процесс завершается (позже), он автоматически исчезает без необходимости явного ожидания.

Подождите Команда также может использоваться для ожидания разветвленного процесса, используя аргументы «-i -1». В отличие от использования с порожденными процессами, эта команда может быть выполнена в любое время. Нет контроля над тем, какой процесс происходит. Однако возвращаемое значение может быть проверено на идентификатор процесса.

Библиотеки

Expect автоматически знает о двух встроенных библиотеках для сценариев Expect. Они определяются каталогами, названными в переменных exp_library и exp_exec_library. Оба должны содержать служебные файлы, которые могут использоваться другими сценариями.

exp_library содержит независимые от архитектуры файлы. exp_exec_library содержит архитектурно-зависимые файлы. В зависимости от вашей системы оба каталога могут быть совершенно пустыми. Существование файла $ exp_exec_library / cat-buffers описывает, буферизует ли ваш / bin / cat по умолчанию.

Довольно-печать

Для симпатичной печати доступно определение vgrind ожидать скрипты. Предполагая определение vgrind, поставляемое с ожидать дистрибутив правильно установлен, вы можете использовать его как:

vgrind -lexpect file

Примеры

Многим не очевидно, как собрать все вместе, что описывает страница руководства. Рекомендуется прочитать и опробовать примеры в каталоге примеров ожидать распределение. Некоторые из них являются настоящими программами. Другие просто иллюстрируют определенные методы, и, конечно, пара — это просто быстрые взломы. Файл INSTALL содержит краткий обзор этих программ.

ожидать документы (см. также смотрите) также полезны. Хотя в некоторых статьях используется синтаксис, соответствующий более ранним версиям Expect, сопутствующие обоснования по-прежнему действительны и содержат гораздо больше подробностей, чем справочная страница.

Предостережения

Расширения могут конфликтовать с именами команд Expect. Например, Отправить определяется Tk для совершенно другой цели. По этой причине большинство ожидать Команды также доступны как «exp_XXXX». Команды и переменные, начинающиеся с «exp», «inter», «spawn» и «timeout», не имеют псевдонимов. Используйте расширенные имена команд, если вам нужна совместимость между средами.

ожидать занимает довольно либеральную точку зрения. В частности, переменные читаются командами, специфичными для ожидать Сначала программа будет искать в локальной области, а если не найдена, в глобальной области. Например, это избавляет от необходимости помещать «глобальное время ожидания» в каждую написанную вами процедуру, которая использует ожидать . С другой стороны, записанные переменные всегда находятся в локальной области (если не была введена «глобальная» команда). Наиболее распространенная проблема, которую это вызывает, — когда в процедуре выполняется spawn. Вне процедуры spawn_id больше не существует, поэтому порожденный процесс больше не доступен просто из-за области видимости. Добавьте «глобальный spawn_id» к такой процедуре.

Если вы не можете активировать функцию множественного появления (то есть ваша система не поддерживает ни select (BSD *. *), Poll (SVR> 2), ни что-либо эквивалентное), ожидать будет иметь возможность контролировать только один процесс одновременно. В этом случае не пытайтесь установить spawn_id и не следует запускать процессы через exec, когда запущенный процесс запущен. Кроме того, вы не сможете ожидать из нескольких процессов (включая пользователя как один) одновременно.

Параметры терминала могут оказать большое влияние на сценарии. Например, если сценарий написан для поиска эха, он будет работать неправильно, если эхо отключено. По этой причине Expect по умолчанию принудительно устанавливает параметры терминала. К сожалению, это может сделать вещи неприятными для других программ. Например, оболочка emacs хочет изменить «обычные» отображения: новые строки отображаются на новые строки вместо новых строк с возвратом каретки, и эхо отключено. Это позволяет использовать emacs для редактирования строки ввода. К сожалению, Expect не может догадаться об этом.

Вы можете попросить Expect не переопределять настройки по умолчанию для параметров терминала, но вы должны быть очень осторожны при написании сценариев для таких сред. В случае с emacs, избегайте зависимости от таких вещей, как эхо и отображение конца строки.

Команды, которые приняли аргументы, объединены в единый список ( ожидать варианты и взаимодействовать ) использовать эвристику, чтобы решить, является ли список одним или несколькими аргументами. Эвристика может потерпеть неудачу только в том случае, если список фактически представляет один аргумент, который имеет несколько встроенных \ n с непробельными символами между ними. Это кажется маловероятным, однако аргумент «-nobrace» может использоваться для принудительной обработки одного аргумента в качестве одного аргумента. Возможно, это можно использовать с машинным кодом Expect. Точно так же -brace заставляет один аргумент обрабатываться как множество шаблонов / действий.

ошибки

Было действительно заманчиво назвать программу «секс» (для «Smart EXec» или «Send-EXpect»), но здравый смысл (или, может быть, просто пуританство) преобладал.

В некоторых системах, когда запускается оболочка, она жалуется на невозможность доступа к tty, но все равно запускается. Это означает, что ваша система имеет механизм для получения контрольного ожидать не знает о. Пожалуйста, выясните, что это, и отправьте мне эту информацию.

Ultrix 4.1 (по крайней мере, последние версии здесь) считает превышение времени ожидания более 1000000 равным 0.

Digital UNIX 4.0A (и, возможно, другие версии) отказывается выделять ptys, если вы определяете обработчик SIGCHLD. Для получения дополнительной информации см. Страницу grantpt.

IRIX 6.0 неправильно обрабатывает разрешения pty, поэтому если Expect попытается выделить pty, ранее использованный кем-то другим, произойдет сбой. Обновление до IRIX 6.1.

Telnet (проверено только под SunOS 4.1.2) зависает, если TERM не установлен. Это проблема в сценариях cron, at и cgi, которые не определяют TERM. Таким образом, вы должны установить его явно — к какому типу обычно не имеет отношения. Это просто должно быть настроено на что-то! Следующего, вероятно, достаточно для большинства случаев.

установить env (TERM) vt100

Совет (проверено только в BSDI BSD / OS 3.1 i386) зависает, если SHELL и HOME не установлены. Это проблема в сценариях cron, at и cgi, которые не определяют эти переменные среды. Таким образом, вы должны установить их явно — к какому типу обычно не имеет отношения. Это просто должно быть настроено на что-то! Следующего, вероятно, достаточно для большинства случаев.

установить env (SHELL) / bin / sh установить env (HOME) / usr / local / bin

Некоторые реализации ptys спроектированы так, что ядро выбрасывает любые непрочитанные выходные данные через 10-15 секунд (фактическое число зависит от реализации) после того, как процесс закрыл дескриптор файла. таким образом ожидать такие программы, как

дата появления сна 20 ожидаем

не удастся. Чтобы избежать этого, вызывайте неинтерактивные программы с Exec скорее, чем порождать . Хотя такие ситуации возможны, на практике я никогда не сталкивался с ситуацией, в которой конечный результат действительно интерактивной программы был бы потерян из-за такого поведения.

С другой стороны, Cray UNICOS ptys отбрасывает любые непрочитанные выходные данные сразу после того, как процесс закрыл дескриптор файла. Я сообщил об этом Крэй, и они работают над исправлением.

Иногда требуется задержка между приглашением и ответом, например, когда интерфейс tty изменяет настройки UART или соответствует скорости передачи данных в поисках битов пуска / останова. Обычно все, что для этого требуется — это поспать секунду или две. Более надежный метод — повторять попытки до тех пор, пока оборудование не будет готово к получению ввода. В следующем примере используются обе стратегии:

отправить «скорость 9600 р»; сон 1 ожидаем {timeout {send "\ r"; exp_continue} $ prompt}

trap-код не будет работать ни с какой командой, которая находится в цикле событий Tcl, например сном. Проблема состоит в том, что в цикле событий Tcl отбрасывает коды возврата от асинхронных обработчиков событий. Обходной путь должен установить флаг в коде ловушки. Затем проверьте флаг сразу после команды (то есть, спать).

Команда wait_background игнорирует аргументы -timeout и вообще не имеет понятия о тайм-аутах.

Ожидайте подсказки

Есть несколько вещей о ожидать это может быть не интуитивно понятно. В этом разделе предпринята попытка решить некоторые из этих вопросов с помощью нескольких предложений.

Общая ожидаемая проблема заключается в том, как распознать приглашения оболочки. Так как они настраиваются по-разному разными людьми и разными оболочками, переносимая автоматизация rlogin может быть затруднена без знания подсказки. Разумное соглашение заключается в том, чтобы пользователи хранили регулярное выражение, описывающее их приглашение (в частности, его конец), в переменной окружения EXPECT_PROMPT. Можно использовать код, подобный следующему. Если EXPECT_PROMPT не существует, у кода все еще есть хорошие шансы на правильное функционирование.

установить приглашение "(% | # | \\ $) $"; # задание подсказки по умолчанию {установить приглашение $ env (EXPECT_PROMPT)} ожидать -re $ приглашение

Написать ожидать шаблоны, которые включают конец того, что вы ожидаете увидеть. Это исключает возможность ответить на вопрос, прежде чем увидеть все это. Кроме того, хотя вы вполне можете отвечать на вопросы до того, как полностью их увидеть, если вы ответите рано, ваш ответ может оказаться отраженным в середине вопроса. Другими словами, итоговый диалог будет правильным, но выглядит зашифрованным.

Большинство подсказок содержат пробел в конце. Например, приглашение от ftp это ‘f’, ‘t’, ‘p’, ‘>’ и. Чтобы соответствовать этому приглашению, вы должны учитывать каждый из этих символов. Это распространенная ошибка — не включать пробел. Вставьте пробел явно.

Если вы используете шаблон формы X *, * будет сопоставлять все выходные данные, полученные с конца X, с последней полученной вещью. Это звучит интуитивно, но может быть несколько запутанным, потому что фраза «последняя полученная вещь» может варьироваться в зависимости от скорости компьютера и обработки ввода-вывода как ядром, так и драйвером устройства.

В частности, люди склонны видеть, что программный результат поступает огромными порциями (атомарно), когда в действительности большинство программ выдают выходные данные по одной строке за раз. Если предположить, что это так, то * в шаблоне предыдущего абзаца может совпадать только с концом текущей строки, даже если кажется, что их больше, потому что во время совпадения были все выходные данные, которые были получены.

ожидать не может знать, что последует дальнейший вывод, если ваш шаблон не учитывает это.

Даже в зависимости от строковой буферизации неразумно. Мало того, что программы редко дают обещания о типе буферизации, которую они делают, но несварение системы может разбить выходные строки так, что строки ломаются в, казалось бы, случайных местах. Таким образом, если вы можете выразить последние несколько символов приглашения при написании шаблонов, это целесообразно сделать.

Если вы ожидаете шаблон в последнем выводе программы, и программа вместо этого выдает что-то еще, вы не сможете обнаружить это с помощью Тайм-аут ключевое слово. Причина в том, что ожидать не будет тайм-аут — вместо этого он получит ВФ индикация. Используйте это вместо этого. Еще лучше, используйте оба. Таким образом, если эта строка будет перемещена, вам не придется редактировать саму строку.

Новые строки обычно преобразуются в возврат каретки, последовательности перевода строки при выводе драйвером терминала. Таким образом, если вы хотите шаблон, который явно соответствует двум строкам, скажем, printf («foo \ nbar»), вам следует использовать шаблон «foo \ r \ nbar».

Аналогичный перевод происходит при чтении от пользователя через expect_user . В этом случае, когда вы нажмете возврат, он будет переведен на новую строку. Если ожидать затем передает это программе, которая переводит свой терминал в режим raw (например, telnet), возникает проблема, так как программа ожидает истинного возврата. (Некоторые программы на самом деле прощают то, что они автоматически переводят переводы строк в возвраты, но большинство этого не делают.) К сожалению, нет никакого способа узнать, что программа переводит свой терминал в режим raw.

Вместо того, чтобы вручную заменять символы новой строки на возвраты, решение состоит в том, чтобы использовать команду «stty raw», которая остановит перевод. Обратите внимание, однако, что это означает, что вы больше не получите готовые функции редактирования строки.

взаимодействовать неявно устанавливает ваш терминал в сырой режим, так что эта проблема не возникнет тогда.

Часто полезно хранить пароли (или другую личную информацию) в ожидать скрипты. Это не рекомендуется, поскольку все, что хранится на компьютере, может быть доступно любому. Таким образом, интерактивное запрашивание паролей из сценария является более разумной идеей, чем встраивание их буквально. Тем не менее, иногда такое вложение является единственной возможностью.

К сожалению, файловая система UNIX не имеет прямого способа создания сценариев, которые выполняются, но не читаются. Системы, которые поддерживают сценарии оболочки setgid, могут косвенно моделировать это следующим образом:

Создать ожидать скрипт (который содержит секретные данные) как обычно. Сделайте его разрешения 750 (-rwxr-x —) и принадлежать доверенной группе, то есть группе, которой разрешено читать. При необходимости создайте новую группу для этой цели. Затем создайте сценарий / bin / sh с разрешениями 2751 (-rwxr-s — x), принадлежащими той же группе, что и раньше.

Результатом является скрипт, который может быть выполнен (и прочитан) кем угодно. При запуске он запускает ожидать скрипт.