Книга: Операционная система UNIX

Программный интерфейс TLI

Программный интерфейс TLI

При обсуждении реализации сетевой поддержки в BSD UNIX был рассмотрен программный интерфейс доступа к сетевым ресурсам, основанный на сокетах. В данном разделе описан интерфейс транспортного уровня (Transport Layer Interface, TLI), который обеспечивает взаимодействие прикладных программ с транспортными протоколами.

TLI был впервые представлен в UNIX System V Release 3.0 в 1986 году. Этот программный интерфейс тесно связан с сетевой подсистемой UNIX, основанной на архитектуре STREAMS, изолируя от прикладной программы особенности сетевой архитектуры. Вместо того чтобы непосредственно пользоваться общими функциями STREAMS, рассмотренными в предыдущей главе, TLI позволяет использовать специальный набор вызовов, специально предназначенных для сетевых приложений. Для преобразования вызовов TLI в функции интерфейса STREAMS используется библиотека TLI, которая в большинстве систем UNIX имеет название libnsl.a или libnsl.so.

Схема использования функций TLI во многом сходна с рассмотренным интерфейсом сокетов и зависит от типа используемого протокола — с предварительным установлением соединения (например, TCP) или без него (например, UDP).

На рис. 6.18 и 6.19 представлены схемы использования функций TLI для транспортных протоколов с предварительным установлением соединения и без установления соединения. Можно отметить, что эти схемы очень похожи на те, с которыми мы уже встречались в разделе "Межпроцессное взаимодействие в BSD UNIX. Сокеты" главы 3 при обсуждении сокетов. Некоторые различия отмечены ниже при описании функций TLI.

Рис. 6.18. Схема вызова функций TLI для протокола с предварительным установлением соединения

Рис. 6.19. Схема вызова функций TLI для протокола без предварительного установления соединения

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

Для определения адреса TLI предоставляет общую структуру данных netbuf, имеющую вид:

struct netbuf {
 unsigned int maxlen;
 unsigned int len;
 char *buf;
}

Поле buf указывает на буфер, в котором может передаваться адрес узла, maxlen определяет его размер, a len — количество данных в буфере, т.е. размер адреса. Эта структура по своему назначению похожа на структуру sockaddr, которая является общим определением адреса коммуникационного узла для сокетов. Далее рассматривается пример сетевого приложения, основанного на TLI, где показано, как netbuf используется при передаче адреса для протоколов TCP/IP.

Структура netbuf используется в TLI для хранения не только адреса, но и другой информации — опций протокола и прикладных данных. Эта структура является составной частью более сложных структур данных, используемых при передаче параметров в функциях TLI. Для упрощения динамического размещения этих структур библиотека TLI предоставляет две функции: t_alloc(3N) для размещения структуры и t_free(3N) для освобождения памяти. Эти функции имеют следующий вид:

#include <tiuser.h>
char *t_alloc(int fd, int struct_type, int fields);
int t_free(char *ptr, int struct_type);

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

Co структурами, приведенными в таблице, мы познакомимся при обсуждении функций TLI. Большинство из них включают несколько элементов netbuf. Поскольку в некоторых случаях может отсутствовать необходимость размещения всех элементов netfuf, поле fields позволяет указать, какие конкретно буферы необходимо разместить для данной структуры:

Отметим одну особенность. Фактический размер буфера и, соответственно, структуры netbuf зависят от значения поля maxlen этой структуры. В свою очередь, этот параметр зависит от конкретного поставщика транспортных услуг — именно он определяет максимальный размер адреса, опций и прикладных данных. Чуть позже мы увидим, что эта информация ассоциирована с транспортным узлом и может быть получена после его создания с помощью функции t_open(3N). Поэтому для определения фактического размера размещаемых структур в функции t_аlloc(3N) необходим аргумент fd, являющийся дескриптором транспортного узла, который возвращается процессу функцией t_open(3N).

Перейдем к основным функциям TLI.

