Socket families¶

Depending on the system and the build options, various socket familiesare supported by this module.

The address format required by a particular socket object is automaticallyselected based on the address family specified when the socket object wascreated. Socket addresses are represented as follows:

• The address of anAF_UNIX socket bound to a file system nodeis represented as a string, using the file system encoding and the'surrogateescape' error handler (seePEP 383). An address inLinux’s abstract namespace is returned as abytes-like object withan initial null byte; note that sockets in this namespace cancommunicate with normal file system sockets, so programs intended torun on Linux may need to deal with both types of address. A string orbytes-like object can be used for either type of address whenpassing it as an argument.

  Changed in version 3.3:Previously,AF_UNIX socket paths were assumed to use UTF-8encoding.

  Changed in version 3.5:Writablebytes-like object is now accepted.

• A pair(host,port) is used for theAF_INET address family,wherehost is a string representing either a hostname in internet domainnotation like'daring.cwi.nl' or an IPv4 address like'100.50.200.5',andport is an integer.

  • For IPv4 addresses, two special forms are accepted instead of a hostaddress:'' representsINADDR_ANY, which is used to bind to allinterfaces, and the string'<broadcast>' representsINADDR_BROADCAST. This behavior is not compatible with IPv6,therefore, you may want to avoid these if you intend to support IPv6 with yourPython programs.

• ForAF_INET6 address family, a four-tuple(host,port,flowinfo,scope_id) is used, whereflowinfo andscope_id represent thesin6_flowinfoandsin6_scope_id members instructsockaddr_in6 in C. Forsocket module methods,flowinfo andscope_id can be omitted just forbackward compatibility. Note, however, omission ofscope_id can cause problemsin manipulating scoped IPv6 addresses.

  Changed in version 3.7:For multicast addresses (withscope_id meaningful)address may not contain%scope_id (orzoneid) part. This information is superfluous and maybe safely omitted (recommended).

• AF_NETLINK sockets are represented as pairs(pid,groups).

• Linux-only support for TIPC is available using theAF_TIPCaddress family. TIPC is an open, non-IP based networked protocol designedfor use in clustered computer environments. Addresses are represented by atuple, and the fields depend on the address type. The general tuple form is(addr_type,v1,v2,v3[,scope]), where:

  • addr_type is one ofTIPC_ADDR_NAMESEQ,TIPC_ADDR_NAME,orTIPC_ADDR_ID.

  • scope is one ofTIPC_ZONE_SCOPE,TIPC_CLUSTER_SCOPE, andTIPC_NODE_SCOPE.

  • Ifaddr_type isTIPC_ADDR_NAME, thenv1 is the server type,v2 isthe port identifier, andv3 should be 0.

    Ifaddr_type isTIPC_ADDR_NAMESEQ, thenv1 is the server type,v2is the lower port number, andv3 is the upper port number.

    Ifaddr_type isTIPC_ADDR_ID, thenv1 is the node,v2 is thereference, andv3 should be set to 0.

• A tuple(interface,) is used for theAF_CAN address family,whereinterface is a string representing a network interface name like'can0'. The network interface name'' can be used to receive packetsfrom all network interfaces of this family.

  • CAN_ISOTP protocol require a tuple(interface,rx_addr,tx_addr)where both additional parameters are unsigned long integer that represent aCAN identifier (standard or extended).

  • CAN_J1939 protocol require a tuple(interface,name,pgn,addr)where additional parameters are 64-bit unsigned integer representing theECU name, a 32-bit unsigned integer representing the Parameter Group Number(PGN), and an 8-bit integer representing the address.

• A string or a tuple(id,unit) is used for theSYSPROTO_CONTROLprotocol of thePF_SYSTEM family. The string is the name of akernel control using a dynamically assigned ID. The tuple can be used if IDand unit number of the kernel control are known or if a registered ID isused.

  Added in version 3.3.

