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

в сетях tcp/ip существуют два приложения, позволяющие осуществить терминальный заход.

1. telnet - стандартное приложение, которое присутствует практически в каждой реализации tcp/ip. оно может быть использовано для связи между хостами, работающими пол управлением различных операционных систем. telnet использует согласование опций клиента и сервера, чтобы определить, какие характеристики присутствуют с той и с другой стороны.
2. программа rlogin происходит из berkeley unix и была разработана для того, чтобы работать только между unix системами, однако впоследствии эта программа была перенесена и на другие операционные системы.

в этой главе рассматривается и telnet, и rlogin. мы начнем с rlogin, потому что это приложение работает проще.

telnet это одно из старейших приложений internet. оно появилось в 1969 году в arpanet. имя этого приложения является сокращением от "сетевой коммуникационный протокол" (telecommmunications network protocol).

приложения удаленного терминала используют стандарт клиент-сервер. на рисунке 26.1 показано типичное общение telnet клиента и telnet сервера. (точно такой же рисунок можно нарисовать для rlogin клиента и rlogin сервера.)

рисунок 26.1 описание работы telnet клиент-сервер.

существует несколько моментов, на которые необходимо обратить внимание на этом рисунке.

• клиент telnet взаимодействует и с пользователем, находящимся за терминалом, и с протоколами tcp/ip. обычно, все что пользователь вводит с клавиатуры отправляется по tcp соединению, а все что приходит по соединению попадает на терминал.
• сервер telnet обычно взаимодействует с так называемыми псевдотерминальными устройствами (pseudo-terminal), по крайней мере в unix системах. это делает его похожим на командный интерпритатор (shell), который запускается на сервере, или на любую программу, которая запускается из shellа, так как именно они общаются с терминальными устройствами. некоторые приложения, например, полноэкранные редакторы, считают, что они общаются с терминальным устройством. и действительно, заставить shell на сервере считать, что он общается с терминалом, является наиболее сложным аспектом в программировании сервера удаленного терминала.
• устанавливается только одно tcp соединение. так как существуют моменты, когда telnet клиент должен общаться с telnet сервером (и наоборот), должны существовать способы, позволяющие отделить команды, которые посылаются по соединению, от пользовательских данных. ниже мы рассмотрим, как telnet и rlogin справляются с этой задачей.
• на рисунке 26.1, квадратиками нарисованными пунктирными линиями, показаны терминал и псевдотерминальные драйверы, вместе с реализацией tcp/ip, которые обычно являются частью ядра операционной системы. однако, telnet клиент и сервер - это, как правило, пользовательские приложения.
• на хосте сервера, показан командный интерпретатор, который запускается при входе пользователя в систему (login shell). это необходимо для получения терминального захода на сервер. необходимо иметь открытый бюджет на этой системе, чтобы получить терминальный заход, с использованием telnet или rlogin.

интересно будет сравнить сложность telnet и rlogin, основываясь на количестве строк в исходных текстах программ, клиента и сервера каждого приложения. на рисунке 26.2 показаны размеры стандартных telnet и rlogin клиентов и серверов, так, как они распространяются в различных версиях berkeley (рисунок 1.10).

рисунок 26.2 сравнение размеров исходных текстов telnet/rlogin/клиент/сервер.

надо отметить, что из-за появления новых опций, реализация telnet постоянно растет, тогда как rlogin остается простым и стабильным.

при заходе удаленным терминалом не предусматривается передача большого количества данных. как мы уже упоминали ранее, по соединению между двумя конечными системами обычно передается очень много маленьких пакетов. в соответствии с [paxson 1993] соотношение байт, отправленных клиентам (пользовательский ввод с терминала), к количеству байт, отправленных назад серверам, составляет примерно 1:20. такое соотношение получается из-за того, что мы вводим короткие команды, которые, в свою очередь, могут генерировать очень большой вывод.

rlogin появился в 4.2bsd и был предназначен для захода удаленным терминалом между unix хостами. поэтому rlogin проще, чем telnet, так как он не требует определение параметров, которые для одной и той же операционной системы известны заранее и для клиента, и для сервера. через несколько лет rlogin был перенесен на не-unix системы.

rfc 1282 [kantor 1991] содержит спецификацию протокола rlogin. однако, как и в случае с rfc посвященным rip (routing information protocol), он был написан после того, как rlogin уже использовался в течении нескольких лет. глава 15 [stevens 1990] описывает программирование клиента и сервера удаленного терминала и предоставляет полные исходные тексты rlogin клиента и сервера. главы 25 и 26 [comer and stevens 1993] сдержат подробности разработки и исходные тексты telnet клиента.

rlogin использует одно tcp соединение между клиентом и сервером. после того как tcp соединение установлено, между клиентом и сервером осуществляется следующая последовательность действий.

1. клиент отправляет серверу четыре строки: (a) нулевой байт, (b) имя пользователя на хосте клиента, заканчивающееся нулевым байтом, (с) имя пользователя на хосте сервера, заканчивающееся нулевым байтом, (d) тип терминала пользователя, за которым следует слэш (/), затем следует скорость терминала, и все это заканчивается нулевым байтом. необходимо отправить именно два имени пользователя, потому что пользователи не обязаны иметь одинаковые имена на разных хостах.

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

2. сервер отвечает нулевым байтом.
3. у сервера есть опция, с помощью которой он просит ввести пароль. это осуществляется как обычный обмен данными по rlogin соединению - специальные протоколы не применяются. сервер отправляет клиенту строку (которую клиент отображает на терминале), чаще всего эта строка выглядит как password:. если клиент не вводит пароль в течение определенного времени (обычно 60 секунд), сервер закрывает соединение. в домашней директории на сервере можно создать файл (который называется .rhosts) в котором будут содержаться имя хоста и имя пользователя. если зайти терминалом с указанного хоста с указанным именем пользователя, то не выдается приглашение ввести пароль. в некоторых публикациях, посвященных безопасности компьютерных систем, как, например, [curry 1992], очень не рекомендуют пользоваться этой характеристикой, потому что в этом случае в секретности появляется порядочная брешь. все что вводится в ответ на приглашение сервера ввести пароль, передается в виде открытого текста. символы введенного пароля посылаются так, как они есть. каждый, кто может прочитать пакеты в сети, может прочитать любой пароль. последние реализации rlogin клиента, например в 4.4bsd, используют kerberos для шифрации при передаче по сети. естественно требуются, чтобы и сервер поддерживал kerberos. ([curry 1992] описывает kerberos более подробно.)
4. сервер обычно отправляет запрос клиенту, спрашивая размер окна терминала (это будет описано позже).

