o

�
bhC�@s
dZd
dl
Z
d
dlZd
dlmZ
d
dlmZmZmZm	Z	m
Z
mZmZm
Z

d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
d	lmZ
d
d
lmZ
d
dlmZmZmZmZ
d
dlm Z 
d
Z!dd�Z"dZ#dd�Z$dd�Z%dd�Z&Gdd�d�Z'dd�Z(ee�
Gdd�d��
Z)Gdd�d�Z*dS)zD
Tools for automated testing of L{twisted.pair}-based applications.
�N)
�deque)�EAGAIN�EBADF�EINTR�EINVAL�ENOBUFS�ENOSYS�EPERM�EWOULDBLOCK�
�wraps)
�implementer)
�DatagramProtocol)
�EthernetProtocol)
�
IPProtocol)
�RawUDPProtocol)�	_IFNAMSIZ�
_TUNSETIFF�TunnelFlags�_IInputOutputSystem)
�nativeString�c

Cst�
d
|�S)z�
    Pack an integer into a network-order two-byte string.

    @param n: The integer to pack.  Only values that fit into 16 bits are
        supported.

    @return: The packed representation of the integer.
    @rtype: L{bytes}
    z>H)�struct�pack)
�
n�r�6/usr/lib/python3/dist-packages/twisted/pair/testing.py�_Hs
r�cCs|
|t|�
|S)
a�

    Construct an ethernet frame.

    @param src: The source ethernet address, encoded.
    @type src: L{bytes}

    @param dst: The destination ethernet address, encoded.
    @type dst: L{bytes}

    @param protocol: The protocol number of the payload of this datagram.
    @type protocol: L{int}

    @param payload: The content of the ethernet frame (such as an IP datagram).
    @type payload: L{bytes}

    @return: The full ethernet frame.
    @rtype: L{bytes}
    )
r��src�dst�protocol�payloadrrr�	_ethernet.sr$cCs�d
tdt
|�
�
dtd�
t�tjt|�
�t�tjt|
�
�}tt�d|��
}|d?}|d@|}|dA}|dd	�t�	d
|�|dd�}||S)a�

    Construct an IP datagram with the given source, destination, and
    application payload.

    @param src: The source IPv4 address as a dotted-quad string.
    @type src: L{bytes}

    @param dst: The destination IPv4 address as a dotted-quad string.
    @type dst: L{bytes}

    @param payload: The content of the IP datagram (such as a UDP datagram).
    @type payload: L{bytes}

    @return: An IP datagram header and payload.
    @rtype: L{bytes}
    sE�s
@r
z!10H�i��N�
z!H�)
r�len�socket�	inet_pton�AF_INETr�sumr�unpackr)r r!r#�ipHeader�
checksumStep1�carry�
checksumStep2�
checksumStep3rrr�_ipDs$���	���$r4cCs0t|�
t|
�
tt
|�
d
�
td�
}||S)a~

    Construct a UDP datagram with the given source, destination, and
    application payload.

    @param src: The source port number.
    @type src: L{int}

    @param dst: The destination port number.
    @type dst: L{int}

    @param payload: The content of the UDP datagram.
    @type payload: L{bytes}

    @return: A UDP datagram header and payload.
    @rtype: L{bytes}
    �r
)rr))r r!r#�	udpHeaderrrr�_udpvs����
r7c@sreZ
dZd
ZdZeed�Zee	d�Z
eed�ZeZ
dZdd�Zed	d
��
Zedd��
Zd
d�Zdd�Zdd�ZdS)�Tunnelz�
    An in-memory implementation of a tun or tap device.

    @cvar _DEVICE_NAME: A string representing the conventional filesystem entry
        for the tunnel factory character special device.
    @type _DEVICE_NAME: C{bytes}
    s/dev/net/tunz Resource temporarily unavailablezOperation would blockzInterrupted function callicCs:|
|_||_
d
|_d
|_d
|_t�|_t�|_t�|_d
S)a

        @param system: An L{_IInputOutputSystem} provider to use to perform I/O.

        @param openFlags: Any flags to apply when opening the tunnel device.
            See C{os.O_*}.

        @type openFlags: L{int}

        @param fileMode: ignored
        N)	�system�	openFlags�
tunnelMode�
requestedName�namer�
readBuffer�writeBuffer�pendingSignals)�selfr9r:�fileModerrr�__init__�s





zTunnel.__init__c

Cs|j|j
j@S)
zx
        If the file descriptor for this tunnel is open in blocking mode,
        C{True}.  C{False} otherwise.
        )r:r9�
O_NONBLOCK�
rArrr�blocking�szTunnel.blockingc

Cst|j
|jj@�
S)
zz
        If the file descriptor for this tunnel is marked as close-on-exec,
        C{True}.  C{False} otherwise.
        )�boolr:r9�	O_CLOEXECrErrr�closeOnExec�szTunnel.closeOnExeccCs.|jt
jj@rtd
dt|
d�}
|j�|
�

dS)aI

        Deliver a datagram to this tunnel's read buffer.  This makes it
        available to be read later using the C{read} method.

        @param datagram: The IPv4 datagram to deliver.  If the mode of this
            tunnel is TAP then ethernet framing will be added automatically.
        @type datagram: L{bytes}
        ss������rN)r;r�IFF_TAP�valuer$�_IPv4r>�append�rA�datagramrrr�addToReadBuffer�s



�zTunnel.addToReadBuffercCsR|jr |j
tjj@r
d
}ndt}|
d8}
||j��d|
�S|jr&t��
|j	�
)a
        Read a datagram out of this tunnel.

        @param limit: The maximum number of bytes from the datagram to return.
            If the next datagram is larger than this, extra bytes are dropped
            and lost forever.
        @type limit: L{int}

        @raise OSError: Any of the usual I/O problems can result in this
            exception being raised with some particular error number set.

        @raise IOError: Any of the usual I/O problems can result in this
            exception being raised with some particular error number set.

        @return: The datagram which was read from the tunnel.  If the tunnel
            mode does not include L{TunnelFlags.IFF_NO_PI} then the datagram is
            prefixed with a 4 byte PI header.
        @rtype: L{bytes}
        ��
rN)
r>r;r�	IFF_NO_PIrK�_PI_SIZE�popleftrF�NotImplementedError�nonBlockingExceptionStyle)rA�limit�headerrrr�read�s





zTunnel.readcCsF|jr
|j�
�
ttd
��
t|
�
|jkrttd��
|j�|
�

t|
�
S)a{

        Write a datagram into this tunnel.

        @param datagram: The datagram to write.
        @type datagram: L{bytes}

        @raise IOError: Any of the usual I/O problems can result in this
            exception being raised with some particular error number set.

        @return: The number of bytes of the datagram which were written.
        @rtype: L{int}
        zInterrupted system callzNo buffer space available)	r@rU�OSErrorrr)�SEND_BUFFER_SIZErr?rMrNrrr�write
s






zTunnel.writeN)�__name__�
__module__�__qualname__�__doc__�_DEVICE_NAME�IOErrorr�EAGAIN_STYLEr[r
�EWOULDBLOCK_STYLEr�EINTR_STYLErWr\rC�propertyrFrIrPrZr]rrrrr8�s 








#r8c
st��
�f
d
d��
}
|
S)a|

    Wrap a L{MemoryIOSystem} method with permission-checking logic.  The
    returned function will check C{self.permissions} and raise L{IOError} with
    L{errno.EPERM} if the function name is not listed as an available
    permission.

    @param original: The L{MemoryIOSystem} instance to wrap.

    @return: A wrapper around C{original} that applies permission checks.
    c
s,�j|j
v
rttd
��
�|g
|
�
Ri|�
�
S)NzOperation not permitted)r^�permissionsr[r	)rA�args�kwargs�
�originalrr�permissionChecker+
s


z&_privileged.<locals>.permissionCheckerr)rlrmrrkr�_privileged
s
rnc@szeZ
dZd
ZdZdZdZdZdd�Zdd	�Z	d
d�Z
edd
d�
�
Zdd�Z
dd�Zdd�Zedd��
Zdd�Zdd�ZdS)�MemoryIOSystemz�
    An in-memory implementation of basic I/O primitives, useful in the context
    of unit testing as a drop-in replacement for parts of the C{os} module.

    @ivar _devices:
    @ivar _openFiles:
    @ivar permissions:

    @ivar _counter:
    i �
�rc

Csi|_i|_
d
dh|_dS)N�open�ioctl)�_devices�
_openFilesrhrErrrrCG
s


zMemoryIOSystem.__init__cCs|j|
�
�S)
aX

        Get the L{Tunnel} object associated with the given L{TuntapPort}.

        @param port: A L{TuntapPort} previously initialized using this
            L{MemoryIOSystem}.

        @return: The tunnel object created by a prior use of C{open} on this
            object on the tunnel special device file.
        @rtype: L{Tunnel}
        )ru�fileno)rA�portrrr�	getTunnelL
�zMemoryIOSystem.getTunnelcCs||j|
<d
S)a1

        Specify a class which will be used to handle I/O to a device of a
        particular name.

        @param name: The filesystem path name of the device.
        @type name: L{bytes}

        @param cls: A class (like L{Tunnel}) to instantiated whenever this
            device is opened.
        N)
rt)rAr=�clsrrr�registerSpecialDeviceY
ryz$MemoryIOSystem.registerSpecialDeviceNcCsD|
|jvr|j
}|j
d
7_
|j|
|||�|j|<|Sttd��
)a�
        A replacement for C{os.open}.  This initializes state in this
        L{MemoryIOSystem} which will be reflected in the behavior of the other
        file descriptor-related methods (eg L{MemoryIOSystem.read},
        L{MemoryIOSystem.write}, etc).

        @param name: A string giving the name of the file to open.
        @type name: C{bytes}

        @param flags: The flags with which to open the file.
        @type flags: C{int}

        @param mode: The mode with which to open the file.
        @type mode: C{int}

        @raise OSError: With C{ENOSYS} if the file is not a recognized special
            device file.

        @return: A file descriptor associated with the newly opened file
            description.
        @rtype: L{int}
        rpzFunction not implemented)rt�_counterrur[r)rAr=�flags�mode�fdrrrrrf
