18.1. socket – Low-level networking interface¶

18.1.1. Семейства сокетов¶Socket families

В зависимости от системы и параметров сборки этим модулем поддерживаются различные семейства сокетов.

Формат адреса, требуемый для конкретного объекта сокета, автоматически выбирается на основе семейства адресов, указанного при создании объекта сокета. Адреса сокетов представляются следующим образом:

• Адрес сокета AF_UNIX, привязанного к узлу файловой системы, представляется в виде строки с использованием кодировки файловой системы и обработчика ошибок 'surrogateescape' (см. PEP 383). Адрес в абстрактном пространстве имён Linux возвращается как объект bytes с начальным нулевым байтом; учтите, что сокеты в этом пространстве имён могут взаимодействовать с обычными сокетами файловой системы, поэтому программам, предназначенным для работы в Linux, возможно, придётся работать с обоими типами адресов. Строку или объект bytes можно использовать для адресов любого типа при передаче в качестве аргумента.

  Изменено в версии 3.3: Ранее пути сокетов AF_UNIX считались использующими кодировку UTF-8.

• Пара (host, port) используется для семейства адресов AF_INET, где host – строка, представляющая либо имя хоста в доменной нотации Интернета, например 'daring.cwi.nl', либо IPv4-адрес, например '100.50.200.5', а port – целое число.

• Для семейства адресов AF_INET6 используется кортеж из четырёх элементов (host, port, flowinfo, scopeid), где flowinfo и scopeid соответствуют полям sin6_flowinfo и sin6_scope_id в структуре struct sockaddr_in6 в C. Для методов модуля socket flowinfo и scopeid можно опускать для обратной совместимости. Однако учтите, что пропуск scopeid может вызвать проблемы при работе с адресами IPv6, имеющими зону действия.

• Сокеты AF_NETLINK представляются в виде пар (pid, groups).

• Поддержка TIPC только для Linux доступна с использованием семейства адресов AF_TIPC. TIPC – это открытый сетевой протокол, не основанный на IP, предназначенный для использования в кластерных вычислительных средах. Адреса представляются в виде кортежа, и поля зависят от типа адреса. Общая форма кортежа: (addr_type, v1, v2, v3 [, scope]), где:

  • addr_type – одно из TIPC_ADDR_NAMESEQ, TIPC_ADDR_NAME, или TIPC_ADDR_ID.

  • scope – одно из TIPC_ZONE_SCOPE, TIPC_CLUSTER_SCOPE и TIPC_NODE_SCOPE.

  • Если addr_type – TIPC_ADDR_NAME, то v1 – тип сервера, v2 – идентификатор порта, а v3 должно быть равно 0.

    Если addr_type – TIPC_ADDR_NAMESEQ, то v1 – тип сервера, v2 – нижний номер порта, а v3 – верхний номер порта.

    Если addr_type – TIPC_ADDR_ID, то v1 – узел, v2 – ссылка, а v3 должно быть установлено в 0.

• Кортеж (interface, ) используется для семейства адресов AF_CAN, где interface – строка, представляющая имя сетевого интерфейса, например 'can0'. Имя сетевого интерфейса '' можно использовать для получения пакетов со всех сетевых интерфейсов этого семейства.

• Строка или кортеж (id, unit) используется для протокола SYSPROTO_CONTROL семейства PF_SYSTEM. Строка – это имя элемента управления ядра с динамически назначаемым идентификатором. Кортеж можно использовать, если идентификатор и номер модуля элемента управления ядра известны или используется зарегистрированный идентификатор.

  Новое в версии 3.3.

• AF_BLUETOOTH поддерживает следующие протоколы и форматы адресов:

  • BTPROTO_L2CAP принимает (bdaddr, psm), где bdaddr – Bluetooth-адрес в виде строки, а psm – целое число.

  • BTPROTO_RFCOMM принимает (bdaddr, channel), где bdaddr – Bluetooth-адрес в виде строки, а channel – целое число.

  • BTPROTO_HCI принимает (device_id,), где device_id – либо целое число, либо строка с Bluetooth-адресом интерфейса. (Зависит от ОС; NetBSD и DragonFlyBSD ожидают Bluetooth-адрес, а все остальные – целое число.)

    Изменено в версии 3.2: Добавлена поддержка NetBSD и DragonFlyBSD.

  • BTPROTO_SCO принимает bdaddr, где bdaddr – объект bytes, содержащий Bluetooth-адрес в строковом формате (например, b'12:23:34:45:56:67'). Этот протокол не поддерживается в FreeBSD.