клиент посылает за один раз серверу 1 байт, каждый байт сервер отражает эхо-откликом. мы это видели в разделе "интерактивный ввод" главы 19. обычно используется алгоритм нагла (глава 19, раздел "алгоритм нагла"), поэтому несколько входных байтов отправляются по медленным сетям как один tcp сегмент. функционально все довольно просто: то, что вводит пользователь, отправляется на сервер, а то, что сервер отправляет клиенту, отображается на терминале.

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

по умолчанию управление потоком обычно осуществляет rlogin клиент. клиент распознает ascii символы stop и start (control-s и control-q), которые вводятся пользователем, и останавливает или стартует вывод на терминал.

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

рисунок 26.3 функционирование rlogin соединения в случае, если сервер поддерживает обмен stop/start.

для интерактивных пользователей подобная задержка отклика на ввод символа control-s нежелательна.

однако, иногда приложения, запущенные на сервере, должны интерпретировать каждый байт ввода, и они не хотят, чтобы клиент использовал символы control-s и control-q каким-то особенным образом. (редактор emacs является примером приложения, которое использует эти два символа как свои собственные команды.) в подобном случае сервер может сообщить клиенту, поддерживает ли он контроль потока данных или нет.

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

достаточно редко поток данных от клиента к серверу может быть остановлен контролем потока данных. в этом направлении передаются только вводимые с клавитуры символы. поэтому нет необходимости отправлять эти специальные символы (control-s или прерывание) от клиента к серверу с использованием режима срочности tcp.

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

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

давайте кратко рассмотрим четыре команды, которые сервер rlogin может отправить клиенту по tcp соединению. проблема заключается в том, что используется одно tcp соединение, поэтому сервер должен пометить байты команд так, чтобы клиент интерпретировал их именно как команды, а не отображал эти байты на терминале. для этого используется режим срочности tcp (глава 20, раздел "режим срочности (urgent mode)").

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

рисунок 26.4 команды rlogin, передаваемые от сервера клиенту.

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

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

в настоящее время определена только одна команда, передаваемая от клиента к серверу: это отправка серверу текущего размера окна. изменение размера окна не отправляется серверу пока клиент не получит от сервера команду 0x80 (рисунок 26.4).

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

для команды, управляющей размером окна, два флаговых байта это ascii символы s. затем следуют четыре 16-битных значения (в порядке сетевых байтов): количество символов в строке (обычно 25), количество символов в столбце (обычно 80), количество пикселей по оси x и количество пикселей по оси y. часто два последних 16-битных значения равны 0, так как большинство приложений, запускаемых rlogin сервером, определяют размер экрана в символах, а не в пикселях.

подобная форма представления команд называется командами в полосе (in-band signaling), так как командные байты передаются в обычном потоке данных. байты, выделяющие команды из потока данных (0xff) выбраны таким образом, нажатие какой-либо клавиши не могло сгенерировать подобные байты. естественно у подобной формы представления команд есть свои недостатки. если мы сможем сгенерировать два последовательных байта равных 0xff с клавиатуры, за которыми будут следовать два ascii символа s, следующие 8 введенных байт будут восприняты как размеры окна.

команды rlogin от сервера к клиенту, показанные на рисунке 26.4, называются командами, выходящими за полосу (out-of-band signaling), именно так эта техника называется в большинстве api. обратитесь к режиму срочности tcp (глава 20, раздел "режим срочности (urgent mode)"). режим срочности не имеет отношения к данным, выходящим за полосу, так как командные байты передаются в обычном потоке данных, при этом их местоположение в потоке данных определяется с использованием указателя срочности.

так как команды в полосе (in-band signaling) передаются от клиента к серверу, сервер должен просматривать каждый байт, принятый от клиента, в поисках двух последовательных байтов 0xff. в случае команд выходящих за полосу (out-of-band signaling) , которые передаются от сервера к клиенту, клиенту нет необходимости просматривать данные, которые он получает от сервера, до тех пор пока сервер не перейдет в режим срочности. даже в режиме срочности клиенту необходимо только просмотреть байт, на который указывает указатель срочности. так как соотношение количества байт, передаваемых в двух направлениях (от клиента к серверу и от сервера к клиенту), составляет примерно 1:20, то возникает необходимость использовать команды в полосе (in-band signaling) для небольшого потока данных (от клиента к серверу), и команды, выходящие за полосу (out-of-band signaling), для более загруженного потока данных (от сервера к клиенту).

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

1. точка прекращает работу клиента.
2. символ конца файла (обычно control-d) прекращает работу клиента.
3. символ подавления (в управлении задачами обычно control-z) приостанавливает работу клиента.
4. символ задержанного подавления (в управлении задачами обычно control-y) задерживает только ввод клиента. все вводимое с клавиатуры интерпретируется программой, запущенной на хосте клиента, однако все отправленное rlogin сервером клиенту появляется на терминале. это может быть использовано, когда на сервере запущено задание, которое займет много времени, и необходимо знать, когда и что оно выдаст, однако на клиенте необходимо запустить другую программу.

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

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

на рисунке 26.5 показана временная диаграмма для rlogin соединения от хоста bsdi к серверу svr4. (мы удалили все связанное с установлением tcp соединения, объявлением окна, а также информацию о типе сервисов.)

протокол, описанный в предыдущих разделах, можно увидеть в сегментах 1-9. клиент отправляет один нулевой байт (сегмент 1), за которым следуют три строки (сегмент 3). в этом примере три строки это: rstevens (имя клиента), rstevens (имя на сервере) и ibmpc3/9600 (тип терминала и скорость). сервер проверяет полномочность этой информации и отвечает нулевым байтом (сегмент 5).

