В примерах, приведенных в данной книге, будут использоваться такие параметры: domain=PF_INET, type=SOCK_STREAM, protocol=0.

Вызов протокола TCP выглядит следующим образом:

int sd;

sd = socket(PF_INET, SOCK_STREAM, 0);

В переменную sd будет записан дескриптор сокета, функционально эквивалентный дескриптору файла:

int fd;

fd = open(...);

В случае возникновения ошибки функция socket () возвращает отрицательное число и помещает код ошибки в стандартную библиотечную переменную errno. Вот наиболее распространенные коды ошибок.

• EPROTONOSUPPORT. Тип протокола или указанный протокол не поддерживаются в данном домене. В большинстве доменов параметр protocol должен равняться нулю.

• EACCES. Отсутствует разрешение на создание сокета указанного типа. При создании сокетов типа SOCK_RAW и PF_PACKET программа должна иметь привилегии пользователя root.

• EINVAL. Неизвестный протокол либо семейство протоколов недоступно. Данная ошибка может возникнуть при неправильном указании параметра domain или type.

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

#include <sys/socket.h>        /* содержит прототипы функций */

#include <sys/types.h>    /* содержит объявления стандартных

                                      системных типов данных */

#include <resolv.h>    /* содержит объявления дополнительных

                                                типов данных */

В файле sys/socket.h находятся объявления функций библиотеки Socket API (включая функцию socket(), естественно). В файле sys/types.h определены многие типы данные, используемые при работе с сокетами.

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

Если провести аналогию с телефонным звонком, то сокет — это трубка, не подключенная ни к базовому аппарату, ни к телефонной линии. Функции bind(), connect() и некоторые функции ввода-вывода соединяют трубку с телефоном, а телефон — с линией. (Если в программе не содержится явного вызова функции bind (), то его осуществляет операционная система; обратитесь к главе 4).

Подключение к серверу

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

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

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

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

Синтаксис функции connect () таков:

#include <sys/socket.h>

#include <resolv.h>

int connect(int sd, struct sockaddr * server, int addr_len);

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

Функция socket () поддерживает по крайней мере два домена: PF_INET и PF_IPX. В каждом из сетевых доменов используется своя структура адреса. Все структуры являются производными от одного общего предка — структуры sockaddr. Именно она указана в заголовке функции connect().

Приведем общий вид структуры адреса и рядом для сравнения — структуру адреса в домене PF_INET (взято из файлов заголовков):

Обратите внимание: поля sa_family и sin_family в обеих структурах являются общими. Любая функция, получающая подобного рода структуру, сначала проверяет первое поле. Следует также отметить, что это единственное поле с серверным порядком следования байтов. Поля-заполнители (sa data и  pad) используются во многих структурах. По существующей договоренности структуры sockaddr и sockaddr in должны иметь размер 16 байтов (в стандарте IPv6 структура sockaddr_in6 имеет размер 24 байта), поэтому такие поля дополняют тело структуры незначащими байтами.

Необходимо обратить внимание что размер массива __pad[] не указан. Ничего неправильного в этом нет — таково общепринятое соглашение. Поскольку данный массив заполняется нулями, его размер не имеет значения (в случае структуры sockaddr_in он равен восьми байтам). В некоторых системах в структуре sockaddr in выделяются дополнительные поля для внутренних вычислений. Не стоит обращать на них внимание, а также использовать их, поскольку нет гарантии, что эти поля будут поддерживаться в другой системе. В любом случае достаточно инициализировать данную структуру нулями.

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

Прежде чем вызвать функцию connect(), программа должна заполнить описанные поля. В листинге 1.2 показано, как это сделать (полный текст примера имеется на Web-узле). Вообще говоря, в Linux не требуется приводить структуру sockaddr in к типу sockaddr. Если же предполагается использовать программу в разных системах, можно легко добавить операцию приведения типа.

Листинг 2 Использование функции connect ()

/***********************************************************/