• AF_BLUETOOTH supports the following protocols and addressformats:

  • BTPROTO_L2CAP accepts(bdaddr,psm) wherebdaddr isthe Bluetooth address as a string andpsm is an integer.

  • BTPROTO_RFCOMM accepts(bdaddr,channel) wherebdaddris the Bluetooth address as a string andchannel is an integer.

  • BTPROTO_HCI accepts a format that depends on your OS.

    • On Linux it accepts a tuple(device_id,) wheredevice_idis an integer specifying the number of the Bluetooth device.

    • On FreeBSD, NetBSD and DragonFly BSD it acceptsbdaddrwherebdaddr is the Bluetooth address as a string.

    Changed in version 3.2:NetBSD and DragonFlyBSD support added.

    Changed in version 3.13.3:FreeBSD support added.

  • BTPROTO_SCO acceptsbdaddr wherebdaddr isthe Bluetooth address as a string or abytes object.(ex.'12:23:34:45:56:67' orb'12:23:34:45:56:67')This protocol is not supported under FreeBSD.

• AF_ALG is a Linux-only socket based interface to Kernelcryptography. An algorithm socket is configured with a tuple of two to fourelements(type,name[,feat[,mask]]), where:

  • type is the algorithm type as string, e.g.aead,hash,skcipher orrng.

  • name is the algorithm name and operation mode as string, e.g.sha256,hmac(sha256),cbc(aes) ordrbg_nopr_ctr_aes256.

  • feat andmask are unsigned 32bit integers.

  Availability: Linux >= 2.6.38.

  Some algorithm types require more recent Kernels.

  Added in version 3.6.

• AF_VSOCK allows communication between virtual machines andtheir hosts. The sockets are represented as a(CID,port) tuplewhere the context ID or CID and port are integers.

  Availability: Linux >= 3.9

  Seevsock(7)

  Added in version 3.7.

• AF_PACKET is a low-level interface directly to network devices.The addresses are represented by the tuple(ifname,proto[,pkttype[,hatype[,addr]]]) where:

  • ifname - String specifying the device name.

  • proto - The Ethernet protocol number.May beETH_P_ALL to capture all protocols,one of theETHERTYPE_* constantsor any other Ethernet protocol number.

  • pkttype - Optional integer specifying the packet type:

    • PACKET_HOST (the default) - Packet addressed to the local host.

    • PACKET_BROADCAST - Physical-layer broadcast packet.

    • PACKET_MULTICAST - Packet sent to a physical-layer multicast address.

    • PACKET_OTHERHOST - Packet to some other host that has been caught bya device driver in promiscuous mode.

    • PACKET_OUTGOING - Packet originating from the local host that islooped back to a packet socket.

  • hatype - Optional integer specifying the ARP hardware address type.

  • addr - Optional bytes-like object specifying the hardware physicaladdress, whose interpretation depends on the device.

  Availability: Linux >= 2.2.

• AF_QIPCRTR is a Linux-only socket based interface for communicatingwith services running on co-processors in Qualcomm platforms. The addressfamily is represented as a(node,port) tuple where thenode andportare non-negative integers.

  Availability: Linux >= 4.7.

  Added in version 3.8.

• IPPROTO_UDPLITE is a variant of UDP which allows you to specifywhat portion of a packet is covered with the checksum. It adds two socketoptions that you can change.self.setsockopt(IPPROTO_UDPLITE,UDPLITE_SEND_CSCOV,length) willchange what portion of outgoing packets are covered by the checksum andself.setsockopt(IPPROTO_UDPLITE,UDPLITE_RECV_CSCOV,length) willfilter out packets which cover too little of their data. In both caseslength should be inrange(8,2**16,8).

  Such a socket should be constructed withsocket(AF_INET,SOCK_DGRAM,IPPROTO_UDPLITE) for IPv4 orsocket(AF_INET6,SOCK_DGRAM,IPPROTO_UDPLITE) for IPv6.

  Availability: Linux >= 2.6.20, FreeBSD >= 10.1

  Added in version 3.9.

• AF_HYPERV is a Windows-only socket based interface for communicatingwith Hyper-V hosts and guests. The address family is represented as a(vm_id,service_id) tuple where thevm_id andservice_id areUUID strings.

  Thevm_id is the virtual machine identifier or a set of known VMID valuesif the target is not a specific virtual machine. Known VMID constantsdefined onsocket are:

  • HV_GUID_ZERO

  • HV_GUID_BROADCAST

  • HV_GUID_WILDCARD - Used to bind on itself and accept connections fromall partitions.

  • HV_GUID_CHILDREN - Used to bind on itself and accept connection fromchild partitions.

  • HV_GUID_LOOPBACK - Used as a target to itself.

  • HV_GUID_PARENT - When used as a bind accepts connection from the parentpartition. When used as an address target it will connect to the parent partition.

  Theservice_id is the service identifier of the registered service.

  Added in version 3.12.