затем сервер отправляет команду с запросом окна (сегмент 7). эта команда отправляется с использованием режима срочности tcp. здесь мы видим реализацию (svr4), которая использует старую, однако более распространенную интерпретацию, когда указатель срочности указывает на номер последовательности последнего байта срочных данных плюс один. клиент отвечает 12 байтами данных: 2 байта 0xff, 2 байта s и четыре 16-битных значения.

следующие четыре сегмента от сервера (10, 12, 14 и 16) это приветствие операционной системы. за ними следует 7-байтное приглашение от shellа: "svr4%" (сегмент 18).

данные, которые вводит клиент, отправляются по 1 байту за один раз, как показано на рисунке 19.2. соединение может быть закрыто с любой стороны. если мы введем команду, которая заставит shell, запущенный на сервере, прекратить свою работу, сервер со своей стороны осуществит активное закрытие. если мы введем escape последовательность rlogin клиенту (обычно тильда), за которой следует точка или символ конца файла, клиент осуществит активное закрытие.

рисунок 26.5 временная диаграмма rlogin соединения.

давайте рассмотрим еще один пример, в котором tcp использует режим срочности, когда поток данных остановлен с помощью символа прерывания. в этом примере сведены вместе несколько алгоритмов tcp, которые мы обсуждали ранее: режим срочности, предотвращение "глупого" окна, управление потоком данных с помощью окон и устойчивого таймера. мы стартовали клиента на хосте sun. затем зашли терминалом на bsdi, вывели на терминал большой текстовый файл, а затем остановили вывод, нажав control-s. когда вывод остановлен, мы нажали клавишу прерывания (delete), чтобы завершить работу программы:

sun % rlogin bsdi
                                             приветствие от операционной системы
bsdi % cat /usr/share/misc/termcap            вывод большого файла на терминал
                                             большой вывод на терминал
                                             мы печатаем control-s, чтобы остановить вывод,
                                             и ожидаем до тех пор, пока вывод не остановится

^?                                           вводим символ прерывания, он отображается эхом
bsdi %                                        затем появляется приглашение

ниже описаны состояния клиента, сервера и соединения.

1. вывод на терминал остановлен путем ввода control-s.
2. rlogin клиент приостановил вывод на терминал, однако выходной буфер терминала будет заполнен.
3. rlogin клиент не может читать из сети, так как приемный буфер tcp клиента полон.
4. tcp клиент объявляет размер окна равный 0, чтобы остановить отправителя (tcp модуль rlogin сервера), когда приемный буфер полон.
5. tcp модуль сервера отправляет сообщение о заполнении буфера, когда его вывод остановлен сообщением от клиента о том, что размер окна равен 0.
6. сервер rlogin остановлен, так как отправляющий буфер полон. таким образом, сервер rlogin не может читать данные от приложения, которое запущено на сервере (cat).
7. приложение cat останавливается, когда его выходной буфер наполняется.
8. затем мы вводим символ прерывания, чтобы остановить работу приложения cat на сервере. это отправляется от tcp клиента к tcp серверу, потому что поток данных в этом направлении не остановлен с помощью контроля потока данных.
9. приложение cat получает символ прерывания и прекращает свою работу. при этом его выходной буфер (из которого читал сервер rlogin) очищается, после чего "просыпается" сервер rlogin. сервер rlogin входит в режим срочности и посылает клиенту команду "очистить вывод" (0x02).

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

рисунок 26.6 поток данных от сервера к клиенту в примере rlogin.

затемненная часть отправляющего буфера это неиспользуемая часть буфера размером в 4096 байт. на рисунке 26.7 приведена временная диаграмма для этого примера.

в сегментах 1-3 сервер отправляет клиенту сегменты полного размера. подтверждение (ack) в сегменте 4 всего лишь объявляет окно равное 1024, потому что вывод остановлен: так как клиент не может писать на терминал, он не может читать из сети. сегмент 5 не полного размера, а ack в сегменте 6 объявляет только оставшееся пространство в приемном буфере, размер премного буфера составляет 4096 байт. клиент должен объявить окно размером 349 байт, потому что если он объявит окно равное 0 (как мы ожидаем, основываясь на алгоритме избежания "глупого окна", глава 22, раздел "синдром "глупого" окна"), это приведет к тому, что правая граница окна сдвинется влево, что не должно произойти (глава 20, раздел "изменение размера окна"). так как сервер не может отправить буфер полного размера, когда он принимает сегмент 6, он прибегает к алгоритму предотвращения "глупого окна", не посылая ничего, при этом устанавливается устойчивый таймер (5 секунд). когда таймер истекает, отправляется 349 байт (сегмент 7), и так как вывод клиента все еще остановлен, подтверждение в сегменте 8 объявляет окно равное 0.

в этот момент мы вводим символ прерывания, который передается в сегменте 9. все еще объявлено окно равное 0. когда rlogin сервер получает символ прерывания, он передает его приложению (cat), и приложение прекращает свою работу. так как приложение было остановлено вводом символа прерывания с терминала, его вывод сбрасывается и это передается серверу rlogin. это заставляет сервер посылать команду "очистить вывод" клиенту с использованием режима срочности tcp. мы видим это в сегменте 10. обратите внимание, что командный байт 0x02 имеет номер последовательности 30146 (указатель срочности минус один). перед командным байтом находится 3419 байт (номера последовательности 26727:30145), они буферизированы сервером и сервер собирается их отправить.

сегмент 10, с уведомлением срочности, содержит следующий байт данных, который передается от сервера клиенту (номер последовательности 26727). он не содержит командный байт "очистить вывод". сервер может послать этот единственный байт в сегменте 10 (глава 22, раздел "пример"), так как отправитель всегда может проверить, закрыто ли окно, отправив 1 байт данных. tcp модуль клиента немедленно отвечает сегментом 11 с нулевым окном, однако прием уведомления о срочности в сегменте 10 заставляет tcp модуль клиента уведомить rlogin клиента, что удаленный конец соединения вошел в режим срочности.

рисунок 26.7 пример rlogin, когда клиент останавливает вывод и затем прерывает работу программы на сервере.