• Некоторые другие семейства адресов (AF_PACKET, AF_CAN) поддерживают особые представления.

Для IPv4-адресов вместо адреса хоста принимаются две специальные формы: пустая строка обозначает INADDR_ANY, а строка '<broadcast>' обозначает INADDR_BROADCAST. Такое поведение несовместимо с IPv6, поэтому от этих форм лучше отказаться, если планируется поддержка IPv6 в программах на Python.

Если в части узел адреса сокета IPv4/v6 указано имя узла, программа может демонстрировать недетерминированное поведение, так как Python использует первый адрес, возвращённый при разрешении DNS. Адрес сокета будет разрешаться по-разному в фактический IPv4/v6-адрес в зависимости от результатов разрешения DNS и/или конфигурации узла. Для детерминированного поведения используйте числовой адрес в части узел.

Все ошибки порождают исключения. Могут возникать обычные исключения для недопустимых типов аргументов и нехватки памяти; начиная с Python 3.3 ошибки, связанные с семантикой сокетов или адресов, порождают OSError или один из его подклассов (ранее они порождали socket.error).

Неподдерживаемый режим поддерживается через setblocking(). Более общий подход на основе тайм-аутов поддерживается через settimeout().

18.1.2. Содержание модуля¶Module contents

Модуль socket экспортирует следующие элементы.

18.1.3. Объекты сокетов¶Socket Objects

Объекты сокетов имеют следующие методы. За исключением makefile(), они соответствуют системным вызовам Unix, применимым к сокетам.

socket.accept()¶

Принимает соединение. Сокет должен быть привязан к адресу и прослушивать соединения. Возвращаемое значение – пара (conn, address), где conn – это новый объект сокета, который можно использовать для отправки и получения данных по соединению, а address – это адрес, привязанный к сокету на другом конце соединения.

Новый созданный сокет ненаследуемый.

Изменено в версии 3.4: Сокет теперь ненаследуемый.

socket.bind(address)¶

Привязывает сокет к address. Сокет не должен быть уже привязан. (Формат address зависит от семейства адресов – см. выше.)

socket.close()¶

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

Сокеты автоматически закрываются при сборке мусора, но рекомендуется явно закрывать их с помощью close() или использовать оператор with для работы с ними.

Примечание

close() освобождает ресурс, связанный с соединением, но не обязательно закрывает соединение немедленно. Если требуется вовремя закрыть соединение, вызовите shutdown() перед close().

socket.connect(address)¶

Подключается к удалённому сокету по адресу address. (Формат address зависит от семейства адресов – см. выше.)

socket.connect_ex(address)¶

Как и connect(address), но возвращает индикатор ошибки вместо вызова исключения для ошибок, возвращаемых вызовом connect() на уровне C (другие проблемы, такие как «хост не найден», по-прежнему могут вызывать исключения). Индикатор ошибки равен 0, если операция выполнена успешно, в противном случае – значению переменной errno. Это полезно, например, для поддержки асинхронных соединений.

socket.detach()¶

Переводит объект сокета в закрытое состояние без фактического закрытия базового файлового дескриптора. Файловый дескриптор возвращается и может быть повторно использован для других целей.

Новое в версии 3.2.

socket.dup()¶

Дублирует сокет.

Новый созданный сокет ненаследуемый.

Изменено в версии 3.4: Сокет теперь ненаследуемый.

socket.fileno()¶

Возвращает файловый дескриптор сокета (небольшое целое число). Это полезно с select.select().

В Windows небольшое целое число, возвращаемое этим методом, нельзя использовать там, где может использоваться файловый дескриптор (например, в os.fdopen()). В Unix такого ограничения нет.