If you use a hostname in thehost portion of IPv4/v6 socket address, theprogram may show a nondeterministic behavior, as Python uses the first addressreturned from the DNS resolution. The socket address will be resolveddifferently into an actual IPv4/v6 address, depending on the results from DNSresolution and/or the host configuration. For deterministic behavior use anumeric address inhost portion.

All errors raise exceptions. The normal exceptions for invalid argument typesand out-of-memory conditions can be raised. Errorsrelated to socket or address semantics raiseOSError or one of itssubclasses.

Non-blocking mode is supported throughsetblocking(). Ageneralization of this based on timeouts is supported throughsettimeout().

Module contents¶

The modulesocket exports the following elements.

Socket Objects¶

Socket objects have the following methods. Except formakefile(), these correspond to Unix system calls applicableto sockets.

socket.accept()¶

Accept a connection. The socket must be bound to an address and listening forconnections. The return value is a pair(conn,address) whereconn is anew socket object usable to send and receive data on the connection, andaddress is the address bound to the socket on the other end of the connection.

The newly created socket isnon-inheritable.

Changed in version 3.4:The socket is now non-inheritable.

Changed in version 3.5:If the system call is interrupted and the signal handler does not raisean exception, the method now retries the system call instead of raisinganInterruptedError exception (seePEP 475 for the rationale).

socket.bind(address)¶

Bind the socket toaddress. The socket must not already be bound. (The formatofaddress depends on the address family — see above.)

Raises anauditing eventsocket.bind with argumentsself,address.

Availability: not WASI.

socket.close()¶

Mark the socket closed. The underlying system resource (e.g. a filedescriptor) is also closed when all file objects frommakefile()are closed. Once that happens, all future operations on the socketobject will fail. The remote end will receive no more data (afterqueued data is flushed).

Sockets are automatically closed when they are garbage-collected, butit is recommended toclose() them explicitly, or to use awith statement around them.

Changed in version 3.6:OSError is now raised if an error occurs when the underlyingclose() call is made.

Note

close() releases the resource associated with a connection butdoes not necessarily close the connection immediately. If you wantto close the connection in a timely fashion, callshutdown()beforeclose().

socket.connect(address)¶

Connect to a remote socket ataddress. (The format ofaddress depends on theaddress family — see above.)

If the connection is interrupted by a signal, the method waits until theconnection completes, or raise aTimeoutError on timeout, if thesignal handler doesn’t raise an exception and the socket is blocking or hasa timeout. For non-blocking sockets, the method raises anInterruptedError exception if the connection is interrupted by asignal (or the exception raised by the signal handler).

Raises anauditing eventsocket.connect with argumentsself,address.

Changed in version 3.5:The method now waits until the connection completes instead of raising anInterruptedError exception if the connection is interrupted by asignal, the signal handler doesn’t raise an exception and the socket isblocking or has a timeout (see thePEP 475 for the rationale).

Availability: not WASI.

socket.connect_ex(address)¶

Likeconnect(address), but return an error indicator instead of raising anexception for errors returned by the C-levelconnect() call (otherproblems, such as “host not found,” can still raise exceptions). The errorindicator is0 if the operation succeeded, otherwise the value of theerrno variable. This is useful to support, for example, asynchronousconnects.

Raises anauditing eventsocket.connect with argumentsself,address.

Availability: not WASI.

socket.detach()¶

Put the socket object into closed state without actually closing theunderlying file descriptor. The file descriptor is returned, and canbe reused for other purposes.

Added in version 3.2.

socket.dup()¶

Duplicate the socket.

The newly created socket isnon-inheritable.

Changed in version 3.4:The socket is now non-inheritable.

Availability: not WASI.

socket.fileno()¶

Return the socket’s file descriptor (a small integer), or -1 on failure. Thisis useful withselect.select().

Under Windows the small integer returned by this method cannot be used where afile descriptor can be used (such asos.fdopen()). Unix does not havethis limitation.

socket.get_inheritable()¶

Get theinheritable flag of the socket’s filedescriptor or socket’s handle:True if the socket can be inherited inchild processes,False if it cannot.

Added in version 3.4.

socket.getpeername()¶