как только rlogin клиент получает уведомление о срочности от своего tcp, он начинает считывание данных, которые уже ожидают этого, окно открывается (сегмент 13). данные, буферизированные сервером, отправляются (сегменты 14, 15, 17 и 18). последний сегмент содержит последний байт срочных данных (номер последовательности 30146), который содержит командный байт, передаваемый от сервера клиенту. когда клиент считывает этот байт, он отбрасывает все данные, которые он прочитал в сегментах 14, 15, 17 и 18, и очищает свою выходную очередь на терминал. следующие 2 байта в сегменте 19 содержат эхо символа прерывания: "^?". последний сегмент, который мы показали (21), содержит приглашение shellа от клиента.

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

telnet был разработан, для того чтобы работать между хостами работающими под управлениием любых операционных систем, а также с любыми терминалами. его спецификация, приведенная в rfc 854 [postel and reynolds 1983a], определяет терминал, который может являться наиболее общим, и который называется виртуальным сетевым терминалом (nvt - network virtual terminal). nvt это воображаемое устройство, находящееся на обоих концах соединения, у клиента и сервера, с помощью которого устанавливается соответствие между их реальными терминалами. таким образом, операционная система клиента должна определять соответствие между тем типом терминала, за которым работает пользователь, с nvt. в свою очередь, сервер должен устанавливать соответствие между nvt и теми типами терминалов, которые он (сервер) поддерживает.

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

термин nvt ascii означает 7-битный вариант u.s. ascii набора символов, который используется в семействе протоколов internet. каждый 7-битный символ отправляется как 8-битный байт со старшим битом установленным в 0.

конец строки передается как двухсимвольная последовательность - cr (возврат каретки - carriage return), затем следует lf (пропуск строки - linefeed). мы показываем это как \r\n. возврат каретки передается как двухсимвольная последовательность cr, за которой следует nul (нулевой байт). мы показываем это как \r\0.

в следующих главах мы увидим, что ftp, smtp, finger и whois используют nvt ascii для ввода команд клиента и откликов сервера.

telnet использует команды в полосе (in-band signaling) в обоих направлениях. байт 0xff (255 десятичный) называется iac, "интерпретировать как команду". следующий байт является командным байтом. для того чтобы послать байт данных равный 255, отправляются два последовательных байта равных 255. (в предыдущем параграфе мы сказали, что поток данных имеет формат nvt ascii, то есть используются 7-битные значения, а это означает, что байт данных равный 255 не может быть отправлен посредством telnet. существует двоичная опция telnet, описанная в rfc 856 [postel and reynolds 1983b], которая, позволяет передавать 8-битные данные.) на рисунке 26.8 приведены команды telnet.

рисунок 26.8 команды telnet, предваряемые iac (255).

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

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

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

1. will. отправитель хочет включить эту опцию для себя.
2. do. отправитель хочет, чтобы получатель включил эту опцию.
3. wont. отправитель хочет выключить эту опцию для себя.
4. dont. отправитель хочет, чтобы получатель выключил опцию.

так как правила telnet позволяют стороне принять или отклонить запрос на включение опции (случаи 1 и 2), однако требуют, чтобы она всегда удовлетворяла запрос на выключение опции (случаи 3 и 4), из этих четырех возможных случаев может получиться шесть комбинаций, которые приведены на рисунке 26.9.

рисунок 26.9 шесть сценариев обсуждения опции telnet.

обсуждение опции занимает 3 байта: iac байт, за которым следует байт will, do, wont или dont, затем id байт, указывающий на ту опцию, которую необходимо включить или выключить. в настоящее время, таким образом, может быть обсуждено 40 опций. assigned numbers rfc содержат значения для байт опций, а соответствующее rfc описывает сами опции. на рисунке 26.10 показаны коды опций, которые мы увидим в этой главе.

рисунок 26.10 коды опций telnet, обсуждаемые в этой главе.

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

некоторые опции требуют большего количества информации, нежели просто "включить" (enable) или "выключить" (disable). например, установка типа терминала: для того чтобы клиент мог идентифицировать тип терминала, он должен отправить ascii строку. чтобы обработать эти опции, применяется обсуждение подопций.

rfc 1091 [vanbokkelen 1989] определяет подопции, которые необходимо обсудить для установки типа терминала. во-первых, одна сторона (обычно клиент) просит включить опцию, отправляя 3-байтовую последовательность

<iac, will, 24>

где 24 (десятичное) это идентификатор опции типа терминала. если получатель (сервер) говорит да, его ответ будет выглядеть как

<iac, do, 24>

затем сервер посылает

<iac, sb, 24, 1, iac, se>

спрашивая о типе терминала клиента. sb это команда, которая сообщает о начале подопций (suboption-begin). следующий байт равный 24 указывает на то, что это подопция типа терминала. (sb всегда следует за номером опции, к которой относятся подопции.) следующий байт равный 1 означает "отправьте ваш тип терминала". перед командой конец подопций (suboption-end) должен опять стоять iac, так же как и перед командой sb. клиент отвечает командой

<iac, sb, 24, 0, 'i', 'b', 'm', 'p', 'c', iac, se>

в случае, если его тип терминала ibmpc. четвертый байт равный 0 означает "у меня следующий тип терминала". ("официальный" список приемлемых типов терминалов находится в assigned numbers rfc, однако для unix систем приемлем любой тип терминала, поддерживаемый сервером. обычно это терминалы, поддерживаемые базами termcap или terminfo.) типы терминалов, указываемые в подопциях telnet, пишутся большими буквами и обычно преобразуются в маленькие буквы уже сервером.

существуют четыре режима, в которых функционирует большинство telnet клиентов и серверов.

