Spamworldpro Mini Shell
Spamworldpro


Server : Apache/2.4.52 (Ubuntu)
System : Linux webserver 6.8.0-49-generic #49~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Wed Nov 6 17:42:15 UTC 2 x86_64
User : www-data ( 33)
PHP Version : 8.1.2-1ubuntu2.21
Disable Function : NONE
Directory :  /lib/python3/dist-packages/twisted/pair/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Current File : //lib/python3/dist-packages/twisted/pair/__pycache__/testing.cpython-310.pyc
o

�bhC�@sdZddlZddlZddlmZddlmZmZmZm	Z	m
Z
mZmZm
Z
ddlmZddlmZddlmZddlmZdd	lmZdd
lmZddlmZmZmZmZdd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�cCs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�dtdt|��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@rz!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@sreZdZdZdZeed�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�|_dS)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__cCs|j|jj@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.blockingcCst|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.|jtjj@rtddt|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 |jtjj@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�szTunnel.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�writes


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




#r8cst���fdd��}|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.
    cs,�j|jvrttd���|g|�Ri|��S)NzOperation not permitted)r^�permissionsr[r	)rA�args�kwargs��originalrr�permissionChecker+s
z&_privileged.<locals>.permissionCheckerr)rlrmrrkr�_privilegedsrnc@szeZdZdZdZdZdZdZdd�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 ��rcCsi|_i|_ddh|_dS)N�open�ioctl)�_devices�
_openFilesrhrErrrrCGszMemoryIOSystem.__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|<dS)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�registerSpecialDeviceYryz$MemoryIOSystem.registerSpecialDeviceNcCsD||jvr|j}|jd7_|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�fdrrrrrfs

zMemoryIOSystem.opencC�,z	|j|�|�WStyttd��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|=WdStyttd��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tyttd��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.3iaSrrp)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�rrrrro4s$


roc@s eZdZdZdd�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�}�fdd�}||_t�}|�d|�t	����d|�|jj|jj
}|tjj
@rEt�}|�d��|j}n�fdd�}|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�capturesz_FakePort.recv.<locals>.capturei90�rcs��|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

Spamworldpro Mini