socket.get_inheritable()¶

Возвращает флаг наследуемости файлового дескриптора сокета или дескриптора сокета: True, если сокет может наследоваться в дочерних процессах, и False – если нет.

Новое в версии 3.4.

socket.getpeername()¶

Возвращает удалённый адрес, к которому подключён сокет. Это полезно, например, для определения номера порта удалённого сокета IPv4/v6. (Формат возвращаемого адреса зависит от семейства адресов – см. выше.) На некоторых системах эта функция не поддерживается.

socket.getsockname()¶

Возвращает собственный адрес сокета. Это полезно, например, для определения номера порта сокета IPv4/v6. (Формат возвращаемого адреса зависит от семейства адресов – см. выше.)

socket.getsockopt(level, optname[, buflen])¶

Возвращает значение указанной опции сокета (см. страницу man Unix getsockopt(2)). Необходимые символьные константы (SO_* и т.д.) определены в этом модуле. Если buflen отсутствует, предполагается целочисленная опция, и функция возвращает её целочисленное значение. Если buflen присутствует, он задает максимальную длину буфера для получения опции, и этот буфер возвращается в виде объекта bytes. Вызывающий код должен сам декодировать содержимое буфера (см. опциональный встроенный модуль struct для способа декодирования структур C, закодированных как байтовые строки).

socket.gettimeout()¶

Возвращает тайм-аут в секундах (число с плавающей точкой), связанный с операциями сокета, или None, если тайм-аут не установлен. Это значение отражает последний вызов setblocking() или settimeout().

socket.ioctl(control, option)¶

Платформа:	Windows

Метод ioctl() представляет собой ограниченный интерфейс к системному интерфейсу WSAIoctl. Для получения дополнительной информации обратитесь к документации Win32.

On other platforms, the generic fcntl.fcntl() and fcntl.ioctl() functions may be used; they accept a socket object as their first argument.

socket.listen(backlog)¶

Ожидает подключения к сокету. Аргумент backlog задаёт максимальное количество ожидающих соединений в очереди и должен быть не меньше 0; максимальное значение зависит от системы (обычно 5), минимальное принудительно устанавливается в 0.

socket.makefile(mode='r', buffering=None, *, encoding=None, errors=None, newline=None)¶

Возвращает файловый объект, связанный с сокетом. Точный возвращаемый тип зависит от аргументов, переданных в makefile(). Эти аргументы интерпретируются так же, как и встроенной функцией open().

Сокет должен быть в блокирующем режиме; можно установить тайм-аут, но при его срабатывании внутренний буфер файлового объекта может оказаться в несогласованном состоянии.

Закрытие файлового объекта, возвращённого makefile(), не закроет исходный сокет, пока не будут закрыты все остальные файловые объекты и для объекта сокета не будет вызван socket.close().

Примечание

В Windows файлоподобный объект, созданный makefile(), нельзя использовать там, где требуется файловый объект с файловым дескриптором, например в аргументах потока subprocess.Popen().

socket.recv(bufsize[, flags])¶

Получает данные из сокета. Возвращает объект bytes с полученными данными. Максимальный объём данных за одно получение задаётся параметром bufsize. Значение необязательного аргумента flags описано на странице руководства Unix recv(2); по умолчанию он равен нулю.

Примечание

Для наилучшего соответствия реальным характеристикам оборудования и сети значение bufsize должно быть относительно небольшой степенью двойки, например, 4096.

socket.recvfrom(bufsize[, flags])¶

Receive data from the socket. The return value is a pair (bytes, address) where bytes is a bytes object representing the data received and address is the address of the socket sending the data. See the Unix manual page recv(2) for the meaning of the optional argument flags; it defaults to zero. (The format of address depends on the address family – see above.)

socket.recvmsg(bufsize[, ancbufsize[, flags]])¶