1. полудуплексный.

   это режим по умолчанию, который, однако, редко используется в настоящее время. nvt по умолчанию это полудуплексное устройство, которое требует исполнения команды go ahead (ga) от сервера, перед тем как будет принят ввод от пользователя. ввод пользователя отображается локальным эхом от nvt клавиатуры на nvt принтер, таким образом, от клиента к серверу посылаются только полные строки.

   таким образом, обеспечивается минимальная поддержка терминала, однако подобным образом невозможно обеспечить полнодуплексную связь с хостами, которые поддерживают полнодуплексную форму общения, что является нормой на сегодняшний день. rfc 857 [postel and reynolds 1983c] определяет опцию echo (эхо), а rfc 858 [postel and reynolds 1983d] определяет опцию suppress go ahead (запрещение команды go ahead). комбинация этих двух опций предоставляет поддержку для следующего режима, символ за один раз, с удаленным эхом.

2. символ за один раз.

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

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

   для того чтобы сервер мог войти в этот режим, у него должна быть включена опция suppress go ahead. обсуждение этой опции осуществляется следующим образом: клиент посылает do suppress go ahead (требуя от сервера, чтобы тот включил опцию), или сервер посылает will suppress go ahead клиенту (спрашивая о возможности включить эту опцию для самого себя). затем сервер осуществляет will echo, спрашивая о возможности включить отражение эхом.

3. строка за один раз.

   часто это называется "kludge line mode", потому что его реализация приходит от чтения между строк в rfc 858. этот rfc декларирует, что должны присутствовать обе опции echo и suppress go ahead, чтобы обеспечить ввод символа за один раз с удаленным эхом. таким образом, если какая-либо из этих опций не включена, telnet находится в режиме строка за один раз. в следующем разделе мы увидим пример того, как происходит обсуждение этого режима, и как он может быть отключен, когда программе сервера необходимо читать каждое нажатие клавиши. (то есть когда программа должна читать каждый символ, введенный пользователем, а не целую строку символов.)

4. линейный режим (linemode).

   в данном случае этот термин означает реальную опцию linemode, определенную в rfc 1184 [borman 1990]. эта опция обсуждается клиентом и сервером и корректирует все недостатки в режиме строка за один раз. новые реализации поддерживают эту опцию.

на рисунке 26.11 показаны режимы функционирования по умолчанию между различными telnet клиентами и серверами. выражение "char" означает символ за один раз, "kludge" означает строка за один раз и "linemode" означает реальный линейный режим rfc 1184.

рисунок 26.11 режимы функционирования по умолчанию между различными telnet клиентами и серверами.

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

telnet использует команду data mark в качестве сигнала синхронизации (dm на рисунке 26.8), который передается в виде срочных данных tcp. команда dm это метка синхронизации в потоке данных, которая сообщает принимающему о необходимости вернуться в обычный режим работы. он может быть отправлен в любом направлении по telnet соединению.

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

мы увидим примеры использования сигнала синхронизации telnet в следующем разделе.

как и в случае rlogin клиента, telnet клиент так же позволяет пообщаться с ним, вместо того чтобы отправлять пользовательский ввод серверу. стандартный символ, позволяющий осуществить переход в режим управления клиентом (escape), это control-] (control и правая квадратная скобка, что обычно печатается как "^]"). при этом клиент выводит приглашение, обычно выглядящее как "telnet>". в ответ на это приглашение можно вводить команды, что позволяет сменить характеристики сессии или напечатать какую-либо информацию. команда help поддерживается большинством unix клиентов и отображает все доступные команды.

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

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

мы начнем с основного режима символ за один раз (character-at-a-time), который напоминает rlogin. каждый символ, который мы вводим на терминале, отправляется на сервер без каких-либо модификаций, а сервер отражает этот символ эхом. однако если мы запустим более новую версию клиента (bsd/386), который старается включить некоторые новые опции, то увидим, что сервер, работающий под управлением svr4, не позволит включить эти опции.

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

bsdi % telnet                           стартуем клиента без опций в командной строке

telnet> toggle options                  сообщаем клиенту о необходимости отобразить
will show option processing.             всю обработку опций

telnet> open svr4                       сейчас устанавливаем соединение с сервером
trying 140.252.13.34...
connected to svr4.
escape character is '^]'.

sent do suppress go ahead                 1. (номера строк, которые мы обсудим ниже)
sent will terminal type                   2.
sent will naws                            3.
sent will tspeed                          4.
sent will lflow                           5.
sent will linemode                        6.
sent will environ                         7.
sent do status                            8.
rcvd do terminal type                     9.
rcvd will suppress go ahead              10.
rcvd dont naws                           11.
rcvd dont tspeed                         12.
rcvd dont lflow                          13.
rcvd dont linemode                       14.
rcvd dont environ                        15.
rcvd wont status                         16.
rcvd iac sb terminal-type send          17.
sent iac sb terminal-type is "ibmpc3"   18.
rcvd will echo                           19.
sent do echo                             20.
rcvd do echo                             21.
sent wont echo                           22.

unix(r) system v release 4.0 (svr4)

rcvd dont echo                           23.
login: rstevens                         вводим имя
password:                                и пароль, который сервер не отображает эхом,
                                        после чего появляется приветствие от
                                        операционной системы...
                                        и затем приглашение от shell

рисунок 26.12 начальное обсуждение опций telnet клиентом и сервером.

строки, в которых происходит обсуждение опций, пронумерованы (они начинаются с sent или rcvd). давайте рассмотрим обсуждение опций более подробно.