Как видно из рис. 6.18 и 6.19, в качестве первого этапа создания коммуникационного узла используется функция t_open(3N). Как и системный вызов open(2), она возвращает дескриптор, который в дальнейшем адресует узел в функциях TLI. Функция имеет вид:

#include <tiuser.h>
#include <fcitl.h>
int t_open(const char *path, int oflags, struct t_info *info);

Аргумент path является именем специального файла устройства, являющегося поставщиком транспортных услуг, например, /dev/tcp или /dev/udp. Аргумент oflags определяет флаги открытия файла и соответствует аналогичному аргументу системного вызова open(2). Приложение может получить информацию о поставщике транспортных услуг в структуре info, имеющей следующие поля:

Прежде чем передача данных будет возможна, транспортному узлу должен быть присвоен адрес. Эта фаза называется операцией связывания и мы уже сталкивались с ней при разговоре о сокетах в главе 3 и при обсуждении сетевой поддержки в BSD UNIX ранее в этой главе. В рассмотренных случаях связывание выполнял вызов bind(2). В TLI для этого служит функция t_bind(3N), имеющая вид:

#include <tiuser.h>
int t_bind(int fd, const struct t_bind *req,
 struct t_bind *ret);

Аргумент fd адресует коммуникационный узел. Аргумент req позволяет программе явно указать требуемый адрес, а через аргумент ret возвращается значение, установленное протоколом.

Два последних аргумента описываются структурой t_bind, имеющей следующие поля:

Рассмотрим три возможных формата аргумента req:

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

Для протоколов с предварительным установлением соединения программе-клиенту необходимо использовать функцию t_connect(3N), отправляющую запрос на создание соединения с удаленным транспортным узлом. Функция t_connect(3N) имеет вид:

#include <tiuser.h>
int t_connect(int fd, const struct t_call* sndcall,
 struct t_call *rcvcall);

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

Через аргумент revcall программе возвращается информация о виртуальном канале после его создания: адрес удаленного узла, опции и прикладные данные, переданные удаленным узлом. Как уже отмечалось, ни TCP, ни UDP не позволяют передавать данные вместе с управляющей информацией. Программа может установить значение rcvcall равным NULL, если информация о канале ее не интересует.

Обычно возврат из функции t_connect(3N) происходит после окончательного установления соединения, когда виртуальный канал готов к передаче данных (конечно, в случае успешного завершения).

Для протоколов с предварительным установлением соединения программа-сервер вызывает функцию t_listen(3N), блокируя свое выполнение до получения запроса на создание виртуального канала.

#include <tiuser.h>
int t_listen(int fd, struct t_call *call);

Информация, возвращаемая транспортным протоколом в аргументе call, содержит параметры, переданные удаленным узлом с помощью соответствующего вызова t_connect(3N): его адрес, установленные опции протокола, а также, в ряде случаев, прикладные данные, переданные вместе с запросом. Поле sequence аргумента call содержит уникальный идентификатор данного запроса.

Хотя t_listen(3N), несмотря на название, напоминает функцию accept(2), используемую для сокетов, сервер должен выполнить вызов другой функции — t_accept(3N) для того, чтобы фактически принять запрос и установить соединение. Функция t_accept(3N) имеет вид:

#include <tiuser.h>
int t_accept(int fd, int connfd, struct t_call *call);

Аргумент fd адресует транспортный узел, принявший запрос (тот же, что и для функции t_listen(3N)). Аргумент connfd адресует транспортный узел, для которого будет установлено соединение с удаленным узлом. За создание нового транспортного узла отвечает сама программа (т.е. необходим явный вызов функции t_open(3N)), при этом fd может по-прежнему использоваться для обслуживания поступающих запросов.

Как и в случае t_listen(3N), через аргумент call передается информация об удаленном транспортном узле.

После возврата из функции t_accept(3N) между двумя узлами (connfd и удаленным узлом-клиентом) образован виртуальный канал, готовый к передаче прикладных данных.

Для обмена прикладными данными после установления соединения используются две функции: t_rcv(3N) для получения и t_snd(3N) для передачи. Они имеют следующий вид:

#include <tiuser.h>
int t_rcv(int fildes, char *buf, unsigned nbytes, int* flags);
int t_snd(int fildes, char *buf, unsigned nbytes, int flags);

Первые три аргумента соответствуют аналогичным аргументам системных вызовов read(2) и write(2). Аргумент flags функции t_snd(3N) может содержать следующие флаги:

Эту информацию принимающий узел получает с помощью t_rcv(3N) также через аргумент flags.

Для протоколов без предварительного установления соединения используются функции t_rcvdata(3N) и t_snddata(3N) для получения и передачи датаграмм соответственно. Функции имеют следующий вид:

#include <tiuser.h>
int t_rcvudata(int fildes, struct t_unitdata *unitdata,
 int* flags);
int t_sndudata(int fildes, struct t_unitdata *unitdata);

Для передачи данных используется структура unitdata, имеющая следующие поля:

Созданный транспортный узел может быть закрыт с помощью функции t_close(3N). Заметим, что при этом соединение, или виртуальный канал, с которым ассоциирован данный узел, в ряде случаев не будет закрыт. Функция t_close(3N) имеет вид:

#include <tiuser.h>
int t_close(int fd);

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

Завершая разговор о программном интерфейсе TLI, необходимо упомянуть об обработке ошибок. Для большинства функций TLI свидетельством ошибки является получение -1 в качестве возвращаемого значения. Напротив, в случае нормального завершения эти функции возвращают 0. Как правило, при неудачном завершении функции TLI код ошибки сохраняется в переменной t_errno, подобно тому, как переменная errno хранит код ошибки системного вызова. Для вывода сообщения, расшифровывающего причину ошибки, используется функция t_error(3N):

#include <tiuser.h>
void t_error(const char *errmsg);

При вызове t_error(3N) после неудачного завершения какой-либо функции TLI будет выведено сообщение errmsg, определенное разработчиком программы, за которым последует расшифровка ошибки, связанной с кодом t_errno. Если значение t_errno равно TSYSERR, то расшифровка представляет собой стандартное сообщение о системной ошибке, связанной с переменной errno.

В заключение в качестве иллюстрации программного интерфейса TLI приведем пример приложения клиент-сервер. Как и в предыдущих примерах, сервер принимает сообщения от клиента и отправляет их обратно. Клиент, в свою очередь, выводит полученное сообщение на экран. В качестве сообщения, как и прежде, выступает жизнерадостное приветствие "Здравствуй, мир!".