Получает из сокета обычные данные (до bufsize байт) и вспомогательные данные. Аргумент ancbufsize задаёт размер внутреннего буфера для вспомогательных данных в байтах; по умолчанию равен 0, то есть вспомогательные данные не принимаются. Подходящие размеры буфера для вспомогательных данных можно вычислить с помощью CMSG_SPACE() или CMSG_LEN(); элементы, не помещающиеся в буфер, могут быть обрезаны или отброшены. Аргумент flags по умолчанию равен 0 и имеет то же значение, что и для recv().

Возвращаемое значение – кортеж из 4 элементов: (data, ancdata, msg_flags, address). Элемент data – объект bytes, содержащий принятые невспомогательные данные. Элемент ancdata – список из нуля или более кортежей (cmsg_level, cmsg_type, cmsg_data), представляющих полученные вспомогательные данные (управляющие сообщения): cmsg_level и cmsg_type – целые числа, задающие уровень протокола и тип в рамках протокола соответственно, а cmsg_data – объект bytes с соответствующими данными. Элемент msg_flags – побитовое ИЛИ различных флагов, указывающих на условия полученного сообщения; подробности смотрите в системной документации. Если принимающий сокет не подключён, address – адрес отправляющего сокета, если он доступен; в противном случае его значение не определено.

В некоторых системах sendmsg() и recvmsg() можно использовать для передачи файловых дескрипторов между процессами через сокет AF_UNIX. При использовании этой возможности (она часто ограничена сокетами SOCK_STREAM) recvmsg() вернёт во вспомогательных данных элементы вида (socket.SOL_SOCKET, socket.SCM_RIGHTS, fds), где fds – объект bytes, представляющий новые файловые дескрипторы в виде двоичного массива нативного типа C int. Если recvmsg() вызывает исключение после возврата системного вызова, она сначала попытается закрыть все файловые дескрипторы, полученные через этот механизм.

Некоторые системы не указывают усечённую длину элементов вспомогательных данных, которые были получены лишь частично. Если элемент выходит за пределы буфера, recvmsg() выдаст RuntimeWarning и вернёт ту часть, которая находится в буфере, при условии, что он не был усечён до начала своих данных.

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

import socket, array