1. клиент начинает с обсуждения опции suppress go ahead. эта опция начинается с do, так как команда go ahead обычно отправляется от сервера клиенту, и клиент хочет, чтобы сервер включил опцию. (это немного непонятно, так как включение опции исключает отправку команд ga.) сервер соглашается на включение этой опции в строке 10.
2. клиент хочет отправить свой тип терминала как указано в rfc 1091 [vanbokkelen 1989]. это является обычным для unix клиентов. опция начинается с will, так как клиент хочет включить эту опцию для себя.
3. naws означает "обсуждение размера окна", как определено в rfc 1073 [waitzman 1988]. если сервер согласен (чего не происходит в строке 11), клиент посылает подопцию с количеством строк и колонок своего терминала. если размер окна изменяется, клиент пошлет эту подопцию позже. (то же самое мы видели в случае rlogin с командой 0x80 на рисунке 26.4.)
4. опция tspeed позволяет отправителю (обычно клиенту) сообщить свою скорость терминала, как определено в rfc 1079 [hedrick 1988b]. если сервер согласен (чего не происходит в строке 12), то клиент отправляет подопцию, в которой сообщает свою скорость передачи и скорость приема.
5. lflow обозначает "локальное управление потоком данных", как определено в rfc 1372 [hedrick and borman 1992]. клиент отправляет эту опцию серверу, сообщая, хочет ли он включить или выключить управление потоком данных. если сервер согласен (чего не происходит в строке 13), сервер посылает подопцию клиенту, в которой сообщается, что переключение между клиентом и сервером будет осуществляться с помощью control-s и control-q. (это напоминает то, что мы видели в случае rlogin команд 0x10 и 0x20 на рисунке 26.4.) как мы уже говорили, обсуждая rlogin, пользователь получает лучшее управление потоком данных, когда оно осуществляется клиентом, а не сервером.
6. linemode это реальный линейный режим, о котором мы уже упоминали в разделе "протокол telnet". вся обработка символов введенных с терминала осуществляется telnet клиентом (удалить символ, удалить строку и так далее), а серверу отправляются завешенные строки. ниже мы увидим, как это делается. эта опция отклонена в строке 14.
7. опция environ позволяет клиенту отправить переменные окружения серверу, как определено в rfc 1408 [borman 1993a]. при этом переменные окружения с хоста клиента могут быть автоматически установлены на хосте сервера. сервер отказался активизировать эту опцию в строке 15. ( в соответствии с соглашением, переменные окружения в unix - это имена из заглавных букв, после которых через знак равно, следует значение переменной, однако это всего лишь соглашение.) по умолчанию, telnet клиент bsd/386 посылает только две переменные, а именно display и printer, если они определены и если опция включена. пользователь telnet может указать дополнительные переменные окружения, которые необходимо отправить.
8. опция status (rfc 859 [postel and reynolds 1983e]) позволяет одному участнику обмена спросить другой о его текущем состоянии опций telnet. в этом примере клиент просит сервер включить опцию (do). если сервер согласен (чего не происходит в строке 16), клиент может в подопции попросить сервер послать статус его опций.
9. это первый отклик от сервера. сервер согласен включить опцию типа терминала. (почти каждый unix сервер поддерживает эту опцию.) клиент, однако, не может послать свой тип терминала, пока сервер не попросит его об этом с помощью подопции (строка 17).
10. сервер согласен запретить отправку команды go ahead.
11. сервер не позволяет клиенту отправить свой размер окна.
12. сервер не позволяет клиенту отправить свою скорость терминала.
13. сервер не позволяет клиенту осуществлять управление потоком данных.
14. сервер не позволяет клиенту включить опцию линейного режима.
15. сервер не позволяет клиенту послать переменные окружения.
16. сервер не будет посылать информацию о состоянии своих опций.
17. это подопция, с помощью которой сервер просит клиента послать тип терминала.
18. клиент посылает свой тип терминала в виде 6-символьной строки ibmpc3.
19. сервер просит клиента позволить ему осуществлять отражение эхом. это первый момент, когда сервер инициирует обсуждение опции.
20. клиент позволяет серверу осуществлять отражение эхом.
21. сервер просит клиента осуществлять отображение эхом. эта команда может показаться лишней, так как подобное обсуждение было предпринято в двух предыдущих строках. это всего лишь еще один способ, применяемый в большинстве unix систем, с помощью которого telnet сервер определяют, является ли их клиент хостом 4.2bsd или более поздним релизом bsd. если клиент ответит will echo, он, возможно, является хостом с более поздним релизом чем 4.2bsd и не сможет корректно поддерживать режим срочности tcp. (в этом случае режим срочности не используется.)
22. клиент отвечает wont echo, из чего следует, что это хост не 4.2bsd.
23. сервер отвечает на принятое wont echo с dont echo.

на рисунке 26.13 показана временная диаграмма для этого обмена клиент-сервер. (мы удалили все, связанное с установлением соединения.)

в сегменте 1 содержатся строки 1-8 (рисунок 26.12). каждая опция занимает 3 байта в сегменте, состоящем из 24 байт. обсуждение опций начинает клиент. мы видим, что в одном tcp сегменте может находиться несколько telnet опций.

сегмент 3 соответствует строке 9 на рисунке 26.12, команда do terminal type. сегмент 5 содержит восемь откликов от сервера на предложенные опции, строки 10-17 (рисунок 26.12). длина этого сегмента составляет 27 байт, потому что строки 10-16 это стандартные опции, каждая требует 3 байта вместе с подопцией (строка 17), которая требует 6 байт. 12 байт в сегменте 6 соответствуют строке 18, клиент посылает подопцию со своим типом терминала.

сегмент 8 (53 байта) - это комбинация двух команд telnet с 47 байтами данных, которые выводятся на терминал. первые 6 байт - это две команды от сервера: will echo и do echo (строки 19 и 21). следующие 47 байт выглядят так:

\r\n\r\nunix(r) system v release 4.0 (svr4) \r\n\r\0\r\n\r\0

первые 4 байта генерируют две пустые строки, перед тем как эта строка появится в выводе. 2-байтовая последовательность \r\n - это символ новой строки в telnet. 2-байтовая последовательность \r\0 соответствует символу возврата каретки. этот сегмент показывает, что данные и команды могут находиться в одном и том же сегменте. telnet клиент и telnet сервер должны просматривать каждый полученный байт в поисках iac байта и затем обрабатывать то, что следует за этим байтом.

рисунок 26.13 начальное обсуждение опций telnet клиентом и сервером.

в сегменте 9 содержатся две последние опции от клиента: строки 20 и 22. отклик в сегменте 10 соответствует строке 23 - это последняя опция от сервера.

с этого момента по соединению начинается обмен данными. ничего не мешает тому, чтобы продолжить обсуждение опций, однако этого не происходит. сегмент 12 содержит приглашение login: от сервера. сегмент 14 это первый символ, который мы вводим в качестве нашего имени, его эхо возвращается в сегменте 15. подобный тип интерактивного траффика мы видели в разделе "интерактивный ввод" главы 19 в случае rlogin: клиент посылает один символ за один раз, а сервер осуществляет эхо.