Return the remote address to which the socket is connected. This is useful tofind out the port number of a remote IPv4/v6 socket, for instance. (The formatof the address returned depends on the address family — see above.) On somesystems this function is not supported.

socket.getsockname()¶

Return the socket’s own address. This is useful to find out the port number ofan IPv4/v6 socket, for instance. (The format of the address returned depends onthe address family — see above.)

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

Return the value of the given socket option (see the Unix man pagegetsockopt(2)). The needed symbolic constants (SO_* etc.)are defined in this module. Ifbuflen is absent, an integer option is assumedand its integer value is returned by the function. Ifbuflen is present, itspecifies the maximum length of the buffer used to receive the option in, andthis buffer is returned as a bytes object. It is up to the caller to decode thecontents of the buffer (see the optional built-in modulestruct for a wayto decode C structures encoded as byte strings).

Availability: not WASI.

socket.getblocking()¶

ReturnTrue if socket is in blocking mode,False if innon-blocking.

This is equivalent to checkingsocket.gettimeout()!=0.

Added in version 3.7.

socket.gettimeout()¶

Return the timeout in seconds (float) associated with socket operations,orNone if no timeout is set. This reflects the last call tosetblocking() orsettimeout().

socket.ioctl(control,option)¶

Platform:

Windows

Theioctl() method is a limited interface to the WSAIoctl systeminterface. Please refer to theWin32 documentation for moreinformation.

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

Currently only the following control codes are supported:SIO_RCVALL,SIO_KEEPALIVE_VALS, andSIO_LOOPBACK_FAST_PATH.

Changed in version 3.6:SIO_LOOPBACK_FAST_PATH was added.

socket.listen([backlog])¶

Enable a server to accept connections. Ifbacklog is specified, it mustbe at least 0 (if it is lower, it is set to 0); it specifies the number ofunaccepted connections that the system will allow before refusing newconnections. If not specified, a default reasonable value is chosen.

Availability: not WASI.

Changed in version 3.5:Thebacklog parameter is now optional.

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

Return afile object associated with the socket. The exact returnedtype depends on the arguments given tomakefile(). These arguments areinterpreted the same way as by the built-inopen() function, exceptthe only supportedmode values are'r' (default),'w','b', ora combination of those.

The socket must be in blocking mode; it can have a timeout, but the fileobject’s internal buffer may end up in an inconsistent state if a timeoutoccurs.

Closing the file object returned bymakefile() won’t close theoriginal socket unless all other file objects have been closed andsocket.close() has been called on the socket object.

Note

On Windows, the file-like object created bymakefile() cannot beused where a file object with a file descriptor is expected, such as thestream arguments ofsubprocess.Popen().

socket.recv(bufsize[,flags])¶

Receive data from the socket. The return value is a bytes object representing thedata received. The maximum amount of data to be received at once is specifiedbybufsize. A returned empty bytes object indicates that the client has disconnected.See the Unix manual pagerecv(2) for the meaning of the optional argumentflags; it defaults to zero.

Changed in version 3.5:If the system call is interrupted and the signal handler does not raisean exception, the method now retries the system call instead of raisinganInterruptedError exception (seePEP 475 for the rationale).

socket.recvfrom(bufsize[,flags])¶

Receive data from the socket. The return value is a pair(bytes,address)wherebytes is a bytes object representing the data received andaddress is theaddress of the socket sending the data. See the Unix manual pagerecv(2) for the meaning of the optional argumentflags; it defaultsto zero. (The format ofaddress depends on the address family — see above.)

Changed in version 3.5:If the system call is interrupted and the signal handler does not raisean exception, the method now retries the system call instead of raisinganInterruptedError exception (seePEP 475 for the rationale).

Changed in version 3.7:For multicast IPv6 address, first item ofaddress does not contain%scope_id part anymore. In order to get full IPv6 address usegetnameinfo().

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

Receive normal data (up tobufsize bytes) and ancillary data fromthe socket. Theancbufsize argument sets the size in bytes ofthe internal buffer used to receive the ancillary data; it defaultsto 0, meaning that no ancillary data will be received. Appropriatebuffer sizes for ancillary data can be calculated usingCMSG_SPACE() orCMSG_LEN(), and items which do not fitinto the buffer might be truncated or discarded. Theflagsargument defaults to 0 and has the same meaning as forrecv().