#include <sys/types.h>
#include <sys/socket.h>
#include <tiuser.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <fcntl.h>
#include <netdb.h>
/* Номер порта, известный клиентам */
#define PORTNUM 1500
main(argc, argv)
int argc;
char *argv[];
{
 /* Дескрипторы транспортных узлов сервера */
 int tn, ntn;
 int pid, flags;
 int nport;
 /* Адреса транспортных узлов сервера и клиента */
 struct sockaddr_in serv_addr, *clnt_addr;
 struct hostent *hp;
 char buf[80], hname[80];
 struct t_bind req;
 struct t_call *call;
 /* Создадим транспортный узел. В качестве поставщика
    транспортных услуг выберем модуль TCP */
 if ((tn = t_open("/dev/tcp", O_RDWR, NULL)) == -1) {
  t_error("Ошибка вызова t_open()");
  exit(1);
 }
 /* Зададим адрес транспортного узла — он должен быть
    известен клиенту */
 nport = PORTNUM;
 /* Приведем в соответствие порядок следования байтов для хоста
    и сети */
 nport = htons((u_short)nport);
 bzero(&serv_addr, sizeof(serv_addr));
 serv_addr.sin_family = AF_INET;
 serv_addr.sin_addr.s_addr = INADDR_ANY;
 serv_addr.sin_port = nport;
 req.addr.maxlen = sizeof(serv_addr);
 req.addr.len = sizeof(serv_addr);
 req.addr.buf = (char*)&serv_addr;
 /* Максимальное число запросов, ожидающих обработки,
    установим равным 5 */
 req.qlen = 5;
 /* Свяжем узел с запросом */
 if (t_bind(tn, &req, (struct t_bind*)0) < 0) {
  t_error("Ошибка вызова t_bind();
  exit(1);
 }
 fprintf(stderr, "Адрес сервера: %sn",
  inet_ntoa(serv_addr.sin_addr));
 /* Поскольку в структуре t_call нам понадобится только буфер
    для хранения адреса клиента, разместим ее динамически */
 if ((call =
  (struct t_call*)t_alloc(tn, T_CALL, T_ADDR)) == NULL) {
  t_error("Ошибка вызова t_alloc()");
  exit(2);
 }
 call->addr.maxlen = sizeof(serv_addr);
 call->addr.len = sizeof(srv_addr);
 call->opt.len = 0;
 call->update.len = 0;
 /* Бесконечный цикл получения и обработки запросов */
 while (1) {
  /* Ждем поступления запроса на установление соединения */
  if (t_listen(s, call) < 0) {
   t_error("Ошибка вызова t_listen()");
   exit(1);
  }
  /* Выведем информацию о клиенте, сделавшем запрос */
  clnt_addr = (struct sockaddr_in*)call->addr.buf;
  printf("Клиент: %sn", inet_ntoa(clnt_addr->sin_addr));
  /* Создадим транспортный узел для обслуживания запроса */
  if (ntn = t_open("/dev/tcp", O_RDWR, (struct t_info*)0)) < 0) {
   t_error("Ошибка вызова t_open()");
   exit(1);
  }
  /* Пусть система сама свяжет его с подходящим адресом */
  if (t_bind(ntn, (struct t_bind*)0), (struct t_bind*)0) < 0) {
   t_error("Ошибка вызова t_accept()");
   exit(1);
  }
  /* Примем запрос и переведем его обслуживание на новый
     транспортный узел */
  if (t_accept(tn, ntn, call) < 0) {
   t_error("Ошибка вызова t_accept()");
   exit(1);
  }
  /* Создадим новый процесс для обслуживания запроса.
     При этом родительский процесс продолжает принимать
     запросы от клиентов */
  if ((pid = fork()) == -1) {
   t_error("Ошибка вызова fork()");
   exit(1);
  }
  if (pid == 0) {
   int nbytes;
   /* Дочерний процесс: этот транспортный узел уже не нужен,
      он используется родителем */
   close(tn);
   while ((nbytes = t_rcv(ntn, buf,
    sizeof(buf), &flags)) != 0) {
    t_snd(ntn, buf, sizeof(buf), 0);
   }
   t_close(ntn);
   exit(0);
  }
  /* Родительский процесс: этот транспортный узел не нужен,
     он используется дочерним процессом для обмена данными
     с клиентом */
  t_close(ntn);
 }
 t_close(ntn);
}

#include <sys/types.h>
#include <sys/socket.h>
#include <tiuser.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <fcntl.h>
#include <netdb.h>
#define PORTNUM 1500
main(argc, argv)
char *argv[];
int argc;