обсуждение опций на рисунке 26.12 инициировано клиентом, однако в нашей книге мы не раз использовали telnet клиента, чтобы подсоединиться к стандартным серверам, таким как сервер времени или эхо сервер, для того чтобы продемонстрировать различные характеристики tcp. когда мы рассматривали обмен пакетами в этих примерах, как, например, на рисунке 18.1, то никогда не видели, чтобы клиент инициировал обсуждение опций. почему? unix telnet клиент никогда не начинает обсуждение опций, если указан номер порта, отличный от стандартного порта telnet (23). это позволяет telnet клиенту с использованием стандартного nvt обмениваться данными с другими, не-telnet серверами. мы пользовались этим с daytime, echo и discard серверами и будем использовать это с ftp и smtp серверами в следующих главах.

чтобы увидеть опцию линейного режима telnet в действии, мы запустим клиента на хосте bsdi и подключимся к серверу 4.4bsd на vangogh.cs.berkeley.edu. и bsd/386, и 4.4bsd поддерживают эту опцию.

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

1. сервер 4.4bsd поддерживает больше опций, доступных к обсуждению, чем bsd/386: размер окна, локальное управление потоком данных, состояние опций, прием переменных окружения и скорость терминала.
2. сервер 4.4bsd старается обсудить более новые опции, чем те, которые поддерживаются клиентом bsd/386: аутентификация (позволяет избежать отправки пользовательского пароля в виде открытого текста по соединению).
3. клиент посылает опцию will linemode, сервер отвечает do linemode, так как он поддерживает эту опцию. клиент отправляет серверу 16 специальных символов в качестве подопции. это текущие значения специальных символов терминала на хосте клиента: символ прерывания, символ конца файла и так далее. сервер отправляет подопции клиенту, которые сообщают ему, как обрабатывать все входные строки и как осуществлять все функции редактирования (удаление символа, удаление строки и так далее). клиент отправляет серверу только завершенные строки. сервер также сообщает клиенту, как транслировать любые символы прерывания или сигнальные символы в соответствующие символы telnet. например, если символ прерывания - control-c, и мы вводим control-c, чтобы прервать текущий процесс на сервере, клиент посылает серверу telnet команду "прервать процесс" (<iac, ip>).
4. интересно посмотреть, что происходит, когда мы вводим пароль. в случае rlogin или режима telnet один символ за раз, когда сервер осуществляет эхо, он не отражает эхом символы пароля. в случае линейного режима, однако, эхо осуществляется самим клиентом. он справляется с этой задачей с помощью следующего обмена:

   (a)

   сервер отправляет will echo, сообщая клиенту, что сервер будет осуществлять отражение эхом.

   (b)

   клиент отвечает do echo.

   (c)

   сервер отправляет строку password: клиенту, а клиент выводит эту строку на терминал.

   (d)

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

   (e)

   сервер посылает 2-байтовую последовательность cr, lf, чтобы переместить курсор, так как символ return, который завершил ввод пароля, не был отображен эхом.

   (f)

   сервер посылает wont echo.

   (g)

   клиент отвечает dont echo. клиент восстанавливает отражение эхом.

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

по telnet соединению с использованием линейного режима. (мы удалили всю информацию о типе сервиса и объявления окна.)

рисунок 26.14 отправка команды от клиента к серверу с использованием линейного режима telnet.

если мы сравним это с той же самой командой, вводимой в rlogin (рисунок 19.2), то увидим, что линейный режим telnetа использует два сегмента (один с данными и один для подтверждения, что в целом составляет 86 байт, включая ip и tcp заголовки), тогда как rlogin использует 15 сегментов (5 с введенными данными, 5 с отраженными эхом данными, 5 с подтверждениями, всего 611 байт). нетрудно догадаться, в чью пользу это сравнение!

что если на сервере мы запустим приложение, которое требует использовать режим единственного символа? (например, редактор vi.) в этом случае будет происходить следующее.

1. когда приложение стартует на сервере и изменяет режим своего псевдотерминала, telnet сервер уведомляется о том, что требуется режим единственного символа. сервер посылает will echo клиенту вместе с подопцией линейного режима, которая сообщает клиенту о том, что не нужно составлять полные строки, а вместо этого необходимо посылать один символ за один раз.
2. клиент отвечает do echo и подтверждает подопцию линейного режима.
3. приложение запускается на сервере. каждый символ, который мы печатаем, отправляется серверу сам по себе (естественно используется алгоритм нагла), при этом сервер не требует отражения эхом.
4. когда приложение завершает работу и восстанавливает режим псевдотерминала, об этом уведомляется telnet сервер. сервер отправляет wont echo клиенту вместе с подопцией линейного режима, которая сообщает клиенту о необходимости снова составлять полные строки.
5. клиент отвечает dont echo и подтверждает подопцию линейного режима.

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

на рисунке 26.15 показаны различные режимы, которые мы видели для telnet и rlogin.

рисунок 26.15 сравнение режимов rlogin и telnet в действии.

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

во-первых, мы опишем, как сервер bsd/386 обсуждает этот режим, когда клиент не поддерживает реальный линейный режим.

1. когда клиент отказывает на требование сервера включить линейный режим, сервер посылает опцию do timing mark. rfc 860 [postel and reynolds 1983f] определяет эту опцию telnet. она предназначена для того, чтобы оба участника обмена могли синхронизироваться друг с другом. мы увидим, как это происходит, позже в этом разделе, когда будем рассматривать прерывание от пользователя. использование этой опции заключается в том, чтобы определить, поддерживает ли клиент режим строка за раз.
2. клиент отвечает will timing mark, что указывает на то, что он поддерживает опцию строка за раз.
3. сервер посылает опцию wont suppress go ahead вместе с опцией wont echo, сообщая о том, что он хочет выключить эти две опции. мы упоминали ранее, что режим символ за раз подразумевает, что обе опции suppress go ahead и echo включены, таким образом, выключение этих опций стартует режим строка за раз.
4. клиент отвечает dont suppress go ahead и dont echo.
5. сервер посылает приглашение login:, мы вводим имя. ввод отправляется серверу в виде полной строки и отражается локальным эхом клиентом.
6. сервер посылает строку password: вместе с опцией will echo. при вводе пароля отражение эхом выключается, так как telnet клиент считает, что сервер ответит эхом. клиент отвечает do echo.
7. мы вводим пароль. он отправляется клиентом на сервер в виде полной строки.
8. эхо снова включается, после того как сервер отправил wont echo, на что клиент отвечает dont echo.

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