The return value is a 4-tuple:(data,ancdata,msg_flags,address). Thedata item is abytes object holding thenon-ancillary data received. Theancdata item is a list of zeroor more tuples(cmsg_level,cmsg_type,cmsg_data) representingthe ancillary data (control messages) received:cmsg_level andcmsg_type are integers specifying the protocol level andprotocol-specific type respectively, andcmsg_data is abytes object holding the associated data. Themsg_flagsitem is the bitwise OR of various flags indicating conditions onthe received message; see your system documentation for details.If the receiving socket is unconnected,address is the address ofthe sending socket, if available; otherwise, its value isunspecified.

On some systems,sendmsg() andrecvmsg() can be used topass file descriptors between processes over anAF_UNIXsocket. When this facility is used (it is often restricted toSOCK_STREAM sockets),recvmsg() will return, in itsancillary data, items of the form(socket.SOL_SOCKET,socket.SCM_RIGHTS,fds), wherefds is abytes objectrepresenting the new file descriptors as a binary array of thenative Cint type. Ifrecvmsg() raises anexception after the system call returns, it will first attempt toclose any file descriptors received via this mechanism.

Some systems do not indicate the truncated length of ancillary dataitems which have been only partially received. If an item appearsto extend beyond the end of the buffer,recvmsg() will issueaRuntimeWarning, and will return the part of it which isinside the buffer provided it has not been truncated before thestart of its associated data.

On systems which support theSCM_RIGHTS mechanism, thefollowing function will receive up tomaxfds file descriptors,returning the message data and a list containing the descriptors(while ignoring unexpected conditions such as unrelated controlmessages being received). See alsosendmsg().

importsocket,arraydefrecv_fds(sock,msglen,maxfds):fds=array.array("i")# Array of intsmsg,ancdata,flags,addr=sock.recvmsg(msglen,socket.CMSG_LEN(maxfds*fds.itemsize))forcmsg_level,cmsg_type,cmsg_datainancdata:ifcmsg_level==socket.SOL_SOCKETandcmsg_type==socket.SCM_RIGHTS:# Append data, ignoring any truncated integers at the end.fds.frombytes(cmsg_data[:len(cmsg_data)-(len(cmsg_data)%fds.itemsize)])returnmsg,list(fds)

Availability: Unix.

Most Unix platforms.

Added in version 3.3.

Changed in version 3.5:If the system call is interrupted and the signal handler does not raisean exception, the method now retries the system call instead of raisinganInterruptedError exception (seePEP 475 for the rationale).

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

Receive normal data and ancillary data from the socket, behaving asrecvmsg() would, but scatter the non-ancillary data into aseries of buffers instead of returning a new bytes object. Thebuffers argument must be an iterable of objects that exportwritable buffers (e.g.bytearray objects); these will befilled with successive chunks of the non-ancillary data until ithas all been written or there are no more buffers. The operatingsystem may set a limit (sysconf() valueSC_IOV_MAX)on the number of buffers that can be used. Theancbufsize andflags arguments have the same meaning as forrecvmsg().

The return value is a 4-tuple:(nbytes,ancdata,msg_flags,address), wherenbytes is the total number of bytes ofnon-ancillary data written into the buffers, andancdata,msg_flags andaddress are the same as forrecvmsg().

Example:

>>>importsocket>>>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---')]

Availability: Unix.

Most Unix platforms.

Added in version 3.3.

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

Receive data from the socket, writing it intobuffer instead of creating anew bytestring. The return value is a pair(nbytes,address) wherenbytes isthe number of bytes received andaddress is the address of the socket sendingthe data. See the Unix manual pagerecv(2) for the meaning of theoptional argumentflags; it defaults to zero. (The format ofaddressdepends on the address family — see above.)

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

Receive up tonbytes bytes from the socket, storing the data into a bufferrather than creating a new bytestring. Ifnbytes is not specified (or 0),receive up to the size available in the given buffer. Returns the number ofbytes received. See the Unix manual pagerecv(2) for the meaningof the optional argumentflags; it defaults to zero.

socket.send(bytes[,flags])¶

Send data to the socket. The socket must be connected to a remote socket. Theoptionalflags argument has the same meaning as forrecv() above.Returns the number of bytes sent. Applications are responsible for checking thatall data has been sent; if only some of the data was transmitted, theapplication needs to attempt delivery of the remaining data. For furtherinformation on this topic, consult theSocket Programming HOWTO.