def recv_fds(sock, msglen, maxfds):
    fds = array.array("i")   # Массив целых чисел
    msg, ancdata, flags, addr = sock.recvmsg(msglen, socket.CMSG_LEN(maxfds * fds.itemsize))
    for cmsg_level, cmsg_type, cmsg_data in ancdata:
        if (cmsg_level == socket.SOL_SOCKET and cmsg_type == socket.SCM_RIGHTS):
            # Добавить данные, игнорируя любые усечённые целые числа в конце.
            fds.fromstring(cmsg_data[:len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
    return msg, list(fds)

Доступность: большинство платформ Unix, возможно, и другие.

Новое в версии 3.3.

socket.recvmsg_into(buffers[, ancbufsize[, flags]])¶

Получает из сокета обычные и вспомогательные данные, ведя себя как recvmsg(), но разбрасывает невспомогательные данные по нескольким буферам, а не возвращает новый объект bytes. Аргумент buffers должен быть итерируемым объектом, элементы которого предоставляют буферы для записи (например, объекты bytearray); они будут заполняться последовательными частями невспомогательных данных, пока те не будут полностью записаны или не кончатся буферы. Операционная система может устанавливать ограничение (значение sysconf() SC_IOV_MAX) на количество используемых буферов. Аргументы ancbufsize и flags имеют то же значение, что и для recvmsg().

Возвращаемое значение – кортеж из 4 элементов: (nbytes, ancdata, msg_flags, address), где nbytes – общее количество байт невспомогательных данных, записанных в буферы, а ancdata, msg_flags и address такие же, как для recvmsg().

Пример:

>>> import socket
>>> s1, s2 = socket.socketpair()
>>> b1 = bytearray(b'----')
>>> b2 = bytearray(b'0123456789')
>>> b3 = bytearray(b'--------------')
>>> s1.send(b'Mary had a little lamb')
22
>>> s2.recvmsg_into([b1, memoryview(b2)[2:9], b3])
(22, [], 0, None)
>>> [b1, b2, b3]
[bytearray(b'Mary'), bytearray(b'01 had a 9'), bytearray(b'little lamb---')]

Доступность: большинство платформ Unix, возможно, и другие.

Новое в версии 3.3.

socket.recvfrom_into(buffer[, nbytes[, flags]])¶

Receive data from the socket, writing it into buffer instead of creating a new bytestring. The return value is a pair (nbytes, address) where nbytes is the number of bytes received and address is the address of the socket sending the data. See the Unix manual page recv(2) for the meaning of the optional argument flags; it defaults to zero. (The format of address depends on the address family – see above.)

socket.recv_into(buffer[, nbytes[, flags]])¶

Получает из сокета до nbytes байтов, сохраняя данные в буфер, а не создавая новую строку байтов. Если nbytes не указан (или равен 0), принимает столько байтов, сколько помещается в переданный буфер. Возвращает количество полученных байтов. Значение необязательного аргумента flags описано на странице руководства Unix recv(2); по умолчанию он равен нулю.

socket.send(bytes[, flags])¶

Отправляет данные в сокет. Сокет должен быть подключён к удалённому сокету. Необязательный аргумент flags имеет то же значение, что и для recv() выше. Возвращает количество отправленных байт. Приложения должны проверять, что все данные были отправлены; если передана только часть данных, приложению необходимо попытаться доставить остаток. Дополнительную информацию по этой теме можно найти в Socket Programming HOWTO.

socket.sendall(bytes[, flags])¶

Отправляет данные в сокет. Сокет должен быть подключён к удалённому сокету. Необязательный аргумент flags имеет то же значение, что и для recv() выше. В отличие от send(), этот метод продолжает отправлять данные из bytes, пока не будут отправлены все данные или не возникнет ошибка. В случае успеха возвращается None. При ошибке вызывается исключение, и невозможно определить, сколько данных (если вообще было) было успешно отправлено.

socket.sendto(bytes, address)¶

socket.sendto(bytes, flags, address)

Отправляет данные в сокет. Сокет не должен быть подключён к удалённому сокету, так как целевой сокет задаётся аргументом address. Необязательный аргумент flags имеет то же значение, что и для recv() выше. Возвращает количество отправленных байт. (Формат address зависит от семейства адресов – см. выше.)

socket.sendmsg(buffers[, ancdata[, flags[, address]]])¶

Отправляет в сокет обычные и вспомогательные данные, собирая невспомогательные данные из нескольких буферов и объединяя их в одно сообщение. Аргумент buffers задаёт невспомогательные данные как итерируемый объект из bytes-like объектов (например, объекты bytes); операционная система может устанавливать ограничение (значение sysconf() SC_IOV_MAX) на количество используемых буферов. Аргумент ancdata задаёт вспомогательные данные (управляющие сообщения) как итерируемый объект из нуля или более кортежей (cmsg_level, cmsg_type, cmsg_data), где cmsg_level и cmsg_type – целые числа, задающие уровень протокола и тип в рамках протокола соответственно, а cmsg_data – bytes-like объект с соответствующими данными. Обратите внимание, что некоторые системы (в частности, системы без CMSG_SPACE()) могут поддерживать отправку только одного управляющего сообщения за вызов. Аргумент flags по умолчанию равен 0 и имеет то же значение, что и для send(). Если address указан и не равен None, он задаёт адрес назначения сообщения. Возвращаемое значение – количество отправленных байт невспомогательных данных.

Следующая функция отправляет список файловых дескрипторов fds через сокет AF_UNIX в системах, поддерживающих механизм SCM_RIGHTS. См. также recvmsg().

import socket, array

def send_fds(sock, msg, fds):
    return sock.sendmsg([msg], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, array.array("i", fds))])

Доступность: большинство платформ Unix, возможно, и другие.

Новое в версии 3.3.

socket.set_inheritable(inheritable)¶

Устанавливает флаг наследования файлового дескриптора сокета или дескриптора сокета.

Новое в версии 3.4.

socket.setblocking(flag)¶

Устанавливает блокирующий или неблокирующий режим сокета: если flag равен false, сокет переводится в неблокирующий режим, иначе в блокирующий.