{

 int tn;
 int flags;
 struct sockaddr_in serv_addr;
 struct hostent *hp;
 char buf[80]="Здравствуй, мир!";
 struct t_call* call;
 /* В качестве аргумента клиенту передается доменное имя хоста,
    на котором запущен сервер. Произведем трансляцию доменного
    имени в адрес */
 if ((hp = gethostbyname(argv[1])) == 0) {
  perror("Ошибка вызова gethostbyname()");
  exit(1);
 }
 /* Создадим транспортный узел. В качестве поставщика
    транспортных услуг выберем модуль TCP */
 printf("Сервер готовn");
 if ((tn = t_open("/dev/tcp", O_RDWR, NULL)) == -1) {
  t_error("Ошибка вызова t_open()");
  exit(1);
 }
 /* Предоставим системе самостоятельно связать узел с
    подходящим адресом */
 if (t_bind(tn, (struct t_bind*)0,
  (struct t_bind *)0) < 0} {
  t_error("Ошибка вызова t_bind()");
  exit(1);
 }
 fprintf(stderr, "Адрес клиента: %sn",
  inet_ntoa(serv_addr.sin_addr));
 /* Укажем адрес сервера, с которым мы будем работать */
 bzero(&serv_addr, sizeof(serv_addr));
 bcopy(hp->h_addr, &serv_addr.sin_addr, hp->h_length);
 serv_addr.sin_family = hp->h_addrtype;
 /* Приведем в соответствие порядок следования байтов
    для хоста и сети */
 serv_addr.sin_port = htons(PORTNUM);
 /* Поскольку в структуре t_call нам понадобится только буфер
    для хранения адреса сервера, разместим ее динамически */
 if ((call =
  (struct t_call*)t_alloc(tn, T_CALL, T_ADDR)) == NULL) {
  t_error("Ошибка вызова t_alloc()");
  exit(2);
 }
 call->addr.maxlen = sizeof(serv_addr);
 call->addr.len = sizeof(serv_addr);
 call->addr.buf = (char*)&serv_addr;
 call->opt.len = 0;
 call->udata.len = 0;
 /* Установи соединение с сервером */
 if (t_connect(tn, call, (struct t_call*)0) == -1) {
  t_error("Ошибка вызова t_rcv()");
  exit(1);
 }
 /* Передадим сообщение и получим ответ */
 t_snd(tn, buf, sizeof(buf), 0);
 if (t_rcv(tn, buf, sizeof(buf), &flags) < 0) {
  t_error("Ошибка вызова t_rcv()");
  exit(1);
 }
 /* Выведем полученное сообщение на экран */
 printf("Получено от сервера: %sn", buf);
 printf("Клиент завершил работу!nn");
}

В рассмотренном примере большая часть исходного текста посвящена созданию транспортных узлов и установлению соединения, в то время как завершение сеанса связи представлено скупыми вызовами t_close(3N). На самом деле, вызов t_close(3N) приводит к немедленному разрыву соединения, запрещая дальнейшую передачу или прием данных. Однако виртуальный канал, обслуживаемый протоколом TCP, является полнодуплексным и, как было показано, TCP предусматривает односторонний разрыв связи, позволяя другой стороне продолжать передачу данных. Действиям, предписываемым TCP, больше соответствуют две функции t_sndrel(3N) и t_rcvrel(3N), которые обеспечивают "корректное "прекращение связи (orderly release). Разумеется, эти рассуждения справедливы лишь для транспортного протокола, обеспечивающего передачу данных с предварительным установлением связи, каковым, в частности, является протокол TCP.

Функции t_sndrel(3N) и t_rcvrel(3N) имеют вид:

#include <tiuser.h>
int t_sndrel(int fd);
int t_rcvrel(int fd);

Вызывая функцию t_sndrel(3N), процесс отправляет другой стороне уведомление об одностороннем прекращении связи, это означает, что процесс не намерен больше передавать данные. В то же время процесс может принимать данные — файловый дескриптор fd доступен для чтения.

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

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

#include <tiuser.h>
int t_look(int fildes);

Функция возвращает идентификатор, соответствующий одному из событий, перечисленных в табл. 6.6.

Таблица 6.6. События, связанные с коммуникационным узлом

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

Проиллюстрируем описанную процедуру фрагментом программы, обрабатывающей корректное прекращение связи:

while (t_rcv(fd) != -1) {
 /* Выполняем обработку принятых данных */
 ...
}
if (t_errno == T_LOOK && t_look(fd) == T_ORDREL) {
 /* Значит, получен запрос на корректное прекращение связи.
    Мы согласны на завершение сеанса, поэтому также корректно
    завершаем связь */
 t_rcvrel(fd);
 t_sndrel(fd);
 exit(0);
} else {
 t_error("Ошибка получения данных (t_rcv)");
 exit(1);
}

Оглавление книги