/***    Фрагмент программы, демонстрирующий инициализацию    ***/

/***    параметров и вызов функции connect().           ***/

/**********************************************************/

#define PORTJTIME    13

struct sockaddr_in dest;

char *host = "127.0.0.1";

int sd;

/**** Создание сокета ****/

...

bzero(&dest, sizeof(dest));              /* обнуляем структуру */

dest.sin_family = AF_INET;                /* выбираем протокол */

dest.sin_port = htons(PORT_TIME);             /* выбираем порт */

inet_aton(host, &dest.sin_addr);               /* задаем адрес */

if ( connect(sd, &dest, sizeof(dest)) != 0 )  /* подключаемся! */

{

  perror("socket connection");

  abort();

}

Перед подключением к серверу выполняется ряд подготовительных действий. В первую очередь создается структура sockaddr_in. Затем объявляется переменная, содержащая адрес, по которому будет произведено обращение. После этого выполняются другие, не показанные здесь, операции, включая вызов функции socket(). Функция bzero() заполняет структуру sockaddr_in нулями. Поле sin family устанавливается равным AF_INET. Далее задаются номер порта и IP-адрес. Функции htons () и inet_aton(), выполняющие преобразования типов данных, рассматриваются в главе 2, "Основы TCP/IP".

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

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

Получение ответа от сервера

Итак, сокет открыт, и соединение установлено. Можно начинать разговор. Некоторые серверы инициируют диалог подобно людям, разговаривающим по телефону. Они как бы говорят: "Алло!" Приветственное сообщение может включать имя сервера и определенные инструкции.

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

#include <unistd.h>

ssize_t read(int fd, void *buf, size t count);

Эта функция должна быть вам знакома. Вы много раз применяли ее при работе с файлами, только на этот раз необходимо указывать дескриптор не файла (fd), а сокета (sd) , Вот как обычно организуется вызов функции функции read () :

...

int sd, bytes_read;

sd = socket(PF_INET, SOCK_STREAM, 0);    /* создание сокета */

/**** Подключение к серверу ****/

bytes_read = read(sd, buffer, MAXBUF);     /* чтение данных */

if ( bytes_read < 0 )

  /* сообщить об ошибках; завершить работу */

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

char Name[NAME], Address[ADDRESS], Phone[PHONE];

FILE *sp;

int sd;

sd = socket(PF_INET, SOCK_STREAM, 0);    /* создание сокета */

/**** Подключение к серверу ****/

if ( (sp = fopen(sd, "r")) == NOLL ) /* преобразуем дескриптор

                                                в формат FILE* */

  perror("FILE* conversion failed");

else if ( fscanf(sp, "%*s, %*s, %*s\n",       /* читаем данные

                                                      из файла */

                 NAME, Name, ADDRESS, Address,

                 PHONE, Phone) < 0)