Changed in version 3.5:If the system call is interrupted and the signal handler does not raisean exception, the method now retries the system call instead of raisinganInterruptedError exception (seePEP 475 for the rationale).

socket.sendall(bytes[,flags])¶

Send data to the socket. The socket must be connected to a remote socket. Theoptionalflags argument has the same meaning as forrecv() above.Unlikesend(), this method continues to send data frombytes untileither all data has been sent or an error occurs.None is returned onsuccess. On error, an exception is raised, and there is no way to determine howmuch data, if any, was successfully sent.

Changed in version 3.5:The socket timeout is no longer reset each time data is sent successfully.The socket timeout is now the maximum total duration to send all data.

Changed in version 3.5:If the system call is interrupted and the signal handler does not raisean exception, the method now retries the system call instead of raisinganInterruptedError exception (seePEP 475 for the rationale).

socket.sendto(bytes,address)¶

socket.sendto(bytes,flags,address)

Send data to the socket. The socket should not be connected to a remote socket,since the destination socket is specified byaddress. The optionalflagsargument has the same meaning as forrecv() above. Return the number ofbytes sent. (The format ofaddress depends on the address family — seeabove.)

Raises anauditing eventsocket.sendto with argumentsself,address.

Changed in version 3.5:If the system call is interrupted and the signal handler does not raisean exception, the method now retries the system call instead of raisinganInterruptedError exception (seePEP 475 for the rationale).

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

Send normal and ancillary data to the socket, gathering thenon-ancillary data from a series of buffers and concatenating itinto a single message. Thebuffers argument specifies thenon-ancillary data as an iterable ofbytes-like objects(e.g.bytes objects); the operating system may set a limit(sysconf() valueSC_IOV_MAX) on the number of buffersthat can be used. Theancdata argument specifies the ancillarydata (control messages) as an iterable of zero or more tuples(cmsg_level,cmsg_type,cmsg_data), wherecmsg_level andcmsg_type are integers specifying the protocol level andprotocol-specific type respectively, andcmsg_data is abytes-like object holding the associated data. Note thatsome systems (in particular, systems withoutCMSG_SPACE())might support sending only one control message per call. Theflags argument defaults to 0 and has the same meaning as forsend(). Ifaddress is supplied and notNone, it sets adestination address for the message. The return value is thenumber of bytes of non-ancillary data sent.

The following function sends the list of file descriptorsfdsover anAF_UNIX socket, on systems which support theSCM_RIGHTS mechanism. See alsorecvmsg().

importsocket,arraydefsend_fds(sock,msg,fds):returnsock.sendmsg([msg],[(socket.SOL_SOCKET,socket.SCM_RIGHTS,array.array("i",fds))])

Availability: Unix, not WASI.

Most Unix platforms.

Raises anauditing eventsocket.sendmsg with argumentsself,address.

Added in version 3.3.

Changed in version 3.5:If the system call is interrupted and the signal handler does not raisean exception, the method now retries the system call instead of raisinganInterruptedError exception (seePEP 475 for the rationale).

socket.sendmsg_afalg([msg,]*,op[,iv[,assoclen[,flags]]])¶

Specialized version ofsendmsg() forAF_ALG socket.Set mode, IV, AEAD associated data length and flags forAF_ALG socket.

Availability: Linux >= 2.6.38.

Added in version 3.6.

socket.sendfile(file,offset=0,count=None)¶

Send a file until EOF is reached by using high-performanceos.sendfile and return the total number of bytes which were sent.file must be a regular file object opened in binary mode. Ifos.sendfile is not available (e.g. Windows) orfile is not aregular filesend() will be used instead.offset tells from where tostart reading the file. If specified,count is the total number of bytesto transmit as opposed to sending the file until EOF is reached. Fileposition is updated on return or also in case of error in which casefile.tell() can be used to figure out the number ofbytes which were sent. The socket must be ofSOCK_STREAM type.Non-blocking sockets are not supported.

Added in version 3.5.

socket.set_inheritable(inheritable)¶

Set theinheritable flag of the socket’s filedescriptor or socket’s handle.

Added in version 3.4.

socket.setblocking(flag)¶

Set blocking or non-blocking mode of the socket: ifflag is false, thesocket is set to non-blocking, else to blocking mode.

This method is a shorthand for certainsettimeout() calls:

• sock.setblocking(True) is equivalent tosock.settimeout(None)

• sock.setblocking(False) is equivalent tosock.settimeout(0.0)

Changed in version 3.7:The method no longer appliesSOCK_NONBLOCK flag onsocket.type.

socket.settimeout(value)¶

Set a timeout on blocking socket operations. Thevalue argument can be anonnegative floating-point number expressing seconds, orNone.If a non-zero value is given, subsequent socket operations will raise atimeout exception if the timeout periodvalue has elapsed beforethe operation has completed. If zero is given, the socket is put innon-blocking mode. IfNone is given, the socket is put in blocking mode.

For further information, please consult thenotes on socket timeouts.

Changed in version 3.7:The method no longer togglesSOCK_NONBLOCK flag onsocket.type.

socket.setsockopt(level,optname,value:int)¶

socket.setsockopt(level,optname,value:buffer)

socket.setsockopt(level,optname,None,optlen:int)

Set the value of the given socket option (see the Unix manual pagesetsockopt(2)). The needed symbolic constants are defined in thismodule (SO_* etc. <socket-unix-constants>). The value can be an integer,None or abytes-like object representing a buffer. In the latercase it is up to the caller to ensure that the bytestring contains theproper bits (see the optional built-in modulestruct for a way toencode C structures as bytestrings). Whenvalue is set toNone,optlen argument is required. It’s equivalent to callsetsockopt() Cfunction withoptval=NULL andoptlen=optlen.

Changed in version 3.5:Writablebytes-like object is now accepted.

Changed in version 3.6:setsockopt(level, optname, None, optlen: int) form added.

Availability: not WASI.

socket.shutdown(how)¶

Shut down one or both halves of the connection. Ifhow isSHUT_RD,further receives are disallowed. Ifhow isSHUT_WR, further sendsare disallowed. Ifhow isSHUT_RDWR, further sends and receives aredisallowed.

Availability: not WASI.

socket.share(process_id)¶

Duplicate a socket and prepare it for sharing with a target process. Thetarget process must be provided withprocess_id. The resulting bytes objectcan then be passed to the target process using some form of interprocesscommunication and the socket can be recreated there usingfromshare().Once this method has been called, it is safe to close the socket sincethe operating system has already duplicated it for the target process.

Availability: Windows.

Added in version 3.3.

Note that there are no methodsread() orwrite(); userecv() andsend() withoutflags argument instead.

Socket objects also have these (read-only) attributes that correspond to thevalues given to thesocket constructor.

socket.family¶

The socket family.

socket.type¶

The socket type.

socket.proto¶

The socket protocol.

Notes on socket timeouts¶

A socket object can be in one of three modes: blocking, non-blocking, ortimeout. Sockets are by default always created in blocking mode, but thiscan be changed by callingsetdefaulttimeout().

• Inblocking mode, operations block until complete or the system returnsan error (such as connection timed out).

• Innon-blocking mode, operations fail (with an error that is unfortunatelysystem-dependent) if they cannot be completed immediately: functions from theselect module can be used to know when and whether a socket is availablefor reading or writing.

• Intimeout mode, operations fail if they cannot be completed within thetimeout specified for the socket (they raise atimeout exception)or if the system returns an error.

Example¶

Here are four minimal example programs using the TCP/IP protocol: a server thatechoes all data that it receives back (servicing only one client), and a clientusing it. Note that a server must perform the sequencesocket(),bind(),listen(),accept() (possiblyrepeating theaccept() to service more than one client), while aclient only needs the sequencesocket(),connect(). Alsonote that the server does notsendall()/recv() onthe socket it is listening on but on the new socket returned byaccept().

The first two examples support IPv4 only.

# Echo server programimportsocketHOST=''# Symbolic name meaning all available interfacesPORT=50007# Arbitrary non-privileged portwithsocket.socket(socket.AF_INET,socket.SOCK_STREAM)ass:s.bind((HOST,PORT))s.listen(1)conn,addr=s.accept()withconn:print('Connected by',addr)whileTrue:data=conn.recv(1024)ifnotdata:breakconn.sendall(data)

# Echo client programimportsocketHOST='daring.cwi.nl'# The remote hostPORT=50007# The same port as used by the serverwithsocket.socket(socket.AF_INET,socket.SOCK_STREAM)ass:s.connect((HOST,PORT))s.sendall(b'Hello, world')data=s.recv(1024)print('Received',repr(data))