Этот метод является сокращением для некоторых вызовов settimeout():

• sock.setblocking(True) эквивалентно sock.settimeout(None)
• sock.setblocking(False) эквивалентно sock.settimeout(0.0)

socket.settimeout(value)¶

Устанавливает тайм-аут для блокирующих операций с сокетом. Аргумент value может быть неотрицательным числом с плавающей запятой, выражающим секунды, или None. Если задано ненулевое значение, последующие операции с сокетом будут вызывать исключение timeout, если период тайм-аута value истек до завершения операции. Если задан ноль, сокет переводится в неблокирующий режим. Если задано None, сокет переводится в блокирующий режим.

Для получения дополнительной информации обратитесь к заметкам о тайм-аутах сокетов.

socket.setsockopt(level, optname, value)¶

Устанавливает значение указанной опции сокета (см. страницу руководства Unix setsockopt(2)). Необходимые символические константы определены в модуле socket (SO_* и т.д.). Значение может быть целым числом или объектом bytes, представляющим буфер. В последнем случае вызывающий должен убедиться, что последовательность байтов содержит правильные биты (см. опциональный встроенный модуль struct для способа кодирования C-структур в виде байтовых строк).

socket.shutdown(how)¶

Завершает одну или обе половины соединения. Если how равно SHUT_RD, дальнейший приём запрещён. Если how равно SHUT_WR, дальнейшая отправка запрещена. Если how равно SHUT_RDWR, дальнейшие отправка и приём запрещены.

socket.share(process_id)¶

Дублирует сокет и подготавливает его для передачи целевому процессу. Целевой процесс должен быть указан с помощью process_id. Полученный объект bytes затем может быть передан целевому процессу с использованием какой-либо формы межпроцессного взаимодействия, и сокет может быть воссоздан там с помощью fromshare(). После вызова этого метода сокет можно безопасно закрыть, так как операционная система уже продублировала его для целевого процесса.

Доступность: Windows.

Новое в версии 3.3.

Обратите внимание, что методов read() или write() не существует; вместо них используйте recv() и send() без аргумента flags.

Объекты сокетов также имеют следующие (только для чтения) атрибуты, которые соответствуют значениям, переданным конструктору socket.

socket.family¶

Семейство сокета.

socket.type¶

Тип сокета.

socket.proto¶

Протокол сокета.

18.1.4. Замечания по тайм-аутам сокетов¶Notes on socket timeouts

Объект сокета может находиться в одном из трёх режимов: блокирующем, неблокирующем или с тайм-аутом. По умолчанию сокеты всегда создаются в блокирующем режиме, но это можно изменить, вызвав setdefaulttimeout().

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

18.1.5. Пример¶Example

Вот четыре минимальных примера программ, использующих протокол TCP/IP: сервер, который отправляет обратно все полученные данные (обслуживая только одного клиента), и клиент, использующий его. Обратите внимание, что сервер должен выполнить последовательность socket(), bind(), listen(), accept() (возможно, повторяя accept() для обслуживания более одного клиента), в то время как клиенту нужна только последовательность socket(), connect(). Также обратите внимание, что сервер не вызывает sendall()/recv() на сокете, который он прослушивает, а на новом сокете, возвращённом accept().

Первые два примера поддерживают только IPv4.

# Программа эхо-сервера
import socket

HOST = ''                 # Символическое имя, обозначающее все доступные интерфейсы
PORT = 50007              # Произвольный непривилегированный порт
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, PORT))
s.listen(1)
conn, addr = s.accept()
print('Connected by', addr)
while True:
    data = conn.recv(1024)
    if not data: break
    conn.sendall(data)
conn.close()

# Программа эхо-клиента
import socket

HOST = 'daring.cwi.nl'    # Удалённый хост
PORT = 50007              # Тот же порт, что и у сервера
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.sendall(b'Hello, world')
data = s.recv(1024)
s.close()
print('Received', repr(data))

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

# Программа эхо-сервера
import socket
import sys