{

perror("fscanf");

...

Только дескрипторы сокетов потокового типа могут быть свободно конвертированы в формат FILE *. Причина этого проста: в протоколе UDP соединение не устанавливается вовсе — дейтаграммы просто посылаются и все. Кроме того, потоковые сокеты обеспечивают целостность данных и надежную доставку сообщений, тогда как доставка дейтаграмм не гарантируется. Применение дейтаграмм подобно вложению письма в конверт с адресом, отправляемый по почте: нельзя быть полностью уверенным в том, что письмо дойдет до адресата. Соединение, имеющее дескриптор типа FILE*, должно быть открытым. Если преобразовать данные в формат дейтаграммы, их можно потерять.

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

Возвращаясь к функции read(), отметим, что чаще всего в результате ее выполнения возникают такие ошибки.

·EAGAIN. Задан режим неблокируемого ввода-вывода, а данные недоступны. Эта ошибка означает, что программа должна вызвать функцию повторно.

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

· EINVAL. Указанный дескриптор связан с объектом, чтение из которого невозможно.

Функция read() не имеет информации о том, как работает сокет. В Linux есть другая функция, recv(), которая наряду с чтением данных позволяет контролировать работу сокета:

#include <sys/socket.h>

#include <resolv.h>

int recv(int sd, void *buf, int len, unsigned int flags);

Эта функция принимает такие же параметры, как и функция read(), за исключением флагов. Флаги можно объединять с помощью операции побитового сложения (флаг1 | флаг2 | ...). Обычно последний параметр задается равным нулю. Читатели могут поинтересоваться, для чего в таком случае вообще вызывать функцию recv()? He проще ли вызвать функцию read()?  Лучше применять функцию recv() — это может помочь вам, если впоследствии работа программы усложнится. Да и, вообще говоря, всегда следует придерживаться какого-то одного стиля.

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

·MSG_OOB - Обработка внеполосных данных. Применяется для сообщений с повышенным приоритетом. Некоторые протоколы позволяют выбирать, с каким приоритетом следует послать сообщение: обычным или высоким. Установите этот флаг, чтобы диспетчер очереди искал и возвращал только внеполосные сообщения (подробно об этом — в главе 10, "Создание устойчивых сокетов").

·MSG_PEEK - Режим неразрушающего чтения. Заставляет диспетчер очереди извлекать сообщения, не перемещая указатель очереди. Другими словами, при последовательных операциях чтения будут возвращаться одни и те же данные (точнее, должны возвращаться; обратитесь ко врезке "Получение фрагментированных пакетов").

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

·MSG_DONTWAIT  Запрос к сокету не будет блокирован, если очередь сообщений пуста. Аналогичный режим (неблокируемый ввод-вывод) можно также задать в свойствах самого сокета. Обычно, если данные в очереди отсутствуют, диспетчер очереди ждет до тех пор, пока они не поступят. А когда этот флаг установлен, функция, запрашивающая данные, немедленно завершается, возвращая код ошибки EWOULDBLK. (В настоящее время в Linux не поддерживается этот флаг. Чтобы достигнуть требуемого результата, необходимо вызвать функцию fcntl() с флагом О_NONBLOCK. Это заставит сокет всегда работать в режиме неблокируемого ввода-вывода.)

Функция recv() является более гибкой, чем read(). Ниже показано, как прочитать данные из канала сокета (эквивалентно функции read()):

int bytes_read;

bytes_read = recv(sd, buffer, MAXBUF, 0);

...

А вот как осуществить неразрушающее чтение:

int bytes_read;

bytes_read = recv(sd, buffer, MAXBUF, MSG_PEEK);

...

Можно даже задать режим неразрушающего чтения внеполосных данных:

int bytes read;

bytes_read = recv(sd, buffer, MAXBUF, MSG_OOB | MSG_PEEK);

...

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

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

Функция recv() возвращает те же коды ошибок, что и функция read(), но есть и дополнения.

·ENOTCONN. Предоставленный дескриптор сокета не связан с одноранговым компьютером или сервером.

·ENOTSOCK. Предоставленный дескриптор не содержит сигнатуру, указывающую на то, что он был создан функцией socket ().

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

Разрыв соединения

Информация от сервера получена, сеанс прошел нормально — настало время прекращать связь. Опять-таки, есть два способа сделать это. В большинстве программ используется стандартный системный вызов close ():

#include <unistd.h>

int close(int fd);

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

Функция close () возвращает всего один код ошибки.

·EBADF. Указан неверный дескриптор файла.

Функция shutdown () позволяет лучше управлять процессом разрыва соединения, поскольку может закрывать отдельно входные и выходные каналы. Эта функция особенно полезна, когда сокет замещает стандартные потоки stdin и stdout.

С помощью функции shutdown () можно закрыть канал в одном направлении, сделав его доступным только для чтения или только для записи:

#include <sys/socket.h>

int shutdown(int s, int how);

Параметр how может принимать три значения.

Резюме: что происходит за кулисами

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

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

Для организации соединения требуется знать язык и правила сетевого общения. Все начинается с функции socket(), которая создает аналог телефонной трубки. Через эту "трубку" программа посылает и принимает сообщения. Чтение и запись данных осуществляются с помощью тех же самых функций read() и write () которые применяются при работе с файлами. Более сложные системы строятся вокруг функции recv().

Пример использования библиотеки Socket API

В сетевом соединении всегда есть отправитель и получатель. В общем случае отправителем является клиент, который запрашивает сервис, предоставляемый сетевым компьютером. В части I, "Создание сетевых клиентских приложений", рассматривались основы клиентского программирования: как подключить клиента к серверу, как организовать прямую доставку сообщений без установления соединения и как работать с протоколами стека TCP/IP. С этой главы начинается знакомство с другой стороной соединения — приемником, или сервером.

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

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

Ниже мы остановимся на том, как предоставлять сервисы и шаг за шагом рассматрим процесс создания сервера.

Схема работы сокета: общий алгоритм сервера

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

Клиентская программа, которую мы писали в первых главах, вызывала функции в такой последовательности: socket (), connect (), read(), write () и close (). Системный вызов bind() был необязательным, так как эту функцию вызывала операционная система. Номер порта не требовался, поскольку программа обращалась напрямую к серверу. Клиент всегда создает активное соединение, потому что он постоянно его занимает.

С другой стороны, серверные программы должны предоставлять своим клиентам неизменные, четко заданные номера портов. Базовая последовательность вызовов здесь будет такой: socket(), bind(), listen(), accept() и close(). В то время как клиент создает активное соединение, серверное соединение пассивно. Функции listen () и accept () устанавливают соединение только тогда, когда приходит запрос от клиента.

Знакомство с функцией bind() состоялось выше, сейчас она будет описана более формально. Кроме того, будут представлены две новые функции: listen () и accept().

Рисунок 2. Алгоритмы построения клиента и сервера сходны, но схема подключения к сети в них разная

Простой эхо-сервер

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

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

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

1.Создание сокета с помощью функции socket ().

2.Привязка к порту с помощью функции bind().

3.Перевод сокета в режим прослушивания с помощью функции listen ().

4.Проверка подключения с помощью функции accept ().

5.Чтение сообщения с помощью функции recv() или read().

6.Возврат сообщения клиенту с помощью функции send() или write ().

7.Если полученное сообщение не является строкой "bye", возврат к п. 5.

8.Разрыв соединения с помощью функции close() или shutdown().

9.Возврат к п. 4.

В приведенном алгоритме четко видны отличия от протокола UDP и других протоколов, не ориентированных на установление соединений. Здесь сервер не закрывает соединение до тех пор, пока клиент не пришлет команду "bye".

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

Привязка порта к сокету

Работа с ТСР-сокетами начинается с вызова функции socket (), которой передается константа SOCK_STREAM. Но теперь требуется задать также номер порта, чтобы клиент мог к нему подключиться.

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

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

Объявление функции bind() выглядит так:

#include <sys/socket.h>

#include <resolv.h>

int bind(int sd, struct sockaddr *addr, int addr size);

Параметр sd является дескриптором ранее созданного сокета. В параметре addr передается структура семейства sockaddr. В ней указывается семейство протоколов, адрес сервера и номер порта (см. выше). Последний параметр содержит размер структуры sockaddr. Его необходимо задавать, потому что такова концепция библиотеки Socket API: один интерфейс, но много архитектур. Операционная система поддерживает множество протоколов, у каждого из которых своя адресная структура.

Перед вызовом функции bind() необходимо заполнить поля структуры sockaddr (Листинг 3).

Листинг 3. Вызов функции bind() в TCP-сервере

/*****************************************************/

/***        Пример ТСР-сокета: заполнение структуры         ***/

/***            sockaddr_in                       ***/

/****************************************************/

struct sockaddr_in addr;                 /* создаем ТСР-сокет */

bzero(&addr, sizeof(addr));             /* обнуляем структуру */

addr.sin_family = AF_INET;            /* выбираем стек TCP/IP */

addr.sin_port = htons(MY_PORT);         /* задаем номер порта */

addr.sin_addr.s_addr = INADDR_ANY;          /* любой IP-адрес */

if ( bind(sd, &addr, sizeof(addr)) != 0 ) /* запрашиваем порт */

  perror("Bind AF_INET");

В следующем фрагменте программы (Листинг 4) осуществляется инициализация именованного сокета (семейство AF_UNIX или AF_LOCAL).

Листинг 4.Вызов функции bind() в локальном сервере

У********************************************************/

/***   Пример локального сокета: заполнение структуры         ***/

/***   sockaddr_ux                                   ***/

/*******************************************************/

#include <linux/un.h>

struct sockaddr ux addr; /* создаем локальный именованный сокет */

bzero(&addr, sizeof(addr));               /* обнуляем структуру */

addr.sun family = AF LOCAL;      /* выбираем именованные сокеты */

strcpy(addr.sun_path, "/tmp/mysocket");         /* выбираем имя */

if ( bind(sd, saddr, sizeof(addr)) != 0 )   /* привязка к файлу */

  perror("Bind AF_LOCAL");

Если запустить на выполнение эту программу, то после ее завершения в каталоге /tmp появится файл mysocket. Именованные сокеты используются системным демоном регистрации сообщений, syslogd, для сбора информации: системные процессы устанавливают соединение с сокетом демона и посылают в него сообщения.

В результате выполнения функции bind() могут возникнуть перечисленные ниже ошибки.

·EBADF. Указан неверный дескриптор сокета. Эта ошибка возникает, если вызов функции socket () завершился неуспешно, а программа не проверила код ее завершения.

·EACCES. Запрашиваемый номер порта доступен только пользователю root. Помните, что для доступа к портам с номерами 0—1023 программа должна иметь привилегии пользователя root. Подробнее об этом рассказывалось в главе 2, "Основы TCP/IP".

·EINVAL. Порт уже используется. Возможно, им завладела другая программа. Эта ошибка может также возникнуть, если сервер завис и вы тут же запускаете его повторно. Для операционной системы требуется время, чтобы освободить занятый порт (до пяти минут!).

Функция bind() пытается зарезервировать для серверного сокета указанное имя файла или порт (список доступных или стандартных портов содержится в файле /etc/services). Клиенты подключаются к данному порту, посылая и принимая через него данные.

Создание очереди ожидания

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

Очередь сокета активизируется при вызове функции listen (). Когда сервер вызывает эту функцию, он указывает число позиций в очереди. Кроме того, сокет переводится в режим "только прослушивание". Это очень важно, так как позволяет впоследствии вызывать функцию accept ().

#include <sys/socket.h>

#include <resolv.h>

int listen(int sd, int numslots);

Параметр sd является дескриптором сокета, полученным в результате вызова функции socket (). Параметр numslots задает число позиций в очереди ожидания. Приведем пример (Листинг 5).

Листинг 5. Пример функции listen ()

/*********************************************************/

/***   Пример функции listen(): перевод сокета         ***/

/***   в режим прослушивания клиентских подключений           ***/

/*********************************************************/

int sd;

sd = socket(PF_INET, SOCK_STREAM, 0);

/*** Привязка к порту ***/

if ( listen(sd, 20) != 0 )            /* перевод сокета в режим */

  perror("Listen");   /* прослушивания очереди с 20-ю позициями */

Как правило, размер очереди устанавливается равным от 5 до 20. Больший размер оказывается избыточным в современной многозадачной среде. Если многозадачный режим не поддерживается, может потребоваться увеличить размер очереди до величины периода тайм-аута (например, 60, если тайм-аут составляет 60 секунд).

Функция listen () может генерировать следующие ошибки.

1.EBADF. Указан неверный дескриптор сокета.

2.EOPNOTSUPP. Протокол сокета не поддерживает функцию listen (). В TCP (SOCK_STREAM) очередь ожидания поддерживается, а в протоколе UDP (SOCK_DGRAM) — нет.

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

Прием запросов от клиентов

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

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

Можно также узнать, кто устанавливает соединение с сервером, поскольку в функцию accept() передается информация о клиенте. Аналогичный процесс рассматривался в главе 4, "Передача сообщений между одноранговыми компьютерами", когда функция recvfrom() получала не только данные, но и указатель на адрес отправителя.

#include <sys/socket.h>

#include <resolv.h>

int accept(int sd, sockaddr *addr, int *addr size);

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

Необходимо убедиться, что размер буфера адреса достаточен для размещения в нем полученной адресной структуры. Беспокоиться о повреждении данных из-за переполнения буфера не стоит: функция задействует ровно столько байтов, сколько указано в третьем параметре. Параметр addr size передается по ссылке, поэтому программа может легко узнать реальный размер полученной структуры (листинг 6.4).

Листинг 6. Пример функции accept ().

/***************************************************************/

/***   Пример функции accept(): ожидание и принятие запросов ***/

/***   на подключение от клиентов                                                    ***/

/***************************************************************/

int sd;

struct sockaddr in addr;

/*** Создание сокета, привязка его к порту и

     перевод в режим прослушивания ***/

for (;;)                         /* цикл повторяется бесконечно */

{  int clientsd;                     /* новый дескриптор сокета */

   int size = sizeof(addr);     /* вычисление размера структуры */

   clientsd = accept(sd, saddr, &size); /* ожидание подключения */

   if ( clientsd > 0 )                            /* ошибок нет */

   {

       /*** взаимодействие с клиентом ***/

       close(clientsd);                 /* очистка и отключение */

   }

   else                                     /* произошла ошибка */

      perror ("Accept");

Взаимодействие с клиентом

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

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

Листинг 7.Пример функции accept () с регистрацией подключений.

/**********************************************************/

/*** Расширенный пример функции accept(): информация      ***/

/***  о каждом новом подключении отображается на экране      ***/

/*********************************************************/

/*** (Внутри цикла) ***/

client = accept(sd, &addr, &size);

if ( client > 0 )

{

  if ( addr.sin_faaily == AF_INET)

    printf("Connection[%s]: %s:%d\n",            /* регистрация */

            ctime(tiine(0)),                   /* метка времени */

            ntoa(addr.sin_addr), ntohs(addr.sin_port));

/*--- взаимодействие с клиентом ---*/

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

·EBADF. Указан неверный дескриптор сокета.

·EOPNOTSOPP. При вызове функции accept () сокет должен иметь тип SOCK_STREAM.

·EAGAIN. Сокет находится в режиме неблокируемого ввода-вывода, а очередь ожидания пуста. Функция accept () блокирует работу программы, если не включен данный режим.

Настало время вернуться к эхо-серверу, который возвращает клиенту полученное сообщение до тех пор, пока не поступит команда bye (Листинг 8).

Листинг 8.Пример эхо-сервера.

/****************************************************************/

/***     Пример эхо-сервера: возврат полученного сообщения    ***/

/***     до тех пор, пока не поступит команда "bye<ret>"      ***/

/****************************************************************/

/*** (Внутри цикла после функции accept()) ***/

if ( client > 0 )

{ char buffer[1024];

  int nbytes;

  do

  {

    nbytes = recv(client, buffer, sizeof(buffer), 0);

    if ( nbytes > 0 ) /* если получены данные, возвращаем их */

       send(client, buffer, nbytes, 0);

  }

  while ( nbytes > 0 && strncmp("bye\r", buffer, 4) != 0);

  close(client);

}

Заметьте, что признаком окончания сеанса является строка "bye\r", а не "bye\n". В общем случае это зависит от того, как выполняется обработка входного потока. Из соображений надежности следует проверять оба случая. Попробуйте протестировать данную программу, использовав в качестве клиента утилиту Telnet.

На главную