мы упоминали ранее, что все клиенты и сервера на рисунке 26.11, которые помечены как "char", поддерживают режим строки за раз, однако по умолчанию стартуют в режиме символ за раз. мы можем увидеть, как происходит обсуждение, когда мы сообщаем клиенту о необходимости войти в линейный режим:

                                   клиент это sun, сервер это svr4
svr4 %                              вводим control-], чтобы пообщаться с telnet клиентом
                                   (эхо выключено)

telnet> status                     проверяем, находимся ли мы в режиме символ за раз
connected to svr4.tuc.noao.edu
operating in character-at-a-time mode.
escape character is '^]'.

telnet> toggle options             просмотрим обработку опций
will show option processing.

telnet> mode line                  переключимся в режим строки за раз
sent dont suppress go ahead        клиент отправляет эти две опции
sent dont echo
rcvd wont suppress go ahead        и сервер отвечает на обе wont
rcvd wont echo

telnet сессия помещается в режим строки за раз, при этом обе опции suppress go ahead и echo выключены.

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

1. telnet сервер знает, что он должен перейти в режим символ за раз, потому что приложение меняет режим на своем псевдотерминале, о чем уведомляется сервер. сервер посылает will suppress go ahead и will echo, это помещает клиента в режим символ за раз.
2. клиент отвечает do suppress go ahead и will echo.
3. приложение запускается на сервере.
4. когда приложение прекращает свою работу и изменяет режим своего псевдотерминала, telnet сервер помещает клиента обратно в режим строка за раз. он посылает wont suppress go ahead и wont echo.
5. клиент отвечает dont suppress go ahead и dont echo, указывая на то, что он вернулся в режим строка за раз.

на рисунке 26.16 показаны различные установки опций suppress go ahead и echo для режимов символ за раз и строка за раз.

рисунок 26.16 установки telnet опций при режиме строка за раз.

давайте посмотрим, что делает telnet, когда клиент вводит символ прерывания. мы открыли сессию между клиентом bsdi и сервером vangogh.cs.berkeley.edu. на рисунке 26.17 показана временная диаграмма того, что происходит, когда вводится символ прерывания. (мы удалили объявления окна и тип сервиса.)

в сегменте 1 символ прерывания (обычно control-c или delete) конвертируется в команду telnet "прерывание процесса" (ip - interrupt process): <iac, ip>. следующие 3 байта, <iac, do, tm>, содержат опцию telnet do timing mark. эта метка отправляется клиентом и на нее должен быть получен ответ либо will, либо wont. в любом случае все данные получены от сервера, перед тем как выдается отклик (за исключением команд telnet). это метка синхронизации от клиента к серверу и обратно. сегмент 1 не посылается с использованием режима срочности tcp.

рисунок 26.17 введение символа прерывания в процессе функционирования линейного режима.

требование к хостам host requirements rfc указывает, что ip команда должна быть послана с использованием сигнала синхронизации telnet. если это сделано, за <iac, ip> должно следовать <iac, dm>, с указателем срочности, указывающим на dm байт. большинство unix telnet клиентов имеют опцию, которая отправляет ip команду с сигналом синхронизации, однако эта опция по умолчанию выключена (как мы здесь и видели).

сегмент 2 это отклик сервера на опцию do timing mark. он следует в сегментах 3 и 4 за сигналом синхронизации telnet: <iac, dm>. указатель срочности в сегменте 3 указывает на dm байт, который отправляется в сегменте 4.

если в очередь поставлено полное окно данных или оно в пути от сервера к клиенту, все эти данные будут отброшены клиентом после отправки команды прерывания процесса в сегменте 1. даже если управление потоком данных tcp запретило серверу отправлять данные в сегментах 2, 3 и 4, указатель срочности все равно посылается. это аналогично тому, что мы видели в случае rlogin на рисунке 26.7.

почему сигнал синхронизации посылается в виде двух сегментов (3 и 4)? мы рассмотрели это в разделе "режим срочности (urgent mode)" главы 20, это связано с указателем срочности tcp. требование к хостам host requirements rfc говорит, что он должен указывать на последний байт срочных данных, тогда как большинство berkeley реализаций указывают на 1 байт позади последнего байта срочных данных. (обратитесь к рисунку 26.6, на котором указатель срочности указывает на 1 байт позади командного байта.) сервер telnet специально пишет первый байт сигнала синхронизации как срочные данные, зная, что указатель срочности будет (неверно) указывать на следующий байт, который он запишет (метка данных, dm), однако эта первая запись с байтом iac посылается немедленно, вместе с указателем срочности, который следует в следующем сегменте за dm байтом.

последний сегмент данных, сегмент 6, это следующее приглашение shellа от сервера.

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

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

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

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

на рисунке 26.18 сравниваются различные характеристики, предоставляемые rlogin и telnet.

рисунок 26.18 краткое описание характеристик, предоставляемых rlogin и telnet.

telnet и rlogin серверы обычно устанавливают tcp опцию "оставайся в живых" (keepalive) (глава 23), если она поддерживается реализацией tcp сервера, чтобы определить момент выхода из строя хоста клиента. оба приложения также используют режим срочности tcp, чтобы посылать команды сервера клиенту, даже если поток данных в этом направлении был остановлен управлением потока данных.

упражнения

1. найдите все задержанные ack на рисунке 26.5.
2. почему был отправлен сегмент номер 12 на рисунке 26.7?
3. мы говорили, что rlogin клиент должен использовать зарезервированный порт (глава 1, раздел "номера портов"). (обычно, rlogin клиент использует зарезервированный порт в диапазоне 512-1023.) как это ограничение отражается на хосте? существует ли способ обойти это?
4. прочитайте rfc 1097, описывающий telnet опцию subliminal-message.