/usr/lib/python3/dist-packages/twisted/pair/__pycache__
Edit: /usr/lib/python3/dist-packages/twisted/pair/__pycache__/tuntap.cpython-310.pyc (13350B)
o
b0 @ sl d Z ddlZddlZddlZddlZddlZddlmZ ddlm Z ddl
m Z m Z m
Z
ddlmZmZ ddlmZ ddlmZmZmZmZmZ dd lmZmZ dd
l m Z dd l m Z dd l m!Z! dd
l"m#Z#m$Z$ g dZ%dZ&dZ'dZ(dZ)G dd deZ*e
ej+G dd de$e#Z,G dd deddZ-G dd de Z.G d d d Z/e
ej0G d d d ej1Z2dS ) zc
Support for Linux ethernet and IP tunnel devices.
@see: U{https://en.wikipedia.org/wiki/TUN/TAP}
N)
namedtuple)Tuple) Attribute Interface implementer) FlagConstantFlags)Version)abstractdefererror
interfacestask)ethernetraw)log)
deprecated)fullyQualifiedName) FancyEqMixin
FancyStrMixin) TunnelFlags
TunnelAddress
TuntapPort iT@l T s /dev/net/tunc @ sp e Zd ZdZedZedZedZedZedZ edZ
edZ ed Z ed
Z
ed Zed Zed
ZdS )r a~
L{TunnelFlags} defines more flags which are used to configure the behavior
of a tunnel device.
@cvar IFF_TUN: This indicates a I{tun}-type device. This type of tunnel
carries IP datagrams. This flag is mutually exclusive with C{IFF_TAP}.
@cvar IFF_TAP: This indicates a I{tap}-type device. This type of tunnel
carries ethernet frames. This flag is mutually exclusive with C{IFF_TUN}.
@cvar IFF_NO_PI: This indicates the I{protocol information} header will
B{not} be included in data read from the tunnel.
@see: U{https://www.kernel.org/doc/Documentation/networking/tuntap.txt}
r @ i i i @ i N)__name__
__module__ __qualname____doc__r IFF_TUNIFF_TAP
TUN_FASYNCTUN_NOCHECKSUM TUN_NO_PI
TUN_ONE_QUEUE TUN_PERSIST TUN_VNET_HDR IFF_NO_PI
IFF_ONE_QUEUE IFF_VNET_HDR IFF_TUN_EXCL r1 r1 5/usr/lib/python3/dist-packages/twisted/pair/tuntap.pyr , s r c @ s@ e Zd ZdZdZddd fdfZedd Zd d
Zd d Z d
S )r zU
A L{TunnelAddress} represents the tunnel to which a L{TuntapPort} is bound.
)
_typeValuenametypec C | j S N)r4 )flagr1 r1 r2
T s zTunnelAddress.r4 c C s | j jS )z
Return the integer value of the C{type} attribute. Used to produce
correct results in the equality implementation.
)r5 valueselfr1 r1 r2 r3 V s zTunnelAddress._typeValuec C s || _ || _dS )z
@param type: Either L{TunnelFlags.IFF_TUN} or L{TunnelFlags.IFF_TAP},
representing the type of this tunnel.
@param name: The system name of the tunnel.
@type name: L{bytes}
N)r5 r4 )r< r5 r4 r1 r1 r2 __init___ s
zTunnelAddress.__init__c C s t jdtdd d| jf| S )zS
Deprecated accessor for the tunnel name. Use attributes instead.
zUTunnelAddress.__getitem__ is deprecated since Twisted 14.0.0 Use attributes instead.r )category
stacklevelTUNTAP)warningswarnDeprecationWarningr4 )r< indexr1 r1 r2 __getitem__j s zTunnelAddress.__getitem__N)
r! r" r# r$ compareAttributesshowAttributespropertyr3 r= rE r1 r1 r1 r2 r M s
r c @ s e Zd ZdZdS )_TunnelDescriptionz
Describe an existing tunnel.
@ivar fileno: the file descriptor associated with the tunnel
@type fileno: L{int}
@ivar name: the name of the tunnel
@type name: L{bytes}
N)r! r" r# r$ r1 r1 r1 r2 rI w s rI z fileno namec @ sd e Zd ZdZedZedZedZdddZdd d
Z d d Z
d
d Z dd Z dd Z
dd ZdS )_IInputOutputSystemz
An interface for performing some basic kinds of I/O (particularly that I/O
which might be useful for L{twisted.pair.tuntap}-using code).
z@see: L{os.O_RDWR}z@see: L{os.O_NONBLOCK}z@see: L{os.O_CLOEXEC} c C dS )z"
@see: L{os.open}
Nr1 )filenamer8 moder1 r1 r2 open z_IInputOutputSystem.openNc C rL )z&
@see: L{fcntl.ioctl}
Nr1 )fdoptarg mutate_flagr1 r1 r2 ioctl rP z_IInputOutputSystem.ioctlc C rL )z"
@see: L{os.read}
Nr1 )rQ limitr1 r1 r2 read rP z_IInputOutputSystem.readc C rL )z#
@see: L{os.write}
Nr1 )rQ datar1 r1 r2 write rP z_IInputOutputSystem.writec C rL )z#
@see: L{os.close}
Nr1 )rQ r1 r1 r2 close rP z_IInputOutputSystem.closec C rL )a
Send a datagram to a certain address.
@param datagram: The payload of a UDP datagram to send.
@type datagram: L{bytes}
@param address: The destination to which to send the datagram.
@type address: L{tuple} of (L{bytes}, L{int})
@return: The local address from which the datagram was sent.
@rtype: L{tuple} of (L{bytes}, L{int})
Nr1 )datagramaddressr1 r1 r2 sendUDP rP z_IInputOutputSystem.sendUDPc C rL )af
Return a socket which can be used to receive datagrams sent to the
given address.
@param fileno: A file descriptor representing a tunnel device which the
datagram was either sent via or will be received via.
@type fileno: L{int}
@param host: The IPv4 address at which the datagram will be received.
@type host: L{bytes}
@param port: The UDP port number at which the datagram will be
received.
@type port: L{int}
@return: A L{socket.socket} which can be used to receive the specified
datagram.
Nr1 )filenohostportr1 r1 r2
receiveUDP rP z _IInputOutputSystem.receiveUDP)rK )NN)r! r" r# r$ r O_RDWR
O_NONBLOCK O_CLOEXECrO rU rW rY rZ r] ra r1 r1 r1 r2 rJ s
rJ c @ sZ e Zd ZdZeejZeejZeejZeej Z ee
j Z ej Z ej
Z
eeddZdS ) _RealSystemz
An interface to the parts of the operating system which L{TuntapPort}
relies on. This is most of an implementation of L{_IInputOutputSystem}.
rd i N)r! r" r# r$ staticmethodosrO rW rY rZ fcntlrU rb rc getattrrd r1 r1 r1 r2 re s
re c @ s e Zd ZdZdZd%ddZdefdd Zd
d Zd d
Z dd Z
dd Z dd Z dd Z
dd Zdd Zeeddd d ed d Zd&d d Zd!d" Zd#d$ ZdS )'r zH
A Port that reads and writes packets from/to a TUN/TAP-device.
i r Nc C s t j|rd| _ tj| _nd| _ tj| _tj|s J |d u r$t }|| _
t j
| | || _|| _|| _| | j}| d| jj d| _d S )Nr r z ())r IEthernetProtocol
providedByr r& _moder% r IRawPacketProtocolre _systemr
FileDescriptorr= interfaceprotocol
maxPacketSize
_getLogPrefixr4 logstr)r< rq protors reactorsystem logPrefixr1 r1 r2 r= s
zTuntapPort.__init__returnc C s@ t | jjf}| jr|d }n|d }|| jj| jf }d| S )N) )znot z<%s %slistening on %s/%s>)r rr __class__ connectedrm r4 rq )r< argsr1 r1 r2 __repr__ s
zTuntapPort.__repr__c C s | | j| | dS )z
Create and bind my socket, and begin listening on it.
This must be called after creating a server to begin listening on the
specified tunnel.
N) _bindSocketrr makeConnection startReadingr; r1 r1 r2 startListening s zTuntapPort.startListeningc C sd | j j| j jB | j jB }tdtf ||j}| j t |}| j
|t |}t ||dt
dS )af
Open the named tunnel using the given mode.
@param name: The name of the tunnel to open.
@type name: L{bytes}
@param mode: Flags from L{TunnelFlags} with exactly one of
L{TunnelFlags.IFF_TUN} or L{TunnelFlags.IFF_TAP} set.
@return: A L{_TunnelDescription} representing the newly opened tunnel.
z%dsHN )ro rb rd rc structpack _IFNAMSIZr: rO _TUN_KO_PATHrU
_TUNSETIFFrI strip)r< r4 rN flagsconfigr^ resultr1 r1 r2 _openTunnel
s
zTuntapPort._openTunnelc
C st t jd| jj| jd z| | j| jtjB \}}W n t y. } zt
d| j|d}~ww || _|| _ d| _
dS )z"
Open the tunnel.
z&%(protocol)s starting on %(interface)s)formatrr rq Nr )r msgrr r| rq r rm r r- OSErrorr CannotListenError_filenor} )r< r^ rq er1 r1 r2 r s
zTuntapPort._bindSocketc C r6 r7 )r r; r1 r1 r2 r^ 4 s zTuntapPort.filenoc
C s d}|| j k rjz | j| j| j}W n& ty1 } z|jtjtjtj fv r,W Y d}~dS d}~w t
y8 w |t |7 }z
| j j
|dd W n t
yb t| j j}tdd| d Y nw || j k sdS dS )z=
Called when my socket is ready for reading.
r N)partialzUnhandled exception from z.datagramReceived)
maxThroughputro rW r rs r errno EWOULDBLOCKEAGAINEINTR
BaseExceptionlenrr datagramReceivedr r| r err)r< rW rX r clsr1 r1 r2 doRead7 s(
zTuntapPort.doReadc
C sP z | j | j|W S ty' } z|jtjkr"| |W Y d}~S d}~ww )z
Write the given data as a single datagram.
@param datagram: The data that will make up the complete datagram to be
written.
@type datagram: L{bytes}
N)ro rY r r r r )r< r[ r r1 r1 r2 rY N s zTuntapPort.writec C s | d| dS )z
Write a datagram constructed from a L{list} of L{bytes}.
@param seq: The data that will make up the complete datagram to be
written.
@type seq: L{list} of L{bytes}
N)rY join)r< seqr1 r1 r2
writeSequence] s zTuntapPort.writeSequencec C sD | | jr
| jS | jr t| jd| j| _d| _| jS t dS )z
Stop accepting connections on this port.
This will shut down my socket and call self.connectionLost().
@return: A L{Deferred} that fires when this port has stopped.
r TN)
stopReading
disconnecting_stoppedDeferredr} r
deferLaterrw connectionLostr succeedr; r1 r1 r2
stopListeningg s
zTuntapPort.stopListeningTwisted r c C s | tj dS )zN
Close this tunnel. Use L{TuntapPort.stopListening} instead.
N)r
addErrbackr r r; r1 r1 r2 loseConnection{ s zTuntapPort.loseConnectionc C sF t d| j tj| | | j d| _| j
| j d| _ dS )zY
Cleans up my socket.
@param reason: Ignored. Do not use this.
z(Tuntap %s Closed)r N) r r rq r
rp r rr doStopr} ro rZ r )r< reasonr1 r1 r2 r s
zTuntapPort.connectionLostc C r6 )zK
Returns the name of my class, to prefix log entries with.
)ru r; r1 r1 r2 ry s zTuntapPort.logPrefixc C s t | j| jS )z
Get the local address of this L{TuntapPort}.
@return: A L{TunnelAddress} which describes the tunnel device to which
this object is bound.
@rtype: L{TunnelAddress}
)r rm rq r; r1 r1 r2 getHost s zTuntapPort.getHost)r NNr7 )r! r" r# r$ r r= strr r r r r^ r rY r r r r r r ry r r1 r1 r1 r2 r s$
r )3r$ r rh rg r rA collectionsr typingr zope.interfacer r r
constantlyr r incrementalr twisted.internetr
r r r
r twisted.pairr r twisted.pythonr twisted.python.deprecater twisted.python.reflectr twisted.python.utilr r __all__r r
_TUNGETIFFr r IAddressr rI rJ re IListeningPortrp r r1 r1 r1 r2 s< !) F