s






zMemoryIOSystem.opencC�,z	|j|
�
|�
WSty


ttd
��
w)z�
        Try to read some bytes out of one of the in-memory buffers which may
        previously have been populated by C{write}.

        @see: L{os.read}
        �Bad file descriptor)rurZ�KeyErrorr[r)rArrXrrrrZ�
�




�zMemoryIOSystem.readcCr�)z�
        Try to add some bytes to one of the in-memory buffers to be accessed by
        a later C{read} call.

        @see: L{os.write}
        r�)rur]r�r[r)rAr�datarrrr]�
r�zMemoryIOSystem.writecCs(z|j|
=WdSt
y


ttd
��
w)z�
        Discard the in-memory buffer and other in-memory state for the given
        file descriptor.

        @see: L{os.close}
        r�N)rur�r[r)rArrrr�close�
s




�zMemoryIOSystem.closecCs�z|j|
}Wnt
y


ttd
��
w|tkrttd��
t�dtf
|�\}}||_	||_
|dtd�d|_t�dtf
|j|�S)z�
        Perform some configuration change to the in-memory state for the given
        file descriptor.

        @see: L{fcntl.ioctl}
        r�zRequest or args is not valid.z%dsHN�s123)
rur�r[rrrrr.rr;r<r=r)rAr�requestri�tunnelr=r~rrrrs�
s



�




zMemoryIOSystem.ioctlcCsLd
}d}t||dt
||d|
d�d�}t|j���
}|d�|�

||fS)ah
        Write an ethernet frame containing an ip datagram containing a udp
        datagram containing the given payload, addressed to the given address,
        to a tunnel device previously opened on this I/O system.

        @param datagram: A UDP datagram payload 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: A two-tuple giving the address from which gives the address
            from which the datagram was sent.
        @rtype: L{tuple} of (L{bytes}, L{int})
        z10.1.2.3iaSr
rp)r r!r#)r4r7�listru�valuesrP)rArO�address�srcIP�srcPort�
serialized�	openFilesrrr�sendUDP�
s



�
zMemoryIOSystem.sendUDPcCs
t||
�S)
aa
        Get a socket-like object which can be used to receive a datagram sent
        from the given address.

        @param fileno: A file descriptor representing a tunnel device which the
            datagram will be received via.
        @type fileno: L{int}

        @param host: The IPv4 address to which the datagram was sent.
        @type host: L{bytes}

        @param port: The UDP port number to which the datagram was sent.
            received.
        @type port: L{int}

        @return: A L{socket.socket}-like object which can be used to receive
            the specified datagram.
        )
�	_FakePort)rArv�hostrwrrr�
receiveUDP�
s
zMemoryIOSystem.receiveUDP�
N)r^r_r`rar|�O_RDWRrDrHrCrxr{rnrrrZr]r�rsr�r�rrrrro4
s$






roc@s eZ
dZd
Zdd�Zdd�ZdS)r�z�
    A socket-like object which can be used to read UDP datagrams from
    tunnel-like file descriptors managed by a L{MemoryIOSystem}.
    cCs|
|_||_
dSr�)�_system�_fileno)rAr9rvrrrrC�
s


z_FakePort.__init__c
s�|jj
|jj��}g�t�}�f
d
d�}||_t�}|�d|�
t	��
�
�d|�
|jj
|jj
}|tjj
@rEt�}|�d�
�
|j}n�
f
dd�}|tjj
@}	|	rZ|td�}||�

�d	d|
�S)
a_

        Receive a datagram sent to this port using the L{MemoryIOSystem} which
        created this object.

        This behaves like L{socket.socket.recv} but the data being I{sent} and
        I{received} only passes through various memory buffers managed by this
        object and L{MemoryIOSystem}.

        @see: L{socket.socket.recv}
        cs��|�

dSr�)
rM)rOr�)
�	datagramsrr�captures
z_FakePort.recv.<locals>.capturei90�rc

s��|dddd�Sr�)
�datagramReceived)
r�)
�iprr�<lambda> s

�z _FakePort.recv.<locals>.<lambda>Nr
)r�rur�r?rUrr�r�addProtorr;rrJrKrrSrT)
rA�nbytesr��receiverr��udpr~�etherr��	dataHasPIr)r�r�r�recv�
s(







z_FakePort.recvN)r^r_r`rarCr�rrrrr��
s
r�)+rar*r�collectionsr�errnorrrrrrr	r
�	functoolsr�zope.interfacer
�twisted.internet.protocolr�twisted.pair.ethernetr�twisted.pair.ipr�twisted.pair.rawudpr�twisted.pair.tuntaprrrr�twisted.python.compatrrTrrLr$r4r7r8rnror�rrrr�<module>
s4

(







2
A