Работа с сокетами как оконечными точками при взаимодействии процессов начинается с их (сокетов) создания посредством функции socket() (см. пример 11.19). Она возвращает открытый файловый дескриптор, который может быть использован в последующих вызовах функций, оперирующих с сокетами. В том же листинге показано описание функции socketpair(), создающей пару сокетов с установленным между ними соединением.
#include <sys/socket.h>int socket (int af, int type, int protocol);int socketpair (int af, int type, int protocol, int sds [2]);
Листинг 11.19. Описание функций socket() и socketpair().
Аргумент af задает адресное семейство создаваемого сокета, аргумент type - тип, аргумент protocol - конкретный протокол (0 обозначает неспецифицированный подразумеваемый протокол, пригодный для запрошенного типа). Напомним, что подходящие значения для аргументов af, type и protocol можно получить с помощью описанной ранее функции getaddrinfo().
Функция socketpair() по назначению аналогична pipe(), только организуется не безымянный канал, а пара соединенных, безымянных (не привязанных к каким-либо адресам), идентичных сокетов, открытые файловые дескрипторы которых помещаются в массив sds. Обычно она используется для адресного семейства AF_UNIX; поддержка для других семейств не гарантируется.
После того как посредством функции bind() (см. пример 11.20) создан сокет, идентифицируемый дескриптором sd, ему присваивают локальный адрес, заданный аргументом address (address_len - длина структуры sockaddr, на которую указывает address). Источником локальных адресов для сокетов может служить вышеупомянутая функция getaddrinfo().
Опросить присвоенный локальный адрес (его иногда называют именем сокета) можно с помощью функции getsockname() (см. пример 11.21): она помещает его в структуру sockaddr, на которую указывает аргумент address, а длину адреса записывает по указателю address_len.
Если сокет ориентирован на режим с установлением соединения (имеет тип SOCK_STREAM), то, воспользовавшись функцией listen() (см. пример 11.22), его следует пометить как готового принимать соединения ("слушающего").
#include <sys/socket.h>int listen (int sd, int backlog);
Листинг 11.22. Описание функции listen().
Аргумент backlog сообщает операционной системе рекомендуемую длину очереди соединений, ожидающих обработки слушающим сокетом. Реализация должна поддерживать значения аргумента backlog вплоть до конфигурационной константы SOMAXCONN, определенной в заголовочном файле <sys/socket.h>. ОС имеет право установить длину очереди меньше рекомендуемой. При неположительном значении backlog очередь будет иметь зависящую от реализации минимальную длину.
Прием соединений выполняет функция accept() (см. пример 11.23). Она выбирает первое соединение из очереди, ассоциированной с заданным дескриптором sd слушающим сокетом, создает новый сокет с теми же адресным семейством, типом и протоколом и возвращает в качестве результата его файловый дескриптор.
Если значение аргумента address отлично от пустого указателя, то в структуру sockaddr, на которую указывает address, помещается адрес сокета, пытающегося установить соединение. По указателю address_len при обращении к функции accept() должна быть задана длина переданной структуры sockaddr, а на выходе туда записывается длина адреса партнера по взаимодействию.
Если очередь соединений, ожидающих обработки слушающим сокетом, пуста и для дескриптора sd не установлен флаг O_NONBLOCK, то вызвавший функцию accept() процесс (поток управления) блокируется до появления подобного соединения. При непустой очереди функция select() сообщит о готовности дескриптора sd к чтению.
Другая сторона, т. е. потенциальный партнер по взаимодействию, инициирует соединение с помощью функции connect() (см. пример 11.24). Аргументы address и address_len стандартным образом задают адрес сокета (как правило, слушающего), с которым необходимо установить соединение.
Если для сокета, заданного аргументом sd (запрашивающего установление соединения), еще не выполнена привязка к локальному адресу, функция connect() сама осуществит связывание со свободным локальным адресом (правда, лишь при условии, что адресное семейство сокета отлично от AF_UNIX).
Функция connect() ограничится фиксацией адреса сокета, взаимодействующего с заданным аргументом sd, если тип сокета не требует установления соединения. В частности, для сокетов типа SOCK_DGRAM таким способом можно специфицировать адреса отправляемых (с помощью функции send()) и принимаемых (посредством обращения к функции recv()) датаграмм.
Когда в качестве аргумента address передается пустой указатель, адрес взаимодействующего сокета сбрасывается.
Попытка установить соединение блокирует вызывающий процесс на неспецифицируемый промежуток времени (в случае наличия флага O_NONBLOCK). Если по истечении этого промежутка соединение установить не удалось, вызов connect(), равно как и попытка установления соединения, завершаются неудачей. Если ожидание прерывается обрабатываемым сигналом, вызов connect() завершается неудачей (переменной errno присваивается значение EINTR), но установление соединения продолжается и будет завершено асинхронно.
Если для дескриптора sd задан флаг O_NONBLOCK, а соединение не может быть установлено немедленно, то вызов connect() завершается неудачей со значением errno, равным EINPROGRESS, но установление соединения продолжается и будет завершено асинхронно. Последующие обращения к функции connect() с тем же сокетом, выполненные до установления соединения, завершаются неудачей (EALREADY).
Сокет оказывается в неспецифицированном состоянии, если функция connect() завершается неудачей по другим причинам. Приложения, соответствующие стандарту POSIX-2001, должны закрыть файловый дескриптор sd и создать новый сокет для продолжения попыток установить соединение.
После асинхронного установления соединения функции select() и poll() сообщат, что файловый дескриптор sd готов к записи.
Функция poll(), позволяющая мультиплексировать ввод/вывод в пределах набора файловых дескрипторов, была описана нами выше. Имеющая сходную направленность (но входящая в обязательную часть стандарта POSIX-2001) функция select() и ее недавно введенный аналог pselect() представлены в пример 11.25.
Листинг 11.25. Описание функций семейства select*().
Если значение аргумента readfds (writefds, errorfds) функции pselect() отлично от NULL, оно ссылается на объект типа fd_set, который на входе специфицирует набор файловых дескрипторов, проверяемых на готовность к чтению (или к записи, или к обработке исключительных ситуаций), а на выходе указывает, какие из них успешно прошли проверку. Аргумент nfds задает границу проверяемых дескрипторов (они являются небольшими целыми числами): дескриптор подлежит проверке, если его значение находится в пределах от 0 до (nfds - 1) включительно.
Стандарт POSIX-2001 определяет тип fd_set как абстрактный. Для работы со значениями этого типа служат макросы FD_ZERO() (сделать набор пустым), FD_SET() (добавить дескриптор к набору), FD_CLR() (удалить дескриптор из набора), FD_ISSET() (проверить принадлежность дескриптора набору). Значение именованной константы FD_SETSIZE равно максимально допустимому числу дескрипторов в наборе.
В качестве результата pselect() возвращается общее количество дескрипторов во всех трех наборах, успешно прошедших проверку.
При отсутствии готовых дескрипторов вызывающий процесс блокируется, пока таковые не появятся, или пока не истечет заданное аргументом timeout время ожидания, или пока ожидание не будет прервано сигналом. Пустой указатель в качестве значения timeout означает бесконечное ожидание, а нулевые значения полей структуры timespec - отсутствие блокировки. Реализация может накладывать ограничение на максимальное время ожидания, но оно не должно быть меньше тридцати одного дня.
Если значение аргумента sigmask отлично от пустого указателя, функция pselect() на входе заменяет маску сигналов процесса на заданную, а на выходе восстанавливает прежнюю маску.
Функция pselect() поддерживает обычные файлы, терминалы и псевдотерминалы, каналы и сокеты.
Функция select() эквивалентна pselect() со следующими оговорками.
Для функции select() время ожидания задается в секундах и микросекундах в виде структуры типа timeval, а для pselect() - в секундах и наносекундах как аргумент типа struct timespec.
У функции select() нет аргумента - маски сигналов, что эквивалентно пустому указателю в качестве значения аргумента sigmask функции pselect().
В случае успешного завершения функция select() может модифицировать структуру, на которую указывает аргумент timeout.
С сокетами могут быть ассоциированы опции, влияющие на их функционирование. Значения этих опций можно опросить или изменить с помощью функций getsockopt() и setsockopt() (см. пример 11.26).
#include <sys/socket.h>int getsockopt (int sd, int level, int option_name, void *restrict option_value, socklen_t *restrict option_len);int setsockopt (int sd, int level, int option_name, const void *option_value, socklen_t option_len);
Листинг 11.26. Описание функций getsockopt() и setsockopt().
Опции задаются именованными константами (аргумент option_name), которые определены в заголовочном файле <sys/socket.h>. Выделим среди них наиболее употребительные и разделим на несколько групп. К первой отнесем опции с целочисленными значениями, описывающими характеристики или состояние сокета.
SO_ERROR
Статус ошибок (после опроса очищается).
SO_TYPE
Тип сокета.
Ко второй группе отнесем булевы опции, представленные целочисленными значениями (0 означает ложь).
SO_DEBUG
Сообщает, записывается ли отладочная информация о работе сокета.
SO_ACCEPTCONN
Указывает, является ли сокет слушающим.
В третью группу включены опции с целочисленными значениями, определяющими количественные характеристики объектов, ассоциированных с сокетом.
SO_SNDBUF
Размер буфера для передаваемых данных (выходного буфера).
SO_RCVBUF
Размер входного буфера.
SO_RCVLOWATM
Минимальное число байт, обрабатываемых при вводе. Подразумеваемое значение равно единице. Большие значения могут вызвать блокировку принимающего процесса до поступления в сокет необходимого объема данных.
SO_SNDLOWAT
Минимальное число байт, обрабатываемых при выводе.
В четвертую группу входят опции со структурными значениями.
SO_LINGER
Определяет, блокировать ли процесс при закрытии дескриптора sd до передачи буферизованных данных, и если блокировать, то на какой срок. Значением опции является структура linger, определенная в заголовочном файле <sys/socket.h> и содержащая, согласно стандарту POSIX-2001, по крайней мере следующие поля.
int l_onoff; /* Признак, включена ли опция блокирования *//* при закрытии */ int l_linger; /* Длительность блокирования в секундах */SO_RCVTIMEO
Длительность ожидания поступления данных при вводе. Значение - упомянутая выше структура типа timeval. Подразумевая длительность равна нулю. Если в течение специфицированного промежутка времени новых данных не поступило, операция ввода вернет число байт, меньше запрошенного, или завершится ошибкой EAGAIN.
SO_SNDTIMEO
Длительность ожидания отправки данных при выводе.
Не все из перечисленных опций могут быть переустановлены функцией setsockopt(). Исключение по понятным причинам составляют SO_ERROR, SO_TYPE, SO_ACCEPTCONN.
Аргумент level задает протокольный уровень опции. Уровню сокетов соответствует значение SOL_SOCKET, уровню TCP - IPPROTO_TCP.
Функция getpeername() (см. пример 11.27), во многом аналогичная рассмотренной выше функции getsockname(), позволяет опросить еще одну характеристику - адрес (имя) сокета, с которым установлено соединение.
После привязки сокета к локальному адресу, а также установления, при необходимости, соединения и задания значений опций, можно приступать к отправке и/или приему данных через сокет. Для этого служат функции, описания которых показаны в пример 11.28.
Листинг 11.28. Описание функций обмена данными через сокет.
Функция recvfrom() позволяет прочитать данные (в рассматриваемом контексте называемые также сообщением) из сокета с дескриптором sd и поместить их в буфер buffer длины length. Обычно функцию recvfrom() применяют к сокетам, ориентированным на режим без установления соединения, поскольку она выдает исходный адрес в структуре типа sockaddr.
В число возможных составляющих значения аргумента flags входят следующие флаги.
MSG_PEEK
Не удалять прочитанные данные. Следующий вызов recvfrom() или другой функции ввода снова вернет их.
MSG_WAITALL
Для сокетов типа SOCK_STREAM флаг означает, что вызывающий процесс блокируется до получения всего запрошенного объема данных (а не до прихода первого сообщения).
MSG_OOB
Запрашиваются экстренные данные. Трактовка этого понятия зависит от протокола.
Как и положено функции ввода, в результате recvfrom() возвращает количество прочитанных и помещенных в буфер данных. Для сокетов, учитывающих границы сообщений (SOCK_RAW, SOCK_DGRAM, SOCK_SEQPACKET), за одно обращение читается все сообщение; если оно не помещается в буфер, лишние байты (в отсутствие флага MSG_PEEK) отбрасываются.
Формально можно считать, что функция recv() эквивалентна recvfrom() с нулевым значением аргумента address_len. Поскольку она не позволяет узнать исходный адрес, ее обычно используют для сокетов, установивших соединение. (Можно провести и еще одну аналогию: если пренебречь флагами, функция recv() эквивалентна read().)
По сравнению с recv(), более содержательным аналогом функции recvfrom() является recvmsg(). Отличия в данном случае носят скорее синтаксический характер и по сути сводятся к способу передачи входных значений и возврата результатов: для минимизации числа аргументов функция recvmsg() использует структуру типа msghdr, которая, согласно стандарту POSIX-2001, должна содержать по крайней мере следующие поля.
void *msg_name; /* Указатель на буфер для адреса *//* (исходного или целевого) */ socklen_t msg_namelen; /* Размер буфера для адреса */ struct iovec *msg_iov; /* Массив для разнесения/сборки сообщений */ int msg_iovlen; /* Число элементов в массиве *//* для разнесения/сборки сообщений */ void *msg_control; /* Указатель на буфер *//* для вспомогательных данных */ socklen_t msg_controllen; /* Размер буфера для вспомогательных данных */ int msg_flags; /* Флаги принятого сообщения */
Если для сокета, специфицированного дескриптором sd, соединение не установлено, в заданный указателем msg_name буфер длины msg_namelen помещается исходный адрес сообщения; если этого не нужно, указатель msg_name можно сделать пустым. При установлении соединения оба поля игнорируются.
Массив msg_iov совместно с полем msg_iovlen задает набор буферов для размещения принимаемых данных. Структура типа iovec определяется в заголовочном файле <sys/uio.h> и содержит по крайней мере два поля.
void *iov_base; /* Адрес области памяти (буфера) */ size_t iov_len; /* Размер области памяти (в байтах) */
Заданные полем msg_iov области памяти по очереди заполняются поступающими данными, пока не будут размещены все принятые данные или не заполнятся все буфера.
Трактовка вспомогательных данных (поля msg_control и msg_controllen структуры типа msghdr) в стандарте POSIX-2001 весьма туманна. Описаны лишь средства доступа к ним. Мы, однако, не будем на этом останавливаться.
В случае успешного завершения функции recvmsg() в поле msg_flags могут быть установлены следующие флаги.
MSG_EOR
Достигнута граница записи (если это понятие поддерживается протоколом).
MSG_OOB
Получены экстренные данные.
MSG_TRUNC
Пришлось урезать обычные данные.
MSG_CTRUNC
Пришлось урезать управляющие данные.
Подобно тому, как write() составляет пару read(), функцию sendto() можно считать парной по отношению к recvfrom(). Она предназначена для отправки через сокет sd сообщения, заданного аргументами message и length, по адресу dest_addr длины dest_len. Если для сокета установлено соединение, целевой адрес dest_addr игнорируется.
В число возможных составляющих значения аргумента flags входят следующие флаги.
MSG_EOR
Обозначает границу записи (если это понятие поддерживается протоколом).
MSG_OOB
Отправляются экстренные данные.
Разумеется, успешное завершение функции sendto() не гарантирует доставку сообщения. Результат, равный -1, указывает только на локально выявляемые ошибки.
Функция send() - пара для recv() со всеми следующими из этого обстоятельства эквивалентностями и аналогиями.
Для функции sendmsg() структура типа msghdr, на которую указывает аргумент message, является входной (что показывает спецификатор const). В поле msg_name задается целевой адрес. Поле msg_flags игнорируется.
Для завершения операций приема и/или отправки данных через сокет служит функция shutdown() (см. пример 11.29).
#include <sys/socket.h>int shutdown (int sd, int how);
Листинг 11.29. Описание функции shutdown().
Значение аргумента how показывает, что именно завершается: SHUT_RD прекращает прием, SHUT_WR - отправку, SHUT_RDWR - и то, и другое.
Примеры программ работы с сокетами
Приводимые далее примеры строятся вокруг задачи копирования данных в распределенной программной конфигурации со стандартного ввода одного процесса на стандартный вывод другого, удаленного. Однако начнем мы с локального случая, обслуживаемого сокетами адресного семейства AF_UNIX (см. пример 11.30).
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//* Программа копирует строки со стандартного ввода на стандартный вывод, *//* "прокачивая" их через пару сокетов. *//* Используются функции ввода/вывода нижнего уровня *//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <unistd.h>#include <stdlib.h>#include <stdio.h>#include <sys/socket.h>#include <sys/wait.h> #define MY_PROMPT "Вводите строки\n"#define MY_MSG "Вы ввели: " int main (void) { int sds [2]; char buf [1]; int new_line = 1; /* Признак того, что надо выдать сообщение MY_MSG */ /* перед отображением очередной строки */ /* Создадим пару соединенных безымянных сокетов */ if (socketpair (AF_UNIX, SOCK_STREAM, 0, sds) < 0) { perror ("SOCKETPAIR"); exit (1); } switch (fork ()) { case -1: perror ("FORK"); exit (2); case 0: /* Чтение из сокета sds [0] и выдачу на стандартный вывод */ /* реализуем в порожденном процессе */ while (read (sds [0], buf, 1) == 1) { if (write (STDOUT_FILENO, buf, 1) != 1) { perror ("WRITE TO STDOUT"); break; } } exit (0); } /* Чтение со стандартного ввода и запись в сокет sds [1] */ /* возложим на родительский процесс */ if (write (sds [1], MY_PROMPT, sizeof (MY_PROMPT) - 1) != sizeof (MY_PROMPT) - 1) { perror ("WRITE TO SOCKET-1"); } while (read (STDIN_FILENO, buf, 1) == 1) { /* Перед отображением очередной строки */ /* нужно выдать сообщение MY_MSG */ if (new_line) { if (write (sds [1], MY_MSG, sizeof (MY_MSG) - 1) != sizeof (MY_MSG) - 1) { perror ("WRITE TO SOCKET-2"); break; } } if (write (sds [1], buf, 1) != 1) { perror ("WRITE TO SOCKET-3"); break; } new_line = (buf [0] == '\n'); } shutdown (sds [1], SHUT_WR); (void) wait (NULL); return (0);}
Листинг 11.30. Пример программы, использующей сокеты адресного семейства AF_UNIX.
Обратим внимание на употребление в процессе, осуществляющем запись в сокет, функции shutdown(), без чего читающий процесс не определит конец файла и не выйдет из цикла.
Решим теперь ту же задачу для действительно распределенной конфигурации. Наше приложение будет состоять из двух процессов, выполняющихся на разных хостах. Первый процесс (см. пример 11.31) читает строки со стандартного ввода и отправляет их в виде датаграмм другому, который принимает датаграммы и выдает их содержимое на стандартный вывод (см. пример 11.32).
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//* Программа процесса, читающего строки со стандартного ввода *//* и посылающего их в виде датаграмм другому процессу *//* (будем называть его сервером), *//* который должно выдать их на свой стандартный вывод. *//* Имя серверного хоста - аргумент командной строки *//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <stdio.h>#include <netdb.h>#include <sys/socket.h>#include <string.h> #define MY_PROMPT "Вводите строки\n" int main (int argc, char *argv []) { int sd; /* Дескриптор передающего сокета */ char line [LINE_MAX]; /* Буфер для копируемых строк */ /* Структура - аргумент sendmsg */ struct msghdr msg = {NULL, 0, NULL, 0, NULL, 0, 0}; struct iovec iovbuf; /* Структура для сборки отправляемых данных */ /* Структура - входной аргумент getaddrinfo */ struct addrinfo hints = {0, AF_INET, SOCK_DGRAM, IPPROTO_UDP, 0, NULL, NULL, NULL}; /* Указатель - выходной аргумент getaddrinfo */ struct addrinfo *addr_res; int res; /* Результат getaddrinfo */ int msg_len; /* Длина очередной введенной строки, */ /* включая завершающий нулевой байт */ if (argc != 2) { fprintf (stderr, "Использование: %s имя_серверного_хоста\n", argv [0]); return (1); } /* Создадим сокет, через который будем отправлять */ /* прочитанные строки */ if ((sd = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { perror ("SOCKET"); return (2); } /* Выясним целевой адрес для датаграмм */ /* Воспользуемся портом для сервиса spooler */ if ((res = getaddrinfo (argv [1], "spooler", &hints, &addr_res)) != 0) { fprintf (stderr, "GETADDRINFO: %s\n", gai_strerror (res)); return (3); } /* Заполним структуру msghdr */ msg.msg_name = addr_res->ai_addr; msg.msg_namelen = addr_res->ai_addrlen; msg.msg_iov = &iovbuf; msg.msg_iovlen = 1; iovbuf.iov_base = line; /* Цикл чтения строк со стандартного ввода */ /* и отправки их через сокет в виде датаграмм */ fputs (MY_PROMPT, stdout); while (fgets (line, sizeof (line), stdin) != NULL) { msg_len = strlen (line) + 1; iovbuf.iov_len = msg_len; if (sendmsg (sd, &msg, 0) != msg_len) { perror ("SENDMSG"); break; } } return (0);}
Листинг 11.31. Пример программы, использующей сокеты адресного семейства AF_INET для отправки датаграмм.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * *//* Программа процесса (будем называть его сервером), *//* читающего сообщения (строки) из датаграммного сокета *//* и выдающего их на стандартный вывод *//* * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <stdio.h>#include <netdb.h>#include <sys/socket.h> #define MY_MSG "Вы ввели: " int main (void) { int sd; /* Дескриптор приемного сокета */ char line [LINE_MAX]; /* Буфер для копируемых строк */ /* Структура - аргумент recvmsg */ struct msghdr msg = {NULL, 0, NULL, 0, NULL, 0, 0}; struct iovec iovbuf; /* Структура для разнесения принимаемых данных */ /* Структура - входной аргумент getaddrinfo */ struct addrinfo hints = {AI_PASSIVE, AF_INET, SOCK_DGRAM, IPPROTO_UDP, 0, NULL, NULL, NULL}; /* Указатель - выходной аргумент getaddrinfo */ struct addrinfo *addr_res; int res; /* Результат getaddrinfo */ /* Создадим сокет, через который будем принимать */ /* прочитанные строки */ if ((sd = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { perror ("SOCKET"); return (1); } /* Привяжем этот сокет к адресу сервиса spooler на локальном хосте */ if ((res = getaddrinfo (NULL, "spooler", &hints, &addr_res)) != 0) { fprintf (stderr, "GETADDRINFO: %s\n", gai_strerror (res)); return (2); } if (bind (sd, addr_res->ai_addr, addr_res->ai_addrlen) < 0) { perror ("BIND"); return (3); } /* Можно освободить память, которую запрашивала функция getaddrinfo() */ freeaddrinfo (addr_res); /* Заполним структуру msghdr */ msg.msg_iov = &iovbuf; msg.msg_iovlen = 1; iovbuf.iov_base = line; iovbuf.iov_len = sizeof (line); /* Цикл приема и выдачи строк */ while (1) { if (recvmsg (sd, &msg, 0) < 0) { perror ("RECVMSG"); break; } fputs (MY_MSG, stdout); fputs (line, stdout); } return (0);}
Листинг 11.32. Пример программы, использующей сокеты адресного семейства AF_INET для приема датаграмм.
Обратим внимание на несколько моментов. Адреса сокетов (целевого и приемного) получены при помощи функции getaddrinfo() с сервисом "spooler" в качестве аргумента. (Если на хосте этот сервис реально используется, для данного примера придется подыскать другой, свободный порт.) С практической точки зрения более правильным было бы пополнить базу данных сетевых сервисов новым элементом, специально предназначенным для представленного приложения, однако подобные административные действия находятся вне рамок стандарта POSIX и, следовательно, нами не рассматриваются. (Менее правильно, на наш взгляд, формировать адрес сокета покомпонентно, выбирая порт, по сути, случайным образом, поскольку это ведет к неявному, бессистемному, неконтролируемому пополнению базы сервисов.)
Для успешного вызова функции bind() процесс должен обладать соответствующими привилегиями. Это может оказаться существенным для запуска программы, показанной в пример 11.32.
Чтобы получить от getaddrinfo() адрес, пригодный для использования в качестве аргумента ориентированных на прием функций (listen(), bind() для приемного сокета), необходимо указать флаг AI_PASSIVE во входной для getaddrinfo() структуре addrinfo (аргумент hints в описании функции getaddrinfo()). В таком случае для IP-адреса будет выдано значение INADDR_ANY, которое трактуется в адресном семействе AF_INET как адрес локального хоста, успешно сопоставляющийся как со шлейфовым (127.0.0.1), так и с реальным сетевыми адресами. В результате через этот сокет можно будет принимать датаграммы, посланные и с локального, и с удаленного хостов.
Цикл приема данных сервером сделан бесконечным, поскольку у последовательности датаграмм нет естественного признака конца.
Для передающего сокета не выполнялась привязка к локальному адресу, а в серверном процессе не запрашивался исходный адрес поступающих датаграмм - подход, возможно, слишком экономный, но непротиворечивый. Заметим, однако, что у представленного приложения есть неиспользованный идейный запас, состоящий в том, что сервер способен принимать датаграммы не только из одного, но и из нескольких источников. Чтобы задействовать этот потенциал, внесем в приложения модификации двух видов.
В программе, посылающей датаграммы, выполним привязку сокета к свободному локальному адресу, воспользовавшись для этого функцией connect() и, для оправдания затраченных усилий, изменим способ отправки: вместо универсальной sendmsg() задействуем даже не более простую функцию send(), а ее вполне привычный аналог write(), скрытый под личиной fputs().
Какой режим буферизации выбрать для потока, сформированного по открытому файловому дескриптору сокета, - дело вкуса. Читателю рекомендуется попробовать разные варианты, каждый из которых имеет свои "за" и "против". Второй вид модификаций касается серверного процесса. Поскольку теперь у датаграмм появился исходный адрес, его можно выяснить и выдать, а заодно опросить выходной флаг MSG_TRUNC, чтобы убедиться, что при пересылке в виде датаграмм копируемые строки не были урезаны. Кроме того, изменение способа формирования отправляемых датаграмм привело к тому, что теперь их содержимое не завершается нулевым байтом; следовательно, способ вывода принимаемых данных также нуждается в модификации (в нашем случае - в дописывании нулевого байта).
Модифицированные варианты программ представлены в листингах пример 11.33 и пример 11.34.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//* Программа процесса, читающего строки со стандартного ввода *//* и посылающего их в виде датаграмм другому процессу *//* (будем называть его сервером), *//* который должно выдать их на свой стандартный вывод. *//* Имя серверного хоста - аргумент командной строки *//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <stdio.h>#include <netdb.h>#include <sys/socket.h> #define MY_PROMPT "Вводите строки\n" int main (int argc, char *argv []) { int sd; /* Дескриптор передающего сокета */ FILE *ss; /* Поток, соответствующий передающему сокету */ char line [LINE_MAX]; /* Буфер для копируемых строк */ /* Структура - входной аргумент getaddrinfo */ struct addrinfo hints = {0, AF_INET, SOCK_DGRAM, IPPROTO_UDP, 0, NULL, NULL, NULL}; /* Указатель - выходной аргумент getaddrinfo */ struct addrinfo *addr_res; int res; /* Результат getaddrinfo */ if (argc != 2) { fprintf (stderr, "Использование: %s имя_серверного_хоста\n", argv [0]); return (1); } /* Создадим сокет, через который будем отправлять */ /* прочитанные строки */ if ((sd = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { perror ("SOCKET"); return (2); } /* Выясним целевой адрес для датаграмм */ /* Воспользуемся портом для сервиса spooler */ if ((res = getaddrinfo (argv [1], "spooler", &hints, &addr_res)) != 0) { fprintf (stderr, "GETADDRINFO: %s\n", gai_strerror (res)); return (3); } /* Воспользуемся функцией connect() для достижения двух целей: */ /* фиксации целевого адреса и привязки к некоему локальному */ if (connect (sd, addr_res->ai_addr, addr_res->ai_addrlen) < 0) { perror ("CONNECT"); return (4); } /* Сформирует поток по дескриптору сокета */ if ((ss = fdopen (sd, "w")) == NULL) { perror ("FDOPEN"); return (5); } /* Отменим буферизацию для этого потока */ setbuf (ss, NULL); /* Цикл чтения строк со стандартного ввода */ /* и отправки их через сокет в виде датаграмм */ fputs (MY_PROMPT, stdout); while (fgets (line, sizeof (line), stdin) != NULL) { fputs (line, ss); } return (0);}
Листинг 11.33. Модифицированный вариант программы, использующей сокеты адресного семейства AF_INET для отправки датаграмм.
/* * * * * * * * * * * * * * * * * * * * * * * * * * *//* Программа процесса (будем называть его сервером), *//* читающего сообщения из датаграммного сокета *//* и копирующего их на стандартный вывод *//* с указанием адреса, откуда они поступили *//* * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <stdio.h>#include <netdb.h>#include <sys/socket.h>#include <arpa/inet.h> int main (void) { int sd; /* Дескриптор приемного сокета */ /* Буфер для принимаемых сообщений */ /* Оставлено место для вставки нулевого байта */ char lbuf [BUFSIZ + 1]; /* Структура - аргумент recvmsg */ struct msghdr msg = {NULL, 0, NULL, 0, NULL, 0, 0}; struct iovec iovbuf; /* Структура для разнесения принимаемых данных */ /* Структура - входной аргумент getaddrinfo */ struct addrinfo hints = {AI_PASSIVE, AF_INET, SOCK_DGRAM, IPPROTO_UDP, 0, NULL, NULL, NULL}; /* Указатель - выходной аргумент getaddrinfo */ struct addrinfo *addr_res; int res; /* Результат getaddrinfo */ /* Структура для исходного адреса датаграмм */ struct sockaddr_in sai; ssize_t lmsg; /* Длина принятой датаграммы */ /* Создадим сокет, через который будем принимать */ /* прочитанные строки */ if ((sd = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { perror ("SOCKET"); return (1); } /* Привяжем этот сокет к адресу сервиса spooler на локальном хосте */ if ((res = getaddrinfo (NULL, "spooler", &hints, &addr_res)) != 0) { fprintf (stderr, "GETADDRINFO: %s\n", gai_strerror (res)); return (1); } if (bind (sd, addr_res->ai_addr, addr_res->ai_addrlen) < 0) { perror ("BIND"); return (2); } /* Можно освободить память, которую запрашивала функция getaddrinfo() */ freeaddrinfo (addr_res); /* Заполним структуру msghdr */ msg.msg_name = &sai; msg.msg_namelen = sizeof (struct sockaddr_in); msg.msg_iov = &iovbuf; msg.msg_iovlen = 1; iovbuf.iov_base = lbuf; /* Оставим место для вставки нулевого байта */ iovbuf.iov_len = sizeof (lbuf) - 1; /* Цикл приема и выдачи строк */ while (1) { if ((lmsg = recvmsg (sd, &msg, 0)) < 0) { perror ("RECVMSG"); break; } printf ("Вы ввели и отправили с адреса %s, порт %d :", inet_ntoa (((struct sockaddr_in *) msg.msg_name)->sin_addr), ntohs (((struct sockaddr_in *) msg.msg_name)->sin_port)); if (msg.msg_flags & MSG_TRUNC) { printf ("Датаграмма была урезана\n"); } lbuf [lmsg] = 0; fputs (lbuf, stdout); } return (0);}
Листинг 11.34. Модифицированный вариант программы, использующей сокеты адресного семейства AF_INET для приема датаграмм.
Читателю предлагается оценить степень надежности (точнее, ненадежности) доставки датаграмм, перенеправив стандартный ввод читающего строки процесса, в какой-либо большой текстовый файл. Кроме того, любопытно параллельно запустить несколько таких процессов и проследить за очередностью датаграмм, поступающих серверу.
Сделаем теперь более существенные изменения, прежде всего на серверной стороне. Перейдем на использование надежного режима с установлением соединения (и, соответственно, сокетов типа SOCK_STREAM). Сервер будет получать запросы на установление соединения через порт сервиса "spooler" и порождать для каждого принятого запроса свой обслуживающий процесс.
Новый вариант программы процесса, читающего строки со стандартного ввода и отправляющего их через потоковый сокет, показан в пример 11.35; две программы серверной части - в листингах пример 11.35 и пример 11.37. Предполагается, что выполнимый файл с образом обслуживающего процесса находится в текущем каталоге и имеет имя gsce.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//* Программа процесса, читающего строки со стандартного ввода *//* и посылающего их в виде потока другому процессу *//* (будем называть его сервером), *//* который должно выдать строки на свой стандартный вывод. *//* Имя серверного хоста - аргумент командной строки *//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <stdio.h>#include <netdb.h> #include <sys/socket.h> #define MY_PROMPT "Вводите строки\n" int main (int argc, char *argv []) { int sd; /* Дескриптор передающего сокета */ FILE *ss; /* Поток, соответствующий передающему сокету */ char line [LINE_MAX]; /* Буфер для копируемых строк */ /* Структура - входной аргумент getaddrinfo */ struct addrinfo hints = {0, AF_INET, SOCK_STREAM, IPPROTO_TCP, 0, NULL, NULL, NULL}; /* Указатель - выходной аргумент getaddrinfo */ struct addrinfo *addr_res; int res; /* Результат getaddrinfo */ if (argc != 2) { fprintf (stderr, "Использование: %s имя_серверного_хоста\n", argv [0]); return (1); } /* Создадим сокет, через который будем отправлять */ /* прочитанные строки */ if ((sd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { perror ("SOCKET"); return (2); } /* Выясним целевой адрес для соединения */ /* Воспользуемся портом для сервиса spooler */ if ((res = getaddrinfo (argv [1], "spooler", &hints, &addr_res)) != 0) { fprintf (stderr, "GETADDRINFO: %s\n", gai_strerror (res)); return (3); } /* Воспользуемся функцией connect() для достижения двух целей: */ /* установления соединения и привязки к некоему локальному адресу */ if (connect (sd, addr_res->ai_addr, addr_res->ai_addrlen) < 0) { perror ("CONNECT"); return (4); } /* Сформируем поток по дескриптору сокета */ if ((ss = fdopen (sd, "w")) == NULL) { perror ("FDOPEN"); return (5); } /* Отменим буферизацию для этого потока */ setbuf (ss, NULL); /* Цикл чтения строк со стандартного ввода */ /* и отправки их через сокет в виде потока */ fputs (MY_PROMPT, stdout); while (fgets (line, sizeof (line), stdin) != NULL) { fputs (line, ss); } shutdown (sd, SHUT_WR); return (0);}
Листинг 11.35. Пример программы, использующей режим с установлением соединения и сокеты типа SOCK_STREAM для пересылки строк.
/* * * * * * * * * * * * * * * * * * * * * * * * * * *//* Программа процесса (будем называть его демоном), *//* принимающего запросы на установления соединения *//* и запускающего процессы для их обслуживания *//* * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <unistd.h>#include <stdio.h>#include <fcntl.h>#include <netdb.h>#include <sys/socket.h>#include <sys/wait.h> int main (void) { int sd; /* Дескриптор слушающего сокета */ int ad; /* Дескриптор приемного сокета */ /* Буфер для принимаемых строк */ struct addrinfo hints = {AI_PASSIVE, AF_INET, SOCK_STREAM, IPPROTO_TCP, 0, NULL, NULL, NULL}; /* Указатель - выходной аргумент getaddrinfo */ struct addrinfo *addr_res; int res; /* Результат getaddrinfo */ /* Создадим слушающий сокет */ if ((sd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { perror ("SOCKET"); return (1); } /* Привяжем этот сокет к адресу сервиса spooler на локальном хосте */ if ((res = getaddrinfo (NULL, "spooler", &hints, &addr_res)) != 0) { fprintf (stderr, "GETADDRINFO: %s\n", gai_strerror (res)); return (1); } if (bind (sd, addr_res->ai_addr, addr_res->ai_addrlen) < 0) { perror ("BIND"); return (2); } /* Можно освободить память, которую запрашивала функция getaddrinfo() */ freeaddrinfo (addr_res); /* Пометим сокет как слушающий */ if (listen (sd, SOMAXCONN) < 0) { perror ("LISTEN"); return (3); } /* Цикл приема соединений и запуска обслуживающих процессов */ while (1) { /* Примем соединение. */ /* Адрес партнера по общению нас в данном случае не интересует */ if ((ad = accept (sd, NULL, NULL)) < 0) { perror ("ACCEPT"); return (4); } /* Запустим обслуживающий процесс */ switch (fork ()) { case -1: perror ("FORK"); return (5); case 0: /* Сделаем сокет ad стандартным вводом */ (void) close (STDIN_FILENO); (void) fcntl (ad, F_DUPFD, STDIN_FILENO); (void) close (ad); /* Сменим программу процесса на обслуживающую */ if (execl ("./gsce", "gsce", (char *) NULL) < 0) { perror ("EXECL"); return (6); } } /* В родительском процессе дескриптор принятого соединения нужно закрыть */ (void) close (ad); /* Обслужим завершившиеся порожденные процессы */ while (waitpid ((pid_t) (-1), NULL, WNOHANG) > 0) ; } return (0);}
Листинг 11.36. Пример программы, принимающей запросы на установление соединения.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * *//* Программа обслуживающего процесса, *//* выдающего принимаемые строки на стандартный вывод. *//* Дескриптор приемного сокета передан *//* в качестве стандартного ввода *//* * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <unistd.h>#include <stdio.h>#include <sys/socket.h>#include <arpa/inet.h> int main (void) { char line [LINE_MAX]; /* Буфер для принимаемых строк */ /* Структура для записи адреса */ struct sockaddr_in sai; /* Длина адреса */ socklen_t sai_len = sizeof (struct sockaddr_in); /* Опросим адрес партнера по общению (передающего сокета) */ if (getpeername (STDIN_FILENO, (struct sockaddr *) &sai, &sai_len) < 0) { perror ("GETPEERNAME"); return (1); } /* Цикл чтения строк из сокета */ /* и выдачи их на стандартный вывод */ while (fgets (line, sizeof (line), stdin) != NULL) { printf ("Вы ввели и отправили с адреса %s, порт %d :", inet_ntoa (sai.sin_addr), ntohs (sai.sin_port)); fputs (line, stdout); } /* Закрытие соединения */ shutdown (STDIN_FILENO, SHUT_RD); return (0);}
Листинг 11.37. Пример программы, обрабатывающей данные, поступающие через сокет типа SOCK_STREAM.
Обратим внимание на два технических момента. Во-первых, дескриптор приемного сокета передается в обслуживающий процесс под видом стандартного ввода. В результате обслуживающая программа по сути свелась к циклу копирования строк со стандартного ввода на стандартный вывод. Мы вернулись к тому, с чего начинали рассмотрение средств буферизованного ввода/вывода, но на новом витке спирали. Во-вторых, в иллюстративных целях для обслуживания завершившихся порожденных процессов использована функция waitpid() со значением аргумента pid, равным -1 (выражающим готовность обслужить любой завершившийся процесс-потомок), и флагом WNOHANG, означающим отсутствие ожидания. В данном случае подобный прием не гарантирует отсутствия зомби-процессов, но препятствует их накоплению.
Чтобы проиллюстрировать еще один типичный прием, связанный с обработкой запросов на установление соединения, изменим способ обслуживания завершившихся порожденных процессов. Определим функцию обработки сигнала SIGCHLD и поместим в нее вызов waitpid(). Модифицированный вариант программы процесса-демона, аккуратно ликвидирующий все зомби-процессы, показан в пример 11.38.
/* * * * * * * * * * * * * * * * * * * * * * * * * * *//* Программа процесса (будем называть его демоном), *//* принимающего запросы на установления соединения *//* и запускающего процессы для их обслуживания *//* * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <unistd.h>#include <stdio.h>#include <fcntl.h>#include <netdb.h>#include <sys/socket.h>#include <sys/wait.h>#include <signal.h>#include <errno.h> /* Функция обработки сигнала SIGCHLD */static void chldied (int dummy) { /* Вдруг число завершившихся потомков отлично от единицы? */ while (waitpid ((pid_t) (-1), NULL, WNOHANG) > 0) ;} int main (void) { int sd; /* Дескриптор слушающего сокета */ int ad; /* Дескриптор приемного сокета */ /* Структура - входной аргумент getaddrinfo */ struct addrinfo hints = {AI_PASSIVE, AF_INET, SOCK_STREAM, IPPROTO_TCP, 0, NULL, NULL, NULL}; /* Указатель - выходной аргумент getaddrinfo */ struct addrinfo *addr_res; int res; /* Результат getaddrinfo */ /* Структура для задания реакции на сигнал SIGCHLD */ struct sigaction sact; /* Создадим слушающий сокет */ if ((sd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { perror ("SOCKET"); return (1); } /* Привяжем этот сокет к адресу сервиса spooler на локальном хосте */ if ((res = getaddrinfo (NULL, "spooler", &hints, &addr_res)) != 0) { fprintf (stderr, "GETADDRINFO: %s\n", gai_strerror (res)); return (1); } if (bind (sd, addr_res->ai_addr, addr_res->ai_addrlen) < 0) { perror ("BIND"); return (2); } /* Можно освободить память, которую запрашивала функция getaddrinfo() */ freeaddrinfo (addr_res); /* Пометим сокет как слушающий */ if (listen (sd, SOMAXCONN) < 0) { perror ("LISTEN"); return (3); } /* Установим обработку сигнала о завершении потомка */ sact.sa_handler = chldied; (void) sigemptyset (&sact.sa_mask); sact.sa_flags = 0; (void) sigaction (SIGCHLD, &sact, (struct sigaction *) NULL); /* Цикл приема соединений и запуска обслуживающих процессов */ while (1) { /* Примем соединение с учетом того, что ожидание может быть прервано */ /* доставкой обрабатываемого сигнала. */ /* Адрес партнера по общению в данном случае нас не интересует */ while ((ad = accept (sd, NULL, NULL)) < 0) { if (errno != EINTR) { perror ("ACCEPT"); return (4); } } /* Запустим обслуживающий процесс */ switch (fork ()) { case -1: perror ("FORK"); return (5); case 0: /* Сделаем сокет ad стандартным вводом */ (void) close (STDIN_FILENO); (void) fcntl (ad, F_DUPFD, STDIN_FILENO); (void) close (ad); /* Сменим программу процесса на обслуживающую */ if (execl ("./gsce", "gsce", (char *) NULL) < 0) { perror ("EXECL"); return (6); } } /* В родительском процессе дескриптор принятого соединения нужно закрыть */ (void) close (ad); } return (0);}
Листинг 11.38. Пример программы, принимающей запросы на установление соединения с учетом того, что ожидание может быть прервано доставкой обрабатываемого сигнала.
Задание функции обработки сигнала о завершении потомка имеет нелокальный эффект. Оно повлияло на поведение функции accept(): ее вызов может быть прерван доставкой сигнала SIGCHLD. В такой ситуации прежний вариант процесса-демона завершился бы, выдав в стандартный протокол диагностическое сообщение вида "ACCEPT: Interrupted system call". Чтобы этого не случилось, вызов accept() пришлось заключить в цикл с проверкой (в случае неудачного завершения) значения переменной errno на совпадение с EINTR. Вообще говоря, по подобной схеме рекомендуется действовать для всех функций, выполнение которых может быть прервано доставкой сигнала, но допускающих и повторный вызов. Отметим в этой связи, что, например, функция connect() очень похожа, но все-таки отличается своими особенностями. После доставки сигнала ее вызов завершается неудачей, а установление соединения продолжается асинхронно, поэтому повторное обращение может завершиться неудачей со значением errno, равным EALREADY.
Рассмотрим теперь еще один вариант сервера, имеющего однопроцессную организацию, но мультиплексирующего ввод с помощью функции select() (см. пример 11.39).
/* * * * * * * * * * * * * * * * * * * * * * * * * * *//* Программа процесса (будем называть его сервером), *//* принимающего запросы на установления соединения *//* и обслуживающего их с использованием select() *//* * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <unistd.h>#include <stdio.h>#include <netdb.h>#include <sys/socket.h>#include <arpa/inet.h>#include <sys/select.h> /* Структура для хранения дескрипторов приемных сокетов *//* и ассоциированной информации */#define MY_MSG_LN 128struct sads { int ad; FILE *sd; char my_msg [MY_MSG_LN];}; /* Максимальное число параллельно обслуживаемых запросов */#define MY_MAX_QS FD_SETSIZE /* Функция для освобождения элемента массива *//* дескрипторов приемных сокетов */static void free_elem (struct sads *sadsp) { shutdown (sadsp->ad, SHUT_RD); close (sadsp->ad); sadsp->ad = -1;} int main (void) { int sd; /* Дескриптор слушающего сокета */ /* Структура - входной аргумент getaddrinfo */ struct addrinfo hints = {AI_PASSIVE, AF_INET, SOCK_STREAM, IPPROTO_TCP, 0, NULL, NULL, NULL}; /* Указатель - выходной аргумент getaddrinfo */ struct addrinfo *addr_res; int res; /* Результат getaddrinfo */ fd_set rdset; /* Набор дескрипторов для чтения */ /* Структура для записи адреса */ struct sockaddr_in sai; socklen_t sai_len; /* Длина адреса */ char line [LINE_MAX]; /* Буфер для принимаемых строк */ /* Массов для хранения дескрипторов приемных сокетов */ /* и ассоциированной информации. */ /* Последний элемент - фиктивный, */ /* нужен для упрощения поиска свободного */ struct sads sadsarr [MY_MAX_QS + 1]; int sads_max; /* Верхняя граница дескрипторов, проверяемых select() */ int i; /* Создадим слушающий сокет */ if ((sd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { perror ("SOCKET"); return (1); } /* Привяжем этот сокет к адресу сервиса spooler на локальном хосте */ if ((res = getaddrinfo (NULL, "spooler", &hints, &addr_res)) != 0) { fprintf (stderr, "GETADDRINFO: %s\n", gai_strerror (res)); return (1); } if (bind (sd, addr_res->ai_addr, addr_res->ai_addrlen) < 0) { perror ("BIND"); return (2); } /* Можно освободить память, которую запрашивала функция getaddrinfo() */ freeaddrinfo (addr_res); /* Пометим сокет как слушающий */ if (listen (sd, SOMAXCONN) < 0) { perror ("LISTEN"); return (3); } /* Инициализируем массив sadsarr. */ /* -1 в поле ad означает, что элемент свободен */ for (i = 0; i < (MY_MAX_QS + 1); i++) { sadsarr [i].ad = -1; } /* Цикл приема соединений и обслуживания запросов */ while (1) { /* Подготовим наборы дескрипторов для select() */ FD_ZERO (&rdset); FD_SET (sd, &rdset); sads_max = sd + 1; for (i = 0; i < MY_MAX_QS; i++) { if (sadsarr [i].ad >= 0) { FD_SET (sadsarr [i].ad, &rdset); if ((sadsarr [i].ad + 1) > sads_max) { sads_max = sadsarr [i].ad + 1; } } } /* Подождем запроса на установление соединения */ /* или готовности данных для чтения. */ /* Время ожидания зададим как бесконечное */ if (select (sads_max, &rdset, NULL, NULL, NULL) == -1) { perror ("PSELECT"); return (4); } /* Посмотрим, есть ли запросы, ждущие установления соединения */ if (FD_ISSET (sd, &rdset)) { /* Примем запрос на установление соединения, */ /* если есть свободный элемент массива дескрипторов. */ /* Последний элемент считаем фиктивным; он всегда свободен */ i = -1; while (sadsarr [++i].ad >= 0) ; if (i < MY_MAX_QS) { /* Свободный элемент нашелся */ sai_len = sizeof (struct sockaddr_in); if ((sadsarr [i].ad = accept (sd, (struct sockaddr *) &sai, &sai_len)) == -1) { perror ("ACCEPT"); continue; } /* Сформируем сообщение, выдаваемое перед принятой строкой */ (void) sprintf (sadsarr [i].my_msg, "Вы ввели и отправили с адреса %s, порт %d :", inet_ntoa (sai.sin_addr), ntohs (sai.sin_port)); /* Сформируем поток по дескриптору сокета */ /* и отменим буферизацию для этого потока */ if ((sadsarr [i].sd = fdopen (sadsarr [i].ad, "r")) == NULL) { perror ("FDOPEN"); free_elem (&sadsarr [i]); continue; } setbuf (sadsarr [i].sd, NULL); } } /* Посмотрим, есть ли данные, готовые для чтения */ for (i = 0; i < MY_MAX_QS; i++) { if ((sadsarr [i].ad >= 0) & FD_ISSET (sadsarr [i].ad, &rdset)) { /* Есть данные, готовые для чтения, */ /* или установлен признак конца файла */ if (fgets (line, sizeof (line), sadsarr [i].sd) != NULL) { /* Выведем полученную строку */ fputs (sadsarr [i].my_msg, stdout); fputs (line, stdout); } else { /* Отправитель закрыл соединение. */ /* Закроем его и мы */ fclose (sadsarr [i].sd); free_elem (&sadsarr [i]); } } } } return (0);}
Листинг 11.39. Пример программы, мультиплексирующей ввод через сокеты с помощью функции select().
Обратим внимание на то, что функция select() позволяет мультиплексировать как поступление данных, так и прием запросов на установление соединения, а также на то, что конец поступления данных в результате закрытия соединения передающей стороной выявляется естественным образом: select() сообщает о наличии данных для чтения, а сама операция чтения возвращает признак конца файла.
В качестве следующего примера рассмотрим передачу целочисленных данных. Главная проблема здесь - аккуратное выполнение преобразований между хостовым и сетевым порядками байт. Для иллюстрации использовано вычисление и вывод строк треугольника Паскаля. Вычисляющая и передающая программа показана в пример 11.40, принимающая и выводящая - в пример 11.41.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//* Программа вычисляет несколько первых строк треугольника Паскаля *//* и отправляет их через сокет сервису spooler. *//* Имя целевого хоста - аргумент командной строки. *//* Передаваемые данные снабжаются однобайтными маркерами типа *//* и кратности и преобразуются к сетевому порядку байт *//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <unistd.h>#include <stdio.h>#include <netdb.h>#include <sys/socket.h> /* Количество вычисляемых строк треугольника Паскаля */#define T_SIZE 16 /* Маркеры типов передаваемых данных */#define T_UCHAR 1#define T_UINT16 2#define T_UINT32 4 #define T_HDR "\nТреугольник Паскаля:" int main (int argc, char *argv []) { uint32_t tp [T_SIZE]; /* Массив для хранения текущей строки треугольника */ unsigned char mtl; /* Переменная для хранения маркеров типа и кратности */ uint32_t ntelem; /* Текущий элемент строки в сетевом порядке байт */ int sd; /* Дескриптор передающего сокета */ /* Структура - входной аргумент getaddrinfo */ struct addrinfo hints = {0, AF_INET, SOCK_STREAM, IPPROTO_TCP, 0, NULL, NULL, NULL}; /* Указатель - выходной аргумент getaddrinfo */ struct addrinfo *addr_res; int res; /* Результат getaddrinfo */ int i, j; if (argc != 2) { fprintf (stderr, "Использование: %s имя_серверного_хоста\n", argv [0]); return (1); } /* Создадим передающий сокет и установим соединение */ if ((sd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { perror ("SOCKET"); return (2); } if ((res = getaddrinfo (argv [1], "spooler", &hints, &addr_res)) != 0) { fprintf (stderr, "GETADDRINFO: %s\n", gai_strerror (res)); return (3); } if (connect (sd, addr_res->ai_addr, addr_res->ai_addrlen) < 0) { perror ("CONNECT"); return (4); } /* Инициализируем массив для хранения текущей строки треугольника Паскаля, */ /* чтобы далее все элементы можно было считать и передавать единообразно */ tp [0] = 1; for (i = 1; i < T_SIZE; i++) { tp [i] = 0; } /* Передадим заголовок */ mtl = T_UCHAR; if (write (sd, &mtl, 1) != 1) { perror ("WRITE-1"); return (5); } mtl = sizeof (T_HDR) - 1; if (write (sd, &mtl, 1) != 1) { perror ("WRITE-2"); return (6); } if (write (sd, T_HDR, mtl) != mtl) { perror ("WRITE-3"); return (7); } /* Вычислим и передадим строки треугольника Паскаля */ for (i = 0; i < T_SIZE; i++) { /* Элементы очередной строки нужно считать от конца к началу */ /* Элемент tp [0] пересчитывать не нужно */ for (j = i; j > 0; j--) { tp [j] += tp [j - 1]; } /* Вывод строки треугольника в сокет */ mtl = T_UINT32; if (write (sd, &mtl, 1) != 1) { perror ("WRITE-4"); return (8); } mtl = i + 1; if (write (sd, &mtl, 1) != 1) { perror ("WRITE-5"); return (9); } /* Преобразование элементов строки к сетевому порядку байт и вывод */ for (j = 0; j <= i; j++) { ntelem = htonl (tp [j]); if (write (sd, &ntelem, sizeof (ntelem)) != sizeof (ntelem)) { perror ("WRITE-6"); return (10); } } } shutdown (sd, SHUT_WR); return (close (sd));}
Листинг 11.40. Пример программы, передающей через сокеты целочисленные данные.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//* Программа процесса (будем называть его наивным сервером), *//* принимающего запросы на установления соединения *//* и осуществляющего вывод поступающих числовых данных *//* без порождения процессов и мультиплексирования *//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <unistd.h>#include <stdio.h>#include <netdb.h>#include <sys/socket.h>#include <arpa/inet.h> /* Маркеры типов передаваемых данных */#define T_UCHAR 1#define T_UINT16 2#define T_UINT32 4 int main (void) { int sd; /* Дескриптор слушающего сокета */ int ad; /* Дескриптор приемного сокета */ /* Структура - входной аргумент getaddrinfo */ struct addrinfo hints = {AI_PASSIVE, AF_INET, SOCK_STREAM, IPPROTO_TCP, 0, NULL, NULL, NULL}; /* Указатель - выходной аргумент getaddrinfo */ struct addrinfo *addr_res; int res; /* Результат getaddrinfo */ /* Структура для записи адреса */ struct sockaddr_in sai; socklen_t sai_len; /* Длина адреса */ char mt; /* Маркер типа поступающих данных */ char ml; /* Маркер кратности поступающих данных */ char bufc; /* Буфер для приема символьных данных */ uint16_t buf16; /* Буфер для приема 16-разрядных целых */ uint32_t buf32; /* Буфер для приема 16-разрядных целых */ /* Создадим слушающий сокет */ if ((sd = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) { perror ("SOCKET"); return (1); } /* Привяжем этот сокет к адресу сервиса spooler на локальном хосте */ if ((res = getaddrinfo (NULL, "spooler", &hints, &addr_res)) != 0) { fprintf (stderr, "GETADDRINFO: %s\n", gai_strerror (res)); return (1); } if (bind (sd, addr_res->ai_addr, addr_res->ai_addrlen) < 0) { perror ("BIND"); return (2); } /* Можно освободить память, которую запрашивала функция getaddrinfo() */ freeaddrinfo (addr_res); /* Пометим сокет как слушающий */ if (listen (sd, SOMAXCONN) < 0) { perror ("LISTEN"); return (3); } /* Цикл приема соединений и обслуживания запросов на вывод */ while (1) { /* Примем соединение */ sai_len = sizeof (struct sockaddr_in); if ((ad = accept (sd, (struct sockaddr *) &sai, &sai_len)) < 0) { perror ("ACCEPT"); continue; } /* Цикл приема поступающих данных и их вывода */ printf ("Получено с адреса %s, порт %d :", inet_ntoa (sai.sin_addr), ntohs (sai.sin_port)); while (read (ad, &mt, 1) == 1) { /* Есть очередная порция данных, начинающаяся с типа. */ /* Прочитаем кратность, потом сами данные */ if (read (ad, &ml, 1) != 1) { perror ("READ-1"); return (4); } while (ml-- > 0) { switch (mt) { case T_UCHAR: if (read (ad, &bufc, sizeof (bufc)) != sizeof (bufc)) { perror ("READ-2"); return (5); } printf ("%c", bufc); continue; case T_UINT16: if (read (ad, &buf16, sizeof (buf16)) != sizeof (buf16)) { perror ("READ-3"); return (6); } printf (" %d", ntohs (buf16)); continue; case T_UINT32: if (read (ad, &buf32, sizeof (buf32)) != sizeof (buf32)) { perror ("READ-4"); return (7); } printf (" %d", ntohl (buf32)); continue; } } /* Вывод порции завершим переводом строки */ printf ("\n"); } /* Конец обслуживания соединения */ (void) close (ad); } return (0);}
Листинг 11.41. Пример программы, принимающей через сокеты целочисленные данные.
