Операционные системы/Сокеты
Материал из eSyr's wiki.
(Новая: == Механизм сокетов == Средства межпроцессного взаимодействия ОС UNIX, представленные в системе IPC, решаю...) |
(Новая: == Механизм сокетов == Средства межпроцессного взаимодействия ОС UNIX, представленные в системе IPC, решаю...) |
Текущая версия
Содержание |
[править] Механизм сокетов
Средства межпроцессного взаимодействия ОС UNIX, представленные в системе IPC, решают проблему взаимодействия двух процессов, выполняющихся в рамках одной операционной системы. Однако, очевидно, их невозможно использовать, когда требуется организовать взаимодействие процессов в рамках сети. Это связано как с принятой системой именования, которая обеспечивает уникальность только в рамках данной системы, так и вообще с реализацией механизмов разделяемой памяти, очереди сообщений и семафоров, – очевидно, что для удаленного взаимодействия они не годятся. Следовательно, возникает необходимость в каком-то дополнительном механизме, позволяющем общаться двум процессам в рамках сети. Однако если разработчики программ будут иметь два абсолютно разных подхода к реализации взаимодействия процессов, в зависимости от того, на одной машине они выполняются или на разных узлах сети, им, очевидно, придется во многих случаях создавать два принципиально разных куска кода, отвечающих за это взаимодействие. Понятно, что это неудобно и хотелось бы в связи с этим иметь некоторый унифицированный механизм, который в определенной степени позволял бы абстрагироваться от расположения процессов и давал бы возможность использования одних и тех же подходов для локального и нелокального взаимодействия. Кроме того, как только мы обращаемся к сетевому взаимодействию, встает проблема многообразия сетевых протоколов и их использования. Понятно, что было бы удобно иметь какой-нибудь общий интерфейс, позволяющий пользоваться услугами различных протоколов по выбору пользователя.
Обозначенные проблемы был призван решить механизм, впервые появившийся в UNIX – BSD (4.2) и названный сокетами (sockets).
Сокеты представляют собой в определенном смысле обобщение механизма каналов, но с учетом возможных особенностей, возникающих при работе в сети. Кроме того, они предоставляют больше возможностей по передаче сообщений, например, могут поддерживать передачу экстренных сообщений вне общего потока данных. Общая схема работы с сокетами любого типа такова: каждый из взаимодействующих процессов должен на своей стороне создать и отконфигурировать сокет, после чего процессы должны осуществить соединение с использованием этой пары сокетов. По окончании взаимодействия сокеты уничтожаются.
Механизм сокетов чрезвычайно удобен при разработке взаимодействующих приложений, образующих систему «клиент-сервер». Клиент посылает серверу запросы на предоставление услуги, а сервер отвечает на эти запросы.
Схема использования механизма сокетов для взаимодействия в рамках модели «клиент-сервер» такова. Процесс-сервер запрашивает у ОС сокет и, получив его, присваивает ему некоторое имя (адрес), которое предполагается заранее известным всем клиентам, которые захотят общаться с данным сервером. После этого сервер переходит в режим ожидания и обработки запросов от клиентов. Клиент, со своей стороны, тоже создает сокет и запрашивает соединение своего сокета с сокетом сервера, имеющим известное ему имя (адрес). После того, как соединение будет установлено, клиент и сервер могут обмениваться данными через соединенную пару сокетов. Ниже мы подробно рассмотрим функции, выполняющие все необходимые действия с сокетами, и напишем пример небольшой серверной и клиентской программы, использующих сокеты.
[править] Типы сокетов. Коммуникационный домен
Сокеты подразделяются на несколько типов в зависимости от типа коммуникационного соединения, который они используют. Два основных типа коммуникационных соединений и, соответственно, сокетов представляет собой
- соединение с использованием виртуального канала и
- датаграммное соединение.
Соединение с использованием виртуального канала – это последовательный поток байтов, гарантирующий надежную доставку сообщений с сохранением порядка их следования. Данные начинают передаваться только после того, как виртуальный канал установлен, и канал не разрывается, пока все данные не будут переданы. Примером соединения с установлением виртуального канала является механизм каналов в UNIX, аналогом такого соединения из реальной жизни также является телефонный разговор. Заметим, что границы сообщений при таком виде соединений не сохраняются, т.е. приложение, получающее данные, должно само определять, где заканчивается одно сообщение и начинается следующее. Такой тип соединения может также поддерживать передачу экстренных сообщений вне основного потока данных, если это возможно при использовании конкретного выбранного протокола.
Датаграммное соединение используется для передачи отдельных пакетов, содержащих порции данных – датаграммы. Для датаграмм не гарантируется доставка в том же порядке, в каком они были посланы. Вообще говоря, для них не гарантируется доставка вообще, надежность соединения в этом случае ниже, чем при установлении виртуального канала. Однако датаграммные соединения, как правило, более быстрые. Примером датаграммного соединения из реальной жизни может служить обычная почта: письма и посылки могут приходить адресату не в том порядке, в каком они были посланы, а некоторые из них могут и совсем пропадать.
Поскольку сокеты могут использоваться как для локального, так и для удаленного взаимодействия, встает вопрос о пространстве адресов сокетов. При создании сокета указывается так называемый коммуникационный домен, к которому данный сокет будет принадлежать. Коммуникационный домен определяет форматы адресов и правила их интерпретации. Мы будем рассматривать два основных домена:
- для локального взаимодействия – домен AF_UNIX
- для взаимодействия в рамках сети – домен AF_INET (префикс AF обозначает сокращение от «address family» – семейство адресов).
В домене AF_UNIX формат адреса – это допустимое имя файла, в домене AF_INET адрес образуют имя хоста + номер порта.
Заметим, что фактически коммуникационный домен определяет также используемые семейства протоколов. Так, для домена AF_UNIX это будут внутренние протоколы ОС, для домена AF_INET – протоколы семейства TCP/IP. Современные системы поддерживают и другие коммуникационные домены, например BSD UNIX поддерживает также третий домен – AF_NS, использующий протоколы удаленного взаимодействия Xerox NS.
[править] Создание и конфигурирование сокета
[править] Создание сокета
#include <sys/types.h> #include <sys/socket.h> int socket (int domain, int type, int protocol)
Функция создания сокета так и называется – socket(). У нее имеется три аргумента. Первый аргумент – domain – обозначает коммуникационный домен, к которому должен принадлежать создаваемый сокет. Для двух рассмотренных нами доменов соответствующие константы будут равны, как мы уже говорили, AF_UNIX и AF_INET. Второй аргумент – type – определяет тип соединения, которым будет пользоваться сокет (и, соответственно, тип сокета). Для двух основных рассматриваемых нами типов сокетов это будут константы SOCK_STREAM для соединения с установлением виртуального канала и SOCK_DGRAM для датаграмм. Третий аргумент – protocol – задает конкретный протокол, который будет использоваться в рамках данного коммуникационного домена для создания соединения. Если установить значение данного аргумента в 0, система автоматически выберет подходящий протокол. В наших примерах мы так и будем поступать. Однако здесь для справки приведем константы для протоколов, используемых в домене AF_INET:
- IPPROTO_TCP – обозначает протокол TCP (корректно при создании сокета типа SOCK_STREAM)
- IPPROTO_UDP – обозначает протокол UDP (корректно при создании сокета типа SOCK_DGRAM)
Функция socket() возвращает в случае успеха положительное целое число – дескриптор сокета, которое может быть использовано в дальнейших вызовах при работе с данным сокетом. Заметим, что дескриптор сокета фактически представляет собой файловый дескриптор, а именно, он является индексом в таблице файловых дескрипторов процесса, и может использоваться в дальнейшем для операций чтения и записи в сокет, которые осуществляются подобно операциям чтения и записи в файл (подробно эти операции будут рассмотрены ниже).
В случае если создание сокета с указанными параметрами невозможно (например, при некорректном сочетании коммуникационного домена, типа сокета и протокола), функция возвращает –1.
[править] Связывание
Для того чтобы к созданному сокету мог обратиться какой-либо процесс извне, необходимо присвоить ему адрес. Как мы уже говорили, формат адреса зависит от коммуникационного домена, в рамках которого действует сокет, и может представлять собой либо путь к файлу, либо сочетание IP-адреса и номера порта. Но в любом случае связывание сокета с конкретным адресом осуществляется одной и той же функцией bind:
#include <sys/types.h> #include <sys/socket.h> int bind (int sockfd, struct sockaddr *myaddr, int addrlen)
Первый аргумент функции – дескриптор сокета, возвращенный функцией socket(); второй аргумент – указатель на структуру, содержащую адрес сокета. Для домена AF_UNIX формат структуры описан в <sys/un.h> и выглядит следующим образом:
#include <sys/un.h>
struct sockaddr_un {
short sun_family; /* == AF_UNIX */
char sun_path[108];
};
Для домена AF_INET формат структуры описан в <netinet/in.h> и выглядит следующим образом:
#include <netinet/in.h>
struct sockaddr_in {
short sin_family; /* == AF_INET */
u_short sin_port; /* port number */
struct in_addr sin_addr; /* host IP address */
char sin_zero[8]; /* not used */
};
Последний аргумент функции задает реальный размер структуры, на которую указывает myaddr.
Важно отметить, что если мы имеем дело с доменом AF_UNIX и адрес сокета представляет собой имя файла, то при выполнении функции bind() система в качестве побочного эффекта создает файл с таким именем. Поэтому для успешного выполнения bind() необходимо, чтобы такого файла не существовало к данному моменту. Это следует учитывать, если мы «зашиваем» в программу определенное имя и намерены запускать нашу программу несколько раз на одной и той же машине – в этом случае для успешной работы bind() необходимо удалять файл с этим именем перед связыванием. Кроме того, в процессе создания файла, естественно, проверяются права доступа пользователя, от имени которого производится вызов, ко всем директориям, фигурирующим в полном путевом имени файла, что тоже необходимо учитывать при задании имени. Если права доступа к одной из директорий недостаточны, вызов bind() завершится неуспешно.
В случае успешного связывания bind() возвращает 0, в случае ошибки – -1.
[править] Типы сокетов
Различают два типа сокетов:
- сокеты с предварительным установлением соединения, когда до начала передачи данных устанавливаются адреса сокетов отправителя и получателя данных – такие сокеты соединяются друг с другом и остаются соединенными до окончания обмена данными
- сокеты без установления соединения, когда соединение до начала передачи данных не устанавливается, а адреса сокетов отправителя и получателя передаются с каждым сообщением.
Если тип сокета – виртуальный канал, то сокет должен устанавливать соединение, если же тип сокета – датаграмма, то, как правило, это сокет без установления соединения, хотя последнее не является требованием.
[править] Сокеты с установлением соединения. Запрос на соединение
Для установления соединения служит следующая функция:
#include <sys/types.h> #include <sys/socket.h> int connect (int sockfd, struct sockaddr *serv_addr, int addrlen);
Здесь первый аргумент – дескриптор сокета, второй аргумент – указатель на структуру, содержащую адрес сокета, с которым производится соединение, в формате, который мы обсуждали выше, и третий аргумент содержит реальную длину этой структуры.
Функция возвращает 0 в случае успеха и –1 в случае неудачи, при этом код ошибки можно посмотреть в переменной errno.
Заметим, что в рамках модели «клиент-сервер» клиенту, вообще говоря, не важно, какой адрес будет назначен его сокету, так как никакой процесс не будет пытаться непосредственно установить соединение с сокетом клиента. Поэтому клиент может не вызывать предварительно функцию bind(), в этом случае при вызове connect() система автоматически выберет приемлемые значения для локального адреса клиента. Однако сказанное справедливо только для взаимодействия в рамках домена AF_INET, в домене AF_UNIX клиентское приложение само должно позаботиться о связывании сокета.
[править] Сервер: прослушивание сокета и подтверждение соединения
Следующие два вызова используются сервером только в том случае, если используются сокеты с предварительным установлением соединения.
#include <sys/types.h> #include <sys/socket.h> int listen (int sockfd, int backlog);
Этот вызов используется процессом-сервером для того, чтобы сообщить системе о том, что он готов к обработке запросов на соединение, поступающих на данный сокет. До тех пор, пока процесс – владелец сокета не вызовет listen(), все запросы на соединение с данным сокетом будут возвращать ошибку. Первый аргумент функции – дескриптор сокета. Второй аргумент, backlog, содержит максимальный размер очереди запросов на соединение. ОС буферизует приходящие запросы на соединение, выстраивая их в очередь до тех пор, пока процесс не сможет их обработать. В случае если очередь запросов на соединение переполняется, поведение ОС зависит от того, какой протокол используется для соединения. Если конкретный протокол соединения не поддерживает возможность перепосылки (retransmission) данных, то соответствующий вызов connect() вернет ошибку ECONNREFUSED. Если же перепосылка поддерживается (как, например, при использовании TCP), ОС просто выбрасывает пакет, содержащий запрос на соединение, как если бы она его не получала вовсе. При этом пакет будет присылаться повторно до тех пор, пока очередь запросов не уменьшится и попытка соединения не увенчается успехом, либо пока не произойдет тайм-аут, определенный для протокола. В последнем случае вызов connect() завершится с ошибкой ETIMEDOUT. Это позволит клиенту отличить, был ли процесс-сервер слишком занят, либо он не функционировал. В большинстве систем максимальный допустимый размер очереди равен 5.
Конкретное соединение устанавливается при помощи вызова accept():
#include <sys/types.h> #include <sys/socket.h> int accept (int sockfd, struct sockaddr *addr, int *addrlen);
Этот вызов применяется сервером для удовлетворения поступившего клиентского запроса на соединение с сокетом, который сервер к тому моменту уже прослушивает (т.е. предварительно была вызвана функция listen()). Вызов accept() извлекает первый запрос из очереди запросов, ожидающих соединения, и устанавливает с ним соединение. Если к моменту вызова accept() очередь запросов на соединение пуста, процесс, вызвавший accept(), блокируется до поступления запросов.
Когда запрос поступает и соединение устанавливается, accept() создает новый сокет, который будет использоваться для работы с данным соединением, и возвращает дескриптор этого нового сокета, соединенного с сокетом клиентского процесса. При этом первоначальный сокет продолжает оставаться в состоянии прослушивания. Через новый сокет осуществляется обмен данными, в то время как старый сокет продолжает обрабатывать другие поступающие запросы на соединение (напомним, что именно первоначально созданный сокет связан с адресом, известным клиентам, поэтому все клиенты могут слать запросы только на соединение с этим сокетом). Это позволяет процессу-серверу поддерживать несколько соединений одновременно. Обычно это реализуется путем порождения для каждого установленного соединения отдельного процесса-потомка, который занимается собственно обменом данными только с этим конкретным клиентом, в то время как процесс-родитель продолжает прослушивать первоначальный сокет и порождать новые соединения.
Во втором параметре передается указатель на структуру, в которой возвращается адрес клиентского сокета, с которым установлено соединение, а в третьем параметре возвращается реальная длина этой структуры. Благодаря этому сервер всегда знает, куда ему в случае надобности следует послать ответное сообщение. Если адрес клиента нас не интересует, в качестве второго аргумента можно передать NULL.
[править] Прием и передача данных
Собственно для приема и передачи данных через сокет используются три пары функций.
#include <sys/types.h> #include <sys/socket.h> int send(int sockfd, const void *msg, int len, unsigned int flags); int recv(int sockfd, void *buf, int len, unsigned int flags);
Эти функции используются для обмена только через сокет с предварительно установленным соединением. Аргументы функции send(): sockfd – дескриптор сокета, через который передаются данные, msg и len - сообщение и его длина. Если сообщение слишком длинное для того протокола, который используется при соединении, оно не передается и вызов возвращает ошибку EMSGSIZE. Если же сокет окажется переполнен, т.е. в его буфере не хватит места, чтобы поместить туда сообщение, выполнение процесса блокируется до появления возможности поместить сообщение. Функция send() возвращает количество переданных байт в случае успеха и -1 в случае неудачи. Код ошибки при этом устанавливается в errno. Аргументы функции recv() аналогичны: sockfd – дескриптор сокета, buf и len – указатель на буфер для приема данных и его первоначальная длина. В случае успеха функция возвращает количество считанных байт, в случае неудачи -1.
Последний аргумент обеих функций – flags – может содержать комбинацию специальных опций. Нас будут интересовать две из них:
- MSG_OOB – этот флаг сообщает ОС, что процесс хочет осуществить прием/передачу экстренных сообщений
- MSG_PEEK – данный флаг может устанавливаться при вызове recv(). При этом процесс получает возможность прочитать порцию данных, не удаляя ее из сокета, таким образом, что последующий вызов recv() вновь вернет те же самые данные.
Другая пара функций, которые могут использоваться при работе с сокетами с предварительно установленным соединением – это обычные read() и write(), в качестве дескриптора которым передается дескриптор сокета.
И, наконец, пара функций, которая может быть использована как с сокетами с установлением соединения, так и с сокетами без установления соединения:
#include <sys/types.h> #include <sys/socket.h> int sendto(int sockfd, const void *msg, int len, unsigned int flags, const struct sockaddr *to, int tolen); int recvfrom(int sockfd, void *buf, int len, unsigned int flags, struct sockaddr *from, int *fromlen);
Первые 4 аргумента у них такие же, как и у рассмотренных выше. В последних двух в функцию sendto() должны быть переданы указатель на структуру, содержащую адрес получателя, и ее размер, а функция recvfrom() в них возвращает соответственно указатель на структуру с адресом отправителя и ее реальный размер. Отметим, что перед вызовом recvfrom() параметр fromlen должен быть установлен равным первоначальному размеру структуры from. Здесь, как и в функции accept, если нас не интересует адрес отправителя, в качестве from можно передать NULL.
[править] Завершение работы с сокетом
Если процесс закончил прием либо передачу данных, ему следует закрыть соединение. Это можно сделать с помощью функции shutdown():
# include <sys/types.h> # include <sys/socket.h> int shutdown (int sockfd, int mode);
Помимо дескриптора сокета, ей передается целое число, которое определяет режим закрытия соединения.
- Если mode=0, то сокет закрывается для чтения, при этом все дальнейшие попытки чтения будут возвращать EOF.
- Если mode=1, то сокет закрывается для записи, и при осуществлении в дальнейшем попытки передать данные будет выдан кода неудачного завершения (-1).
- Если mode=2, то сокет закрывается и для чтения, и для записи.
Аналогично файловому дескриптору, дескриптор сокета освобождается системным вызовом close(). При этом, разумеется, даже если до этого не был вызван shutdown(), соединение будет закрыто. Таким образом, в принципе, если по окончании работы с сокетом мы собираемся закрыть соединение и по чтению, и по записи, можно было бы сразу вызвать close() для дескриптора данного сокета, опустив вызов shutdown(). Однако, есть небольшое различие с тем случаем, когда предварительно был вызван shutdown(). Если используемый для соединения протокол гарантирует доставку данных (т.е. тип сокета – виртуальный канал), то вызов close() будет блокирован до тех пор, пока система будет пытаться доставить все данные, находящиеся «в пути» (если таковые имеются), в то время как вызов shutdown() извещает систему о том, что эти данные уже не нужны и можно не предпринимать попыток их доставить, и соединение закрывается немедленно. Таким образом, вызов shutdown() важен в первую очередь для закрытия соединения сокета с использованием виртуального канала.
[править] Общая схема работы с сокетами
Мы рассмотрели все основные функции работы с сокетами.
[править] Общая схема работы с сокетами с установлением соединения
Обобщая изложенное, можно изобразить общую схему работы с сокетами с установлением соединения в следующем виде:
[править] Общая схема работы с сокетами без предварительного установления соединения
Общая схема работы с сокетами без предварительного установления соединения проще, она такова:
