27.3.1. Что такое сокет?
Сокет — это двунаправленный канал между двумя компьютерами в сети, который обеспечивает конечную точку соединения. «Двунаправленный» означает, что данный могут передаваться в двух направлениях — от клиента к серверу и наоборот. Понятие сокета — абстрактное, это как бы программный соединитель, через который обмениваются данными программа-сервер и программа-клиент.
Сокет-интерфейс используется для получения доступа к транспортному уровню протокола TCP/IP и представляет собой набор системных вызовов операционной системы и библиотечных функций на языке С. Все эти функции можно условно разделить на три группы:
♦ управляющие функции;
♦ функции установления связи;
♦ функции сетевого ввода/вывода.
Общий алгоритм работы сетевой программы, использующей сокеты:
1. Подготовить (создать) сокет — функция socket().
2. Связать сокет — функция bind().
3. Установить связь с удаленным компьютером (клиенту — установить связь, а серверу — ожидать установления связи).
4. Произвести обмен данными — функции recv() и send().
5. Завершить сеанс связи — close() и shutdown().
Библиотечные функции для работы с сокетами находятся в заголовочном файле sys/socket.h, поэтому для любой сетевой программы обязательна следующая директива:
#include
27.3.2. Создание и связывание сокета
Основная задача управляющих функций — организовать взаимодействие двух компьютеров, точнее процессов, а также завершить сеанс связи этих процессов. К управляющим функциям относятся функции:
♦socket() — создание сокета;
♦bind() — связывание сокета;
♦close() и shutdown() — завершение сеанса связи.
Начнем по порядку, а именно, с функции socket(). Ее прототип следующий:
#include
#include
extern int socket(int __domain, int __type,
int __protocol) __THROW;
Первый аргумент определяет набор протоколов. Особо вдаваться в подробности не будем — просто всегда в качестве параметра domain передавайте значение AF_INET, что означает использование стека протоколов TCP/IP.
Аргумент type позволяет установить режим работы: с установлением соединения и без такового — значения SOCK_STREAM и SOCK_DGRAM соответственно. Для непосредственного доступа к протоколам IPv4 используется параметр SOCK_RAW. Для его использования нужно подключить заголовочный файл:
#include
Третий параметр лучше всего установить равным 0. В этом случае будет выбран протокол по умолчанию в зависимости от режима работы:
TCP, если мы выбрали режим SOCK_STREAM;
UDP, если мы выбрали SOCK_DGRAM.
Если вы установили значение SOCK_RAW, вы можете указывать в качестве последнего параметра непосредственно значения из файла
/etc/protocols
. Фрагмент этого файла приведен ниже.Листинг 27.2. Фрагмент файла /etc/protocols
ip 0 IP # Протокол Интернета
icmp 1 ICMP # Протокол ICMP
igmp 2 IGMP # Протокол IGMP
# (Internet Group Management Protocol)
ggp 3 GGP # Протокол GGP (gateway-gateway )
tcp 6 TCP # Протокол TCP
udp 17 UDP # Протокол UDP
Если сокет создан успешно, функция возвращает дескриптор сокета — целое положительное число. В случае ошибки функция возвращает значение -1 (отрицательное число). Вот небольшой пример:
int sock;
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock==-1) {
printf("Ошибка при создании сокета\n");
exit(1);
}
Чтобы связать созданный нами сокет с локальным портом, например, 1234, нужно использовать системный вызов bind():
#include
#include
#include
extern int bind(int fd, struct sockaddr *addr,
socklen_t len) __THROW;
Первый аргумент функции задает дескриптор нашего сокета. Второй — это указатель на структуру типа sockaddr. Все структуры данного типа определены в файле
socket.h
:# define __SОСKADDR_ALLTYPES \
__SOCKADDR_ONETYPE (sockaddr) \
__SOCKADDR_ONETYPE (sockaddr_at) \
__SОСKADDR_ONETYPE (sockaddr_ax25) \
__SOCKADDR_ONETYPE (sockaddr_dl) \
__SOCKADDR_ONETYPE (sockaddr_eon) \
__SОСKADDR_ONETYPE (sockaddr_in) \
__SOCKADDR_ONETYPE (sockaddr_in6) \
__SОСKADDR_ONETYPE (sockaddr_inarp) \
__SOCKADDR_ONETYРЕ (sockaddr_ipx) \
__SОСKADDR_ONETYPE (sockaddr_iso) \
__SОСKADDR_ONETYPE (sockaddr_ns) \
__SOCKADDR_ONETYPE (sockaddr_un) \
__SOCKADDR_ONETYPE (sockaddr_x25)
Мы программируем для сети TCP/IP, поэтому будем использовать структуру sockaddr_in (для IPv4) или sockaddr_in6 (для IPv6).
Последний аргумент — это длина выбранной нами структуры (sockaddr_in) в байтах.
Структура sockaddr_in определена в файле
in.h
так:struct sockaddr_in {
__SОСKADDR_COMMON(sin_);
in_port_t sin_port; /* Номер порта */
struct in_addr sin_addr; /* IP-адрес */
unsigned char sin_zero[sizeof (struct sockaddr) -
__SОСKADDR_COMMON_SIZE -
sizeof(in_port_t) - sizeof (struct in_addr)];
};
/* для IPv6. */
struct sockaddr_in6 {
__SОСKADDR_COMMON(sin6_);
in_port_t sin6_port; /* Порт транспортного уровня */
uint32_t sin6_flowinfo; /* Информация потока IPv6 */
struct in6_addr sin6_addr; /* адрес IPv6 */
uint32_t sin6_scope_id; /* IPv6-идентификатор */
};
Поля структуры sockaddr_in означают следующее:
♦sin_ — набор используемых протоколов. Так как мы используем TCP/IP, данное поле должно содержать значение AF_INET;
♦sin_port — номер порта;
♦sin_addr — структура, определяющая адрес узла;
♦sin_zero — обычно не используется.
Структура struct in_addr, определяющая адрес узла, также описана в файле
in.h
:struct in_addr {
in_addr_t s_addr;
};
Обычно поле s_addr должно принимать значение INADDR_ANY — сейчас поясню почему. Структура sockaddr_in должна быть заполнена ДО вызова функции bind(). Если поле sin_addr.s_addr принимает значение INADDR_ANY, то функция bind() автоматически привяжет к сокету адрес локального компьютера и нам не нужно будет указывать его явно — так наша программа будет универсальной.
Функция bind() возвращает 0 в случае успеха, и -1, если произошла ошибка. Вот небольшой пример использования этой функции:
struct sockaddr_in client;
...
client.sin_family = AF_INET;
client.sin_addr.s_addr = INADDR_ANY;
client.sin_port = 1235;
bind(sock, (struct sockaddr *)&client, sizeof(client));
27.3.3. Установление связи с удаленным компьютером
Устанавливать связь можно как на стороне сервера, так и на стороне клиента. На стороне клиента используется только один вызов — connect(), который «спрашивает» у сервера: «Могу ли я подключиться?», то есть передает запрос на установление соединения. На сервере используются функции:
♦listen() — ожидание клиента;
♦accept() — подтверждение запроса клиента на установление соединения.
Сервер должен постоянно прослушивать сокет — ожидать новых клиентов. Как только новый клиент посылает запрос на установление соединения, сервер может либо разрешить ему подключиться (connect), либо запретить (например, если сервер уже обслуживает другого клиента).
Функция listen()Вызов listen() «заставляет» программу-сервер работать в режиме ожидания запроса на соединение от клиента. Прототип этой функции следующий:
#include
extern int listen (int __fd, int __n) __THROW;
Первый параметр — это дескриптор сокета, а второй — максимальное количество запросов на установление связи (другими словами, максимальное количество клиентов).
Как и функция bind(), функция listen() в случае успеха возвращает 0. Пример вызова функции:
if (listen (sock1, 3) != 0) {
printf("Ошибка при вызове listen(sock1, 3)\n");
exit(1);
}
Функция connect()Используется программой-клиентом для отправки запроса на подключение к серверу. Прототип функции следующий:
#include
#include
#include
extern int connect (int __fd, struct sockaddr_in *addr,
socklen_t __len) __THROW;
Первый параметр — это дескриптор сокета, созданного функцией socket() и привязанного функцией bind(). Привязку сокета функцией bind() выполнять не обязательно: если сокет не был привязан до вызова connect(), привязка будет выполнена автоматически.
Второй параметр — это указатель на структуру типа sockaddr_in, содержащую информацию о сервере: его IP-адрес, номер порта, а также семейство протоколов.
Последний параметр — это размер структуры sockaddr_in в байтах. В случае успеха функция возвращает 0, а в случае ошибки —1.
Вот пример использования вызова connect:
struct sockaddr_in server;
struct hostent *h;
...
// определяем IP-адрес сервера
h = gethostbyname("server.domain.ru");
memcpy((char*)&server.sin_addr, h->h_addr, h->h_length);
// Определяем порт сервера
server.sin_port = 1234;
// Определяем семейство протоколов
server.sin_family = AF_INET;
// Вызов функции connect()
connect(sock, &server, sizeof(server));
Если вы используете режим без установления соединения (SOCK_DGRAM), вызов connect() необязателен.
Функция accept()Если максимальное число клиентов не превышено, сервер может принять запрос клиента. Для этого используется функция accept(). Данная функция используется только при работе в режиме с установлением соединения. Прототип функции следующий:
#include
#include
extern int accept(int __fd, struct sockaddr_in *addr,
socklen_t *__restrict __len) __THROW;
Первый параметр — это дескриптор сокета, второй — указатель на структуру, где можно разместить адрес клиента, причем данную структуру инициализировать не нужно. Последний параметр — размер структуры, указанной во втором параметре.
Системный вызов accept() работает так. Сначала он извлекает из очереди listen() запрос на соединение и создает новый сокет, через который будет производиться обмен данными с клиентом, например:
// получаем сокет клиента
sock2 = accept(sock1, &client, &ans_len);
// передаем клиенту информацию
write(sock2, MSG_TO_SEND, sizeof(MSG_TO_SEND));
Если вызов accept() завершился успехом, структура addr, задаваемая во втором параметре, будет содержать IP-адрес клиента.
Если очередь listen() пуста, то наш сервер будет ожидать появления нового клиента. В случае ошибки функция accept() возвращает отрицательное значение.
27.3.4. Функция gethostbyname()
Пользователям обычно удобнее указать символьное имя сервера, чем его IP-адрес. Для разрешения имени служит функция gethostbyname(). Вот ее прототип:
#include
#include
struct hostent *gethostbyname(char *name);
Данная функция возвращает указатель на структуру типа hostent, содержащую следующие поля:
♦char *h_name — доменное имя узла;
♦char **h_aliases — псевдонимы узла, если таковые определены;
♦char *h_addr — IP-адрес узла;
♦int h_addrtype — набор используемых протоколов (в нашем случае — AF_INET);
♦int h_length — длина адреса узла.
Примеры использования функции:
struct hostent *h;
h = gethostbyname(*argv);
if (h==NULL) {
printf("Невозможно разрешить имя: `%s`\n", *argv);
exit(1);
}
// Выводим IP-адрес. Вывод в виде: имя -> адрес
printf("%s -> %s \n", *argv,
inet_ntoa(*((struct in_addr *)h->h_addr_list[0])));
Узнать свой собственный адрес можно с помощью функции getsockname():
extern int getsockname(int __fd, __SOCKADDR_ARG __addr,
socklen_t *__restrict __len) __THROW;
Ей нужно передать три параметра — дескриптор сокета, адрес структуры, которая будет содержать информацию о нашем узле (его адрес). Третий параметр будет содержать длину адресной структуры.
27.3.5. Функции сетевого ввода/вывода
После успешного установления соединения можно начать обмен данными. Для отправки и получения данных можно использовать обыкновенные функции для работы с файлами — read() и write(), только вместо дескриптора файла нужно указывать дескриптор сокета. Однако рекомендуется использовать системные вызовы send() и recv(), которые предназначены именно для работы с сокетами. Эти системные вызовы будут рассмотрены ниже.
Если вы работаете в режиме без установления соединения, вам нужно использовать функции sendto() и recvfrom(). Первая функция отправляет данные, а вторая — принимает. Функция sendto() вместе с данными позволяет указать адрес получателя, a recvfrom() возвращает не только полученные данные, но и адрес отправителя.
Обмен данными в режиме SOCK_STREAMДля отправления данных используется функция send():
#include
#include
extern ssize_t send (int __fd, __const void *__buf,
size_t __n, int __flags) __THROW;
Первый параметр — дескриптор сокета, второй — указатель на область памяти, которая содержит передаваемые данные. Третий параметр — это размер передаваемых данных в байтах. Последний параметр позволяет определить поведение функции send(): если он равен 0, то вызов send() полностью аналогичен вызову write().
Нужно отметить особенность работы этой функции; если буфер сокета __fd переполнен, функция переводит программу в состояние ожидания освобождения буфера. Такое может случиться, если узел-приемник по каким-то причинам не успевает принять данные.
Функция возвращает число байтов отправленных данных или -1 в случае ошибки.
Для приема данных используется функция recv():
#include
#include
extern ssize_t recv(int __fd, void *__buf, size_t __n,
int __flags) __THROW;
Первый параметр, как обычно, задает дескриптор сокета. В случае успешного приема данных они будут размешены в буфере __buf — второй параметр функции recv(). Третий параметр задает размер области, на которую указывает второй параметр. Если четвертый параметр (флаги) принимает значение 0, то вызов recv() аналогичен вызову read(). Четвертый параметр может принимать следующие значения:
♦ MSG_PEEK — прочитанные данные не удаляются. Следующий вызов функции recvfrom() опять возвратит эти данные.
♦ MSG_WAITALL — процесс будет блокирован до получения всего запрошенного объема данных, а не до получения первого сообщения. Только для сокетов SOCK_STREAM!
Если через указанный сокет ничего нельзя принять, функция переводит программу в состояние ожидания — до появления данных в канале связи.
Функция возвращает количество принятых байтов или -1 в случае ошибки.
Обмен данными в режиме SOCK_DGRAMФункция sendto() позволяет отправить данные по протоколу UDP (без установления соединения), указав при этом узел-приемник:
extern ssize_t sendto(int __fd, __const void *__buf,
size_t __n, int __flags, __CONST_SOCKADDR_ARG __addr,
socklen_t __addr_len) __THROW;
Назначение первых четырех аргументов такое же, как и функции send(), а последние два аргумента задают структуру типа struct sockaddr_in, содержащую информацию об адресе узла-приемника, и размер этой структуры соответственно. Аргумент
__addr
— это адрес структуры sockaddr_in, а не она сама!Как и функция send(), функция sendto() возвращает количество байтов отправленных данных или -1, если произошла ошибка.
Функция recvfrom() позволяет получить данные по протоколу UDP:
extern ssize_t recvfrom(int __fd, void *__restrict __buf,
size_t __n, int __flags, __SOCKADDR_ARG __addr,
socklen_t *__restrict __addr_len) __THROW;
Назначение первых четыре аргументов такое же, как и у функции recv(). Предпоследний аргумент позволяет указать структуру, в которую будет записана информация об адресе узла-отправителя. Помните: нужно передать адрес структуры, а не саму структуру. Последний параметр задает длину этой структуры.
Функция возвращает количество принятых данных или -1 в случае ошибки. Проверить ошибку можно и по-другому: если структура адреса узла отправителя пуста (равна NULL), значит, произошла ошибка.
27.3.6. Завершение сеанса связи
Для закрытия сеанса связи можно использовать один из двух системных вызовов: close() или shutdown().
Системный вызов close() также используется для закрытия файлов. Вот прототип этой функции:
int close(int __fd);
Данной функции нужно передать всего один параметр — дескриптор сокета.
Однако вызов close() использовать не рекомендуется из-за специфики его работы: он закрывает сокет грубо, не дожидаясь завершения передачи данных. В результате использования close() вероятность повреждения принимаемых или передаваемых данных очень высока. В принципе, использовать close() можно на клиенте, но на сервере это недопустимо: сначала нужно использовать shutdown(), а потом уже close().
Вызов shutdown() используется для завершения сеанса связи, при этом еще не переданные данные будут переданы другой стороне. Прототип функции:
extern int shutdown(int __fd, int __how) __THROW;
Первый параметр — это дескриптор сокета, а второй может принимать одно из трех значений:
♦ SHUT_RD (или 0) — передать данные, которые еще не переданы, но их отправка уже началась, и больше не принимать данные для чтения.
♦ SHUT_WR (или 1) — передать данные и запретить прием данных через сокет.
♦ SHUT_RDWR (или 2) — передать данные и запретить вообще обмен через сокет — ни приема, ни передачи.
27.3.7. Программа-сервер
В этом пункте мы напишем две программы — сервер и клиент. Программа-сервер после запуска сразу же перейдет в режим ожидания («прослушивания») новых клиентов. Максимальное количество клиентов —3. Как только подключится клиент, сервер отправит ему сообщение «What is your name?», в ответ на которое клиент передаст свое имя — «Denis». Сервер прочитает переданную клиентом информацию и выведет ее на консоль. Клиент, в свою очередь, выведет на консоль запрос сервера.
С целью упрощения исходного кода как сервера, так и клиента, обработку ошибок производить не будем, поэтому будьте готовы к тому, что ваш клиент выдаст сообщение Segmentation fault в ответ на неверно заданные параметры. Я рекомендую в качестве имени сервера использовать
localhost
и обе программы запускать на одном компьютере — это же только демонстрация.Вот исходный код программы-сервера:
Листинг 27.3. Программа-сервер
#include
#include
#include
#include
#include
#include
#define SERVER_PORT 1234
#define BUF_SIZE 64
#define MSG_TO_SEND "What is your name?\n"
int main() {
int sock1, sock2;
int ans_len, total=0;
char buffer[BUF_SIZE];
struct sockaddr_in sin, client;
sock1 = socket(AF_INET, SOCK_STREAM, 0);
memset((char *)&sin, '\0', sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = SERVER_PORT;
bind(sock1, (struct sockaddr *)&sin, sizeof(sin));
printf("Server running...\n");
listen(sock1, 3);
while (1) {
ans_len = sizeof(client);
sock2 = accept(sock1, &client, &ans_len);
write(sock2, MSG_TO_SEND, sizeof(MSG_TO_SEND));
total+=1;
ans_len = read(sock2, buffer, BUF_SIZE);
write(1, buffer, ans_len);
printf("Client no %d\n", total);
shutdown(sock2, 0);
close(sock2);
}
return 0;
}
Теперь разберемся, что есть что. Сначала мы определяем некоторые макросы: номер порта, который будет прослушивать сервер, размер буфера передаваемых данных и текст запроса клиенту.
Стандартные номера портов определены в файле
netinet/in.h
:enum {
IPPORT_ECHO = 7, /* Echo service. */
IPPORT_DISCARD = 9, /* Discard transmissions service. */
IPPORT_SYSTAT = 11, /* System status service. */
IPPORT_DAYTIME = 13, /* Time of day service. */
IPPORT_NETSTAT = 15, /* Network status service. */
IPPORT_FTP = 21, /* File Transfer Protocol. */
IPPORT_TELNET =23, /* Telnet protocol. */
IPPORT_SMTP = 25, /* Simple Mail Transfer Protocol. */
IPPORT_TIMESERVER = 37, /* Timeserver service. */
IPPORT_NAMESERVER = 42, /* Domain Name Service. */
IPPORT_WHOIS = 43, /* Internet Whois service. */
IPPORT_MTP = 57,
IPPORT_TFTP = 69, /* Trivial File Transfer Protocol. */
IPPORT_RJE = 77,
IPPORT_FINGER = 79, /* Finger service. */
IPPORT_TTYLINK = 87,
IPPORT_SUPDUP = 95, /* SUPDUP protocol. */
IPPORT_EXECSERVER = 512, /* execd service. */
IPPORT_LOGINSERVER = 513, /* rlogind service. */
IPPORT_CMDSERVER = 514,
IPPORT_EFSSERVER = 520,
/* UDP ports. */
IPPORT_BIFFUDP = 512,
IPPORT_WHOSERVER = 513,
IPPORT_ROUTESERVER = 520,
/* Ports less than this value are reserved
for privileged processes. */
IPPORT_RESERVED = 1024,
/* Ports greater this value are reserved
for (non-privileged) servers. */
IPPORT_USERRESERVED = 5000
}
;Нам понадобятся сразу два сокета: первый — это сокет сервера, а через второй сокет мы будем производить обмен данными с клиентом.
int sock1, sock2;
Следующие переменные:
ans_len
используется для хранения размера передаваемой клиентом информации — фактического размера структуры struct sockaddr_in, а total
— это счетчик числа клиентов, используемый для вывода порядкового номера клиента.Переменная
buffer
размера BUF_SIZE — это наш буфер для обмена информацией. Нам нужны две структуры типа sockaddr_in
— одна для сервера (sin) и одна для клиента (client).В строке
sock1 = socket(AF_INET, SOСK_STREAM, 0);
мы создаем наш, «серверный», сокет: набор протоколов — TCP/IP, режим — с установлением соединения.
Затем мы инициализируем структуру sin:
memset((char *)&sin, '\0', sizeof(sin));
sin.sin_family = AF_INET; // TCP/IP
sin.sin_addr.s_addr = INADDR_ANY; // можем работать на
// любом адресе
sin.sin_port = SERVER_PORT; // указываем порт (1234)
После создания сокета и инициализации структуры sin, нужно связать наш сокет с адресом и портом сервера:
bind(sock1, (struct sockaddr *)&sin, sizeof(sin));
Оператор
listen(sock1, 3)
означает, что мы будем прослушивать сокет sock1 (порт 1234) и максимальное число клиентов не должно превышать 3.Как и любой нормальный сервер, мы должны работать в бесконечном цикле, постоянно обрабатывая запросы клиентов. В бесконечном цикле мы:
1. получаем размер структуры client
ans_len = sizeof(client);
2. создаем сокет sock2, через который будем обмениваться данными с клиентом. Если в очереди listen нет клиентов, мы переходим в состояние ожидания
sock2 = accept(sock1, &client, &ans_len);
3. как только подключится клиент, мы отправим ему сообщение MSG_TO_SEND
write(sock2, MSG_TO_SEND, sizeof(MSG_TO_SEND));
4. увеличиваем счетчик клиентов
total+=1;
5. получаем размер прочитанных данных, сами данные записываются в буфер buffer
ans_len = read(sock2, buffer, BUF_SIZE);
6. выводим прочитанные данные на стандартный вывод
write(1, buffer, ans_len);
7. завершаем сеанс связи
shutdown(sock2, 0);
8. закрываем сокет
close(sock2);
Конечно, любой нормальный сервер при поступлении определенных сигналов, например, SIG_HUP, должен корректно перезапуститься или вообще завершить работу. Наш сервер этого не делает — обработку сигналов, я надеюсь, вы можете добавить сами.
Теперь мы можем откомпилировать нашу программу:
$ gcc -о server server.c
Запускаем:
./server
Программа перешла в состояние ожидания новых клиентов.
27.3.8. Программа-клиент
Программа-клиент несколько проще, чем сервер. Вот ее листинг:
Листинг 27.4. Программа-клиент
#include
#include
#include
#include
#include
#include
#define SERVER_HOST "localhost"
#define SERVER_PORT 1234
#define CLIENT_PORT 1235
#define MSG "Denis\n"
main() {
int sock;
int ans_len;
int BUF_SIZE = 64;
char buffer[BUF_SIZE];
struct hostent *h;
struct sockaddr_in client, server;
sock = socket(AF_INET, SOCK_STREAM, 0);
memset((char *)&client, '\0', sizeof(client));
client.sin_family = AF_INET;
client.sin_addr.s_addr = INADDR_ANY;
client.sin_port = CLIENT_PORT;
bind(sock, (struct sockaddr *)&client, sizeof(client));
memset((char *)&client, '\0', sizeof(server));
h = gethostbyname(SERVER_HOST);
server.sin_family = AF_INET;
memcpy((char *)&server.sin_addr.h->h_addr, h->h_length);
server.sin_port = SERVER_PORT;
connect(sock, &server, sizeof(server));
ans_len = recv(sock, buffer, BUF_SIZE, 0);
write(1, buffer, ans_len);
send(sock, MSG, sizeof(MSG), 0);
close(sock);
exit(0);
}
Константа MSG — это сообщение, которое будет передано серверу. Как и в случае с сервером, нам понадобятся две структуры типа sockaddr_in:
struct hostent *h;
struct sockaddr_in client, server;
Структура типа hostent нам нужна для получения адреса сервера.
Создаем сокет, заполняем информацию о клиенте и связываем сокет:
sock = socket(AF_INET, SOCK_STREAM, 0);
memset((char *)&client, '\0' , sizeof(client));
client.sin_family = AF_INET;
client.sin_addr.s_addr = INADDR_ANY;
client.sin_port = CLIENT_PORT;
bind(sock, (struct sockaddr *)&client, sizeof(client));
Перед подключением к серверу нужно определить его IP-адрес:
h = gethostbyname(SERVER_HOST);
Подключаемся к серверу:
server.sin_family = AF_INET; // набор протоколов
memcpy((char *)&server.sin_addr, h->h_addr, h->h_length);
// задаем адрес сервера
server.sin_port = SERVER_PORT; // указываем порт сервера
connect(sock, &server, sizeof(server));
После подключения к серверу принимаем его запрос, выводим на стандартный вывод, отправляем серверу свое сообщение и закрываем сокет:
ans_len = recv(sock, buffer, BUF_SIZE, 0);
write(1, buffer, ans_len);
send(sock, MSG, sizeof(MSG), 0);
close(sock);
27.3.9. Установка опций сокета
Поскольку мы используем набор протоколов AF_INET, то в этом пункте будем рассматривать только те опции сокетов, которые относятся к этому набору. Для работы с опциями сокета используются две функции:
♦getsockopt() — получение опций сокета;
♦setsockopt() — установка опций сокета.
Прототипы этих функций выглядят так:
#include
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);
Первый параметр, sd, — это дескриптор сокета. Второй параметр — уровень доступа (существует только один уровень — SOL_SOCKET). Следующий параметр, option_name, — это название опции, значение которой вы хотите изменить (см. таблицу 27.10). Последние два параметра — это значение опции и его размер.
Наиболее часто используемые опции сокетов Таблица 27.10
Название опции Описание SO_DEBUG Включить/выключить (1/0) запись отладочной информации для сокета SO_BROADCAST Включить/выключить (1/0) отправку широковещательных сообщений SO_REUSEADDR Опция разрешает/запрещает использование локальных адресов SO_KEEPALIVE Сохраняет неактивные соединения "в живых" путем посылки сообщений. Если данный сокет не отвечает на сообщения, соединение будет разорвано, а процессу, который осуществлял запись в сокет, будет послан сигнал SIGPIPE. Для включения KEEPALIVE нужно установить значение 1, для выключения — 0 SO_SNDBUF Устанавливает размер буфера отправки, значение целого типа SO_RCVBUF Устанавливает размер буфера приема, значение целого типа SO_SNDTIMEO Установка таймаута для отправки сообщений. По умолчанию таймаут равен 0, то есть его вообще нет. Нужно передать значение типа struct timeval SO_RCVTIMEO Установка таймаута для приема сообщений. По умолчанию таймаут равен 0, то есть его вообще нет. Нужно передать значение типа struct timeval TCP_NODELAY Отключить (1) механизм буферизации сообщений, то есть они будут отправляться сразу, без задержки. Для включения механизма буферизации нужно указать значение 0 TCP_MAXSEG Установить максимальный сегмент данных. Значение целого типа TCP_NOPUSH Не использовать проталкивание (1) TCP_NOOPT Не использовать опции TCP (1). Для использования опций передайте значение 0
В случае успешной установки параметра функция setsockopt() возвращает 0; в случае ошибки возвращается -1, а переменная errno устанавливается следующим образом:
♦ EBADF — неверный дескриптор сокета:
♦ ENOTSOCK — указанный дескриптор является файлом, а не сокетом;
♦ EFAULT — нет доступа к адресу, на который указывает указатель
optval
, то есть данный адрес находится за пределами видимости приложения.Функция getsockopt() возвращает значение параметра. Кроме вышеперечисленных параметров, функция getsockopt() может использовать следующие параметры:
♦ SO_ERROR — возвращает номер ошибки (будет в возвращаемом значении);
♦ SO_TYPE — возвращает тип сокета.
Рассмотрим небольшой пример работы с опциями сокетов. Мы установим размер буфера TCP.
#include "sock.h"
#include "stdio.h"
main() {
int sd; /* дескриптор сокета */
int optval; /* значение опции */
int optlen; /* длина optval */
int new_buffsize = 8192; /* новый размер буфера */
/* создаем сокет */
sd = socket(AF_INET, SOCK_STREAM, 0);
/* считывание длины буфера TCP */
optlen = sizeof(optval);
getsockopt(sd, SOL_SOCKET, SO_SNDBUF, &optval, &optlen);
printf("Size of send buffer %d\n", optval);
getsockopt(sd, SOL_SOCKET, SO_RCVBUF, &optval, &optlen);
printf("Size of recv buffer %d\n", optval);
/* изменяем длину буфера */
setsockopt(sd, SOL_SOCKET, SO_RCVBUF,
&new_buffsize, sizeof(new_buffsize));
setsockopt(sd, SOL_SOCKET, SO_SNDBUF,
&new_buffsize, sizeof(new_buffsize));
/* выводим измененную информацию */
getsockopt(sd, SOL_SOCKET, SO_SNDBUF, &optval, &optlen);
printf("New size of send buffer %d\n", optval);
getsockopt(sd, SOL_SOCKET, SO_RCVBUF, &optval, &optlen);
printf("New size of recv buffer %d\n", optval);
}
27.3.10. Сигналы и сокеты
С сокетами связаны три сигнала:
♦ SIGIO — сокет готов к вводу/выводу. Сигнал посылается процессу, который связан с сокетом;
♦ SIGURG — сокет получил экспресс-данные (мы их использовать не будем, поэтому особо останавливаться на них нет смысла);
♦ SIGPIPE — запись в сокет больше невозможна. Сигнал посылается процессу, связанному с сокетом. Например, функция write() вызывает сигнал SIGPIPE, если удаленный процесс завершен или связь по сети невозможна.
Пример обработки сигнала SIGPIPE приведен ниже.
Листинг 27.6. Обработка сигнала SIGPIPE
#include "sock.h"
#include
/* обработчик сигнала SIGPIPE */
sigpipe_handler() {
err_quit("Получен SIGPIPE \n");
}
main() {
int sock; /* дескриптор сокета */
/* установка обработчика сигнала SIGPIPE */
signal(SIGPIPE, sigpipe_handler);
/* работа с сокетом */
}
27.3.11. Мультиплексирование
В этой главе мы рассматривали пример программы-сервера, обрабатывающей запросы только от одного клиента. На практике все выглядит намного сложнее: серверу приходится одновременно обрабатывать запросы многих клиентов. Для мультиплексирования запросов клиентов используется системный вызов select(). Этот вызов использует, например, суперсервер xinetd.
Листинг 27.7. Мультиплексирование запросов
#include "sock.h"
#include
main() {
int sock; /* дескриптор исходного сокета */
int new_sock; /* дескриптор, полученный с помощью accept */
int retval; /* возвращаемое значение */
struct sockaddr_in server; /* адрес сокета */
fd_set readv; /* переменная для select */
fd_set writev; /* переменная для select */
struct timeval tout; /* тайм-аут для select */
/* бесконечный цикл ожидания */
for (;;) {
/* процесс ждет операцию ввода-вывода на сокете;
одновременно можно ждать и другие операции */
FD_ZERO(&readv);
FD_ZERO(&writev);
FD_SET(sock, &readv);
FD_SET(sock, &writev);
tout.tv_sec = 10; /* 10 секунд */
retval = select(sock+1, &readv, &writev, 0, &to);
/* если select возвращает нулевое значение, значит тайм-аут */
if (retval == 0) {
err_ret("timeout");
continue;
}
/* в противном случае, ищем соответствующий дескриптор */
if ( (FD_ISSET(sock, &readv)) || (FD_ISSET(sock, &writev))) {
/* прием связи с сокета */
new_sock = accept(sock, (struct sockaddr *)0, (int *)0);
/* работа с сокетом new_sock */
...
/* закрытие текущей связи */
close(new_sock);
} else {
err_ret("Это не сокет! Проверьте все дескрипторы\n");
}
}
}
Системный вызов select() принимает 5 аргументов:
int select(int fd, fd_set *input, fd_set *output,
fd_set *error, struct timeval *timeout);
Первый аргумент, fd, — это файловый дескриптор, который может быть сокетом. Следующие три аргумента задают множества файловых дескрипторов для ожидания условий ввода (input), вывода (output) и ошибок (error). Последний аргумент — это тайм-аут.
Множества файловых дескрипторов инициализируются с помощью трех макросов:
FD_ZERO(fd_set);
FD_SET(fd, fd_set);
FD_CLR(fd, fd_set);
Первый макрос полностью очищает множество, следующие два макроса, соответственно, добавляют и удаляют файловый дескриптор. Мы использовали два макроса для ввода и два для вывода. Сначала мы полностью очистили множество, а потом добавили в него соответствующие дескрипторы:
FD_ZERO(&readv);
FD_ZERO(&writev);
FD_SET(sock, &readv);
FD_SET(sock, &writev);
Особого разговора требует последний параметр — тайм-аут. Тайм-аут можно задавать в секундах и миллисекундах. Например, следующие операторы объявляют тайм-аут длительностью 2 секунды и 5 миллисекунд:
struct timeval tout; /* тайм-аут для select */
tout.tv_sec = 2; /* 2 секунды */
tout.tv_usec = 5; /* 5 миллисекунд */
Если вы хотите не использовать тайм-аут (то есть ждать бесконечно), укажите NULL в качестве последнего аргумента.
Функция select() возвращает число файловых дескрипторов, на которых выполнились ожидаемые условия (ввод/вывод/ошибка) или -1 при ошибке.
Вот еще один пример использования функции select(). Мы будем ожидать ввода из файла и из сокета. Если будет достигнут тайм-аут в 20 секунд, пользователь увидит соответствующее сообщение; в противном случае он увидит сообщение: «Получен ввод из файла/сокета».
Листинг 27.8. Еще один пример использования select()
#include
#include
#include
#include
int k;
int sock;
int fd;
int max_fd;
fd_set input;
struct timeval timeout;
/* инициализация файла и сокета */
...
/* Инициализируем множество ввода */
FD_ZERO(input);
FD_SET(fd, input);
FD_SET(sock, input);
max_fd = (sock > fd ? sock : fd) + 1;
/* Задаем тайм-аут */
timeout.tv_sec = 20;
k = select(max_fd, &input, NULL, NULL, &timeout);
if (k < 0)
perror("Ошибка при вызове select");
else if (k == 0) puts("TIMEOUT");
else {
/* Получен ввод */
if (FD_ISSET(fd, input))
printf("Получен ввод из файла");
if (FD_ISSET(sock, input))
printf("Получен ввод из сокета");
}
Вроде бы код программы очень прост, но комментария заслуживает макрос FD_ISSET. С его помощью мы проверяем, есть ли во множестве ввода ввод из какого-либо источника.
27.3.12. Неблокирующие операции
Некоторые функции для работы с сокетами блокируют программу в случае, если удаленный процесс не осуществил требуемую операцию. Примеры таких функций:
♦ accept();
♦ connect();
♦ read();
♦ write().
Блокирование процесса очень нежелательно, поскольку во время ожидания можно было бы заняться чем-нибудь другим: например, обработать информацию, поступившую с другого сокета. Вы можете объявить сокеты неблокирующими с помощью системного вызовы ioctl().
Особенности работы некоторых функций в неблокирующем режиме:
♦ функция accept() сразу же завершает работу с ошибкой EWOULDBLOCK;
♦ функция connect() тоже завершает работу, но с другой ошибкой: EINPROGRESS;
♦ функции чтения (read(), recv(), recvfrom()) возвращают -1 или 0, если нет считываемых данных.
Ясное дело, что в таком режиме нужно периодически проверять наличие данных — ведь теперь процесс не будет их ожидать: если их нет, то функции просто возвратят -1 или 0.
Пример создания неблокирующих сокетов приведен ниже:
Листинг 27.9. Использование системного вызова ioctl()
#include "sock.h"
#include
void main() {
int sock;
int on = 1, off = 0; /* значение дня ioctl() */
/* Создаем неблокирующий сокет */
ioctl(sock, FIONBIO, &on);
}
Глава 28