HOST = None               # Символическое имя, обозначающее все доступные интерфейсы
PORT = 50007              # Произвольный непривилегированный порт
s = None
for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC,
                              socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
    af, socktype, proto, canonname, sa = res
    try:
        s = socket.socket(af, socktype, proto)
    except OSError as msg:
        s = None
        continue
    try:
        s.bind(sa)
        s.listen(1)
    except OSError as msg:
        s.close()
        s = None
        continue
    break
if s is None:
    print('could not open socket')
    sys.exit(1)
conn, addr = s.accept()
print('Connected by', addr)
while True:
    data = conn.recv(1024)
    if not data: break
    conn.send(data)
conn.close()

# Программа эхо-клиента
import socket
import sys

HOST = 'daring.cwi.nl'    # Удалённый хост
PORT = 50007              # Тот же порт, что и у сервера
s = None
for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC, socket.SOCK_STREAM):
    af, socktype, proto, canonname, sa = res
    try:
        s = socket.socket(af, socktype, proto)
    except OSError as msg:
        s = None
        continue
    try:
        s.connect(sa)
    except OSError as msg:
        s.close()
        s = None
        continue
    break
if s is None:
    print('could not open socket')
    sys.exit(1)
s.sendall(b'Hello, world')
data = s.recv(1024)
s.close()
print('Received', repr(data))

Следующий пример показывает, как написать очень простой снифер сети с помощью сырых сокетов в Windows. Для изменения интерфейса пример требует прав администратора:

import socket

# общедоступный сетевой интерфейс
HOST = socket.gethostbyname(socket.gethostname())

# создать сырой сокет и привязать его к общедоступному интерфейсу
s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP)
s.bind((HOST, 0))

# Включать IP-заголовки
s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)

# принять все пакеты
s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)

# принять пакет
print(s.recvfrom(65565))

# неразборчивый режим отключён
s.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)

Последний пример показывает, как использовать интерфейс сокетов для обмена данными с сетью CAN с помощью протокола сырых сокетов. Чтобы вместо этого использовать CAN с протоколом широковещательного менеджера, откройте сокет:

socket.socket(socket.AF_CAN, socket.SOCK_DGRAM, socket.CAN_BCM)

После привязки (CAN_RAW) или подключения (CAN_BCM) сокета вы можете использовать операции socket.send() и socket.recv() (а также их аналоги) на объекте сокета как обычно.

Для этого примера могут потребоваться особые привилегии:

import socket
import struct


# Упаковка/распаковка CAN-фреймов (см. 'struct can_frame' в <linux/can.h>)

can_frame_fmt = "=IB3x8s"
can_frame_size = struct.calcsize(can_frame_fmt)

def build_can_frame(can_id, data):
    can_dlc = len(data)
    data = data.ljust(8, b'\x00')
    return struct.pack(can_frame_fmt, can_id, can_dlc, data)

def dissect_can_frame(frame):
    can_id, can_dlc, data = struct.unpack(can_frame_fmt, frame)
    return (can_id, can_dlc, data[:can_dlc])


# создать сырой сокет и привязать его к интерфейсу 'vcan0'
s = socket.socket(socket.AF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
s.bind(('vcan0',))

while True:
    cf, addr = s.recvfrom(can_frame_size)

    print('Received: can_id=%x, can_dlc=%x, data=%s' % dissect_can_frame(cf))

    try:
        s.send(cf)
    except OSError:
        print('Error sending CAN frame')

    try:
        s.send(build_can_frame(0x01, b'\x01\x02\x03'))
    except OSError:
        print('Error sending CAN frame')

Запуск примера несколько раз со слишком маленькой задержкой между выполнениями может привести к этой ошибке:

OSError: [Errno 98] Address already in use

Это связано с тем, что предыдущее выполнение оставило сокет в состоянии TIME_WAIT, и его нельзя сразу использовать повторно.

Существует флаг socket, который можно установить, чтобы предотвратить это: socket.SO_REUSEADDR

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((HOST, PORT))

флаг SO_REUSEADDR указывает ядру повторно использовать локальный сокет в состоянии TIME_WAIT, не дожидаясь истечения его естественного тайм-аута.