The next two examples are identical to the above two, but support both IPv4 andIPv6. The server side will listen to the first address family available (itshould listen to both instead). On most of IPv6-ready systems, IPv6 will takeprecedence and the server may not accept IPv4 traffic. The client side will tryto connect to all the addresses returned as a result of the name resolution, andsends traffic to the first one connected successfully.

# Echo server programimportsocketimportsysHOST=None# Symbolic name meaning all available interfacesPORT=50007# Arbitrary non-privileged ports=Noneforresinsocket.getaddrinfo(HOST,PORT,socket.AF_UNSPEC,socket.SOCK_STREAM,0,socket.AI_PASSIVE):af,socktype,proto,canonname,sa=restry:s=socket.socket(af,socktype,proto)exceptOSErrorasmsg:s=Nonecontinuetry:s.bind(sa)s.listen(1)exceptOSErrorasmsg:s.close()s=NonecontinuebreakifsisNone:print('could not open socket')sys.exit(1)conn,addr=s.accept()withconn:print('Connected by',addr)whileTrue:data=conn.recv(1024)ifnotdata:breakconn.send(data)

# Echo client programimportsocketimportsysHOST='daring.cwi.nl'# The remote hostPORT=50007# The same port as used by the servers=Noneforresinsocket.getaddrinfo(HOST,PORT,socket.AF_UNSPEC,socket.SOCK_STREAM):af,socktype,proto,canonname,sa=restry:s=socket.socket(af,socktype,proto)exceptOSErrorasmsg:s=Nonecontinuetry:s.connect(sa)exceptOSErrorasmsg:s.close()s=NonecontinuebreakifsisNone:print('could not open socket')sys.exit(1)withs:s.sendall(b'Hello, world')data=s.recv(1024)print('Received',repr(data))

The next example shows how to write a very simple network sniffer with rawsockets on Windows. The example requires administrator privileges to modifythe interface:

importsocket# the public network interfaceHOST=socket.gethostbyname(socket.gethostname())# create a raw socket and bind it to the public interfaces=socket.socket(socket.AF_INET,socket.SOCK_RAW,socket.IPPROTO_IP)s.bind((HOST,0))# Include IP headerss.setsockopt(socket.IPPROTO_IP,socket.IP_HDRINCL,1)# receive all packetss.ioctl(socket.SIO_RCVALL,socket.RCVALL_ON)# receive a packetprint(s.recvfrom(65565))# disabled promiscuous modes.ioctl(socket.SIO_RCVALL,socket.RCVALL_OFF)

The next example shows how to use the socket interface to communicate to a CANnetwork using the raw socket protocol. To use CAN with the broadcastmanager protocol instead, open a socket with:

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

After binding (CAN_RAW) or connecting (CAN_BCM) the socket, youcan use thesocket.send() andsocket.recv() operations (andtheir counterparts) on the socket object as usual.

This last example might require special privileges:

importsocketimportstruct# CAN frame packing/unpacking (see 'struct can_frame' in <linux/can.h>)can_frame_fmt="=IB3x8s"can_frame_size=struct.calcsize(can_frame_fmt)defbuild_can_frame(can_id,data):can_dlc=len(data)data=data.ljust(8,b'\x00')returnstruct.pack(can_frame_fmt,can_id,can_dlc,data)defdissect_can_frame(frame):can_id,can_dlc,data=struct.unpack(can_frame_fmt,frame)return(can_id,can_dlc,data[:can_dlc])# create a raw socket and bind it to the 'vcan0' interfaces=socket.socket(socket.AF_CAN,socket.SOCK_RAW,socket.CAN_RAW)s.bind(('vcan0',))whileTrue: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)exceptOSError:print('Error sending CAN frame')try:s.send(build_can_frame(0x01,b'\x01\x02\x03'))exceptOSError:print('Error sending CAN frame')

Running an example several times with too small delay between executions, couldlead to this error:

OSError:[Errno98]Addressalreadyinuse

This is because the previous execution has left the socket in aTIME_WAITstate, and can’t be immediately reused.

There is asocket flag to set, in order to prevent this,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))

theSO_REUSEADDR flag tells the kernel to reuse a local socket inTIME_WAIT state, without waiting for its natural timeout to expire.