a
    kÄ#d�™ ã                   @   sª  d Z ddlmZ ddlmZ ddlmZ ddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlm  mZ ddlmZmZmZ ddlmZ ddlm Z m!Z!m"Z" dd	l#m$Z$m%Z%m&Z& dd
l'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ ddl0m1Z1m2Z2m3Z3 ddl4m5Z5 ddl'm6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZD e@�rÊddlEmFZF ddlGmHZHmIZI ddlJmKZK eKZLneMZLeCe;eN e	jOf ZPdd„ ZQeCeeRf ZSG dd„ deƒZTeDdd„ ƒZUeDdÖdd„ƒZUd×dd„ZUdØdd„ZVdÙdd„ZWejXjYdd „ ƒZZd!d"„ Z[ejXjYdÚd#d$„ƒZ\ejXjYdÛd%d&„ƒZ]ejXjYdÜd'd(„ƒZ^ejXjYdÝd)d*„ƒZ_d+d,„ Z`ejXjYdÞd-d.„ƒZae bd/d0¡d1k�rÒd2d3„ Zcnd4d3„ Zcd5d6„ Zdd7d8„ ZeejXjYd9d:„ ƒZfejXjYd;d<„ ƒZgd=d>„ Zhd?d@„ ZidAdB„ ZjdCdD„ ZkdEdF„ ZldGdH„ ZmdIdJ„ Znze odK¡ W n ejp�yn   dLdM„ ZoY n0 ejoZoejqZqdNdO„ ZrdPdQ„ ZsdRdS„ ZtdTdU„ ZudVdW„ ZvdXdY„ ZwdZd[„ Zxd\d]„ ZyG d^d_„ d_eMƒZzG d`da„ daeMƒZ{dßdbdc„Z|dddedfdgdhdidjdkdldmdndodpdqœZ}drds„ Z~dtdu„ Zdàdwdx„Z€dydz„ Z�d{d|„ Z‚G d}d~„ d~ƒZƒG dd€„ d€e„ƒZ…d�d‚„ Z†dádƒd„„Z‡d…d†„ Zˆd‡dˆ„ Z‰ejXjYdâdŠd‹„ƒZŠejXjYdãdŒd�„ƒZ‹ejXjYdŽd�„ ƒZŒejXjYd�d‘„ ƒZ�ejXjYdäd“d”„ƒZŽG d•d–„ d–e„ƒZ�e �e�¡G d—d˜„ d˜ƒƒZ‘G d™dš„ dše‘eLƒZ’G d›dœ„ dœe‘ƒZ“G d�dž„ dže“e’eLƒZ”G dŸd „ d eMƒZ•G d¡d¢„ d¢e•ƒZ–G d£d¤„ d¤e–ƒZ—G d¥d¦„ d¦e–ƒZ˜G d§d¨„ d¨e—ƒZ™G d©dª„ dªe˜ƒZšejXjYdåd«d¬„ƒZ›G d­d®„ d®e�ƒZœe �eœ¡G d¯d°„ d°e’ƒƒZ�ejXjYd±d²„ ƒZžG d³d´„ d´e™ƒZŸejXjYdædµd¶„ƒZ ejXjYdçd·d¸„ƒZ¡ejXjYdèd¹dº„ƒZ¢d»d¼„ Z£d½d¾„ Z¤ejXjYdédÀdÁ„ƒZ¥ejXjYdÂdÃ„ ƒZ¦dÄdÅ„ Z§dêdÆdÇ„Z¨dëdÈdÉ„Z©dÊdË„ ZªdÌdÍ„ Z«dÎdÏ„ Z¬dÐdÑ„ Z­G dÒdÓ„ dÓej®ƒZ¯G dÔdÕ„ dÕeMƒZ°dS )ìz
General utility functions.
é    )Úabsolute_import)Úprint_function)ÚDecimalN)ÚrangeÚinputÚzip_longest)Úconf)ÚDARWINÚOPENBSDÚWINDOWS)ÚMTUÚ
DLT_EN10MBÚDLT_RAW)ÚorbÚ	plain_strÚchbÚbytes_base64Úbase64_bytesÚ	hex_bytesÚlambda_tuple_converterÚbytes_encode)Úlog_runtimeÚScapy_ExceptionÚwarning)Ú	inet_pton)ÚcastÚAnyÚAnyStrÚCallableÚDictÚIOÚIteratorÚListÚLiteralÚOptionalÚTYPE_CHECKINGÚTupleÚTypeÚUnionÚoverload)ÚPacket)Ú_PacketIterableÚ
PacketList)ÚSuperSocketc                 C   s:   t |tƒr|dd„ | jD ƒv S t | tƒr6t| |ƒr6dS dS )zòissubtype(C, B) -> bool

    Return whether C is a class and if it is a subclass of class B.
    When using a tuple as the second argument issubtype(X, (A, B, ...)),
    is a shortcut for issubtype(X, A) or issubtype(X, B) or ... (etc.).
    c                 s   s   | ]}|j V  qd S ©N)Ú__name__)Ú.0Úz© r2   úB/var/www/html/gsl.tools/lib/python3.9/site-packages/scapy/utils.pyÚ	<genexpr>Y   ó    zissubtype.<locals>.<genexpr>TF)Ú
isinstanceÚstrÚ	__bases__ÚtypeÚ
issubclass)ÚxÚtr2   r2   r3   Ú	issubtypeN   s
    

r=   c                       s¬   e Zd ZdZd$dd„Zdd„ Zdd„ Zd	d
„ Zdd„ Zdd„ Z	dd„ Z
dd„ Zejdkrbdd„ Zndd„ Zdd„ Zdd„ Zdd„ Zd%dd„Z‡ fd d!„Z‡ fd"d#„Z‡  ZS )&ÚEDecimalznExtended Decimal

    This implements arithmetic and comparison with float for
    backward compatibility
    Nc                 C   s   t t | t|ƒ¡ƒS r.   ©r>   r   Ú__add__)ÚselfÚotherÚcontextr2   r2   r3   r@   i   s    zEDecimal.__add__c                 C   s   t t | t|ƒ¡ƒS r.   r?   ©rA   rB   r2   r2   r3   Ú__radd__m   s    zEDecimal.__radd__c                 C   s   t t | t|ƒ¡ƒS r.   )r>   r   Ú__sub__rD   r2   r2   r3   rF   q   s    zEDecimal.__sub__c                 C   s   t t | t|ƒ¡ƒS r.   )r>   r   Ú__rsub__rD   r2   r2   r3   rG   u   s    zEDecimal.__rsub__c                 C   s   t t | t|ƒ¡ƒS r.   ©r>   r   Ú__mul__rD   r2   r2   r3   rI   y   s    zEDecimal.__mul__c                 C   s   t t | t|ƒ¡ƒS r.   rH   rD   r2   r2   r3   Ú__rmul__}   s    zEDecimal.__rmul__c                 C   s   t t | t|ƒ¡ƒS r.   )r>   r   Ú__truediv__rD   r2   r2   r3   rK   �   s    zEDecimal.__truediv__c                 C   s   t t | t|ƒ¡ƒS r.   )r>   r   Ú__floordiv__rD   r2   r2   r3   rL   …   s    zEDecimal.__floordiv__)é   c                 C   s(   t  | t |ƒ¡}t|d ƒt|d ƒfS )Nr   é   )r   Ú
__divmod__r>   )rA   rB   Úrr2   r2   r3   rO   Š   s    zEDecimal.__divmod__c                 C   s   t t | t|ƒ¡ƒS r.   )r>   r   Ú__div__rD   r2   r2   r3   rQ   �   s    zEDecimal.__div__c                 C   s   t t | t|ƒ¡ƒS r.   )r>   r   Ú__rdiv__rD   r2   r2   r3   rR   “   s    zEDecimal.__rdiv__c                 C   s   t t | t|ƒ¡ƒS r.   )r>   r   Ú__mod__rD   r2   r2   r3   rS   —   s    zEDecimal.__mod__c                 C   s   t t | t|ƒ¡ƒS r.   )r>   r   Ú__rmod__rD   r2   r2   r3   rT   ›   s    zEDecimal.__rmod__c                 C   s   t t | t|ƒ|¡ƒS r.   )r>   r   Ú__pow__)rA   rB   Zmodulor2   r2   r3   rU   Ÿ   s    zEDecimal.__pow__c                    s   t t| ƒ |¡pt| ƒ|kS r.   )Úsuperr>   Ú__eq__ÚfloatrD   ©Ú	__class__r2   r3   rW   £   s    zEDecimal.__eq__c                    sF   t  ¡ �*}||_ttt| ƒ |¡ƒW  d   ƒ S 1 s80    Y  d S r.   )ÚdecimalÚlocalcontextÚprecr>   rV   Ú	normalize)rA   Ú	precisionÚctxrY   r2   r3   r^   §   s    
zEDecimal.normalize)N)N)r/   Ú
__module__Ú__qualname__Ú__doc__r@   rE   rF   rG   rI   rJ   rK   rL   ÚsysÚversion_inforO   rQ   rR   rS   rT   rU   rW   r^   Ú__classcell__r2   r2   rY   r3   r>   b   s$   



r>   c                 C   s   d S r.   r2   ©ÚkeepÚautoextÚfdr2   r2   r3   Úget_temp_file®   s    rk   FÚ c                 C   s   d S r.   r2   rg   r2   r2   r3   rk   ´   s    c                 C   s<   t jd|dd�}| s"tj |j¡ |r*|S | ¡  |jS dS )a=  Creates a temporary file.

    :param keep: If False, automatically delete the file when Scapy exits.
    :param autoext: Suffix to add to the generated file name.
    :param fd: If True, this returns a file-like object with the temporary
               file opened. If False (default), this returns a file path.
    ÚscapyF)ÚprefixÚsuffixÚdeleteN)ÚtempfileÚNamedTemporaryFiler   Ú
temp_filesÚappendÚnameÚclose)rh   ri   rj   Úfr2   r2   r3   rk   º   s    	ÿc                 C   s    t jdd�}| stj |¡ |S )zÚCreates a temporary file, and returns its name.

    :param keep: If False (default), the directory will be recursively
                 deleted when Scapy exits.
    :return: A full path to a temporary directory.
    rm   )rn   )rq   Úmkdtempr   rs   rt   )rh   Údnamer2   r2   r3   Úget_temp_dirÐ   s    	rz   c                 C   sV   d}| D ]H}t |ƒ}|dk s$|dkrD|r:|tj d¡7 }qP|d7 }q|t|ƒ7 }q|S )Nrl   é    é   Ú.)r   r   Úcolor_themeZnot_printableÚchr)r;   ÚcolorrP   ÚiÚjr2   r2   r3   Úsaneá   s    
rƒ   c               	   C   sŒ   t jrtj tjd ¡s tdƒ‚trpz>zt	 
tjgtj ¡} W n tyT   d} Y n0 W t | ¡ nt | ¡ 0 t tjtjgtj ¡ dS )zRestarts scapyr   z"Scapy was not started from consolerN   N)r   ÚinteractiveÚosÚpathÚisfilerd   ÚargvÚOSErrorr   Ú
subprocessÚcallÚ
executableÚKeyboardInterruptÚ_exitÚexecv)Zres_coder2   r2   r3   Úrestartð   s    r�   c                 C   s~   ddl m} t| |ƒrt| ƒS t| tjƒr2t| ƒS t| tƒrTdd dd„ | D ƒ¡ S t| t	ƒrvdd dd„ | D ƒ¡ S t
| ƒS )	Nr   )ÚVolatileValuez(%s)ú, c                 s   s   | ]}t |ƒV  qd S r.   ©Úlhex©r0   Úvr2   r2   r3   r4     r5   zlhex.<locals>.<genexpr>z[%s]c                 s   s   | ]}t |ƒV  qd S r.   r“   r•   r2   r2   r3   r4   
  r5   )Zscapy.volatiler‘   r6   ÚreprÚsixÚinteger_typesÚhexÚtupleÚjoinÚlistr7   )r;   r‘   r2   r2   r3   r”      s    


r”   c                 C   sÄ   d}t | ƒ}t|ƒ}d}||k r’|d| 7 }tdƒD ]2}|| |k r^|dt|||  ƒ 7 }q4|d7 }q4|dt|||d … dd	� 7 }|d7 }q| d
¡r¨|dd… n|}|r´|S t|ƒ dS dS )z¼Build a tcpdump like hexadecimal view

    :param p: a Packet
    :param dump: define if the result must be printed or returned in a variable
    :return: a String only when dump=True
    rl   r   z%04x  é   z%02X z   z %s
T©r€   Ú
Néÿÿÿÿ)r   Úlenr   r   rƒ   ÚendswithÚprint)ÚpÚdumpÚsr;   Zx_lenr�   r‚   r2   r2   r3   Úhexdump  s"    	
 
r¨   c                 C   s.   d}t | ||| d�}|r|S t|ƒ dS dS )ae  Build an equivalent view of hexdump() on a single line

    Note that setting both onlyasc and onlyhex to 1 results in a empty output

    :param p: a Packet
    :param onlyasc: 1 to display only the ascii view
    :param onlyhex: 1 to display only the hexadecimal view
    :param dump: print the view if False
    :return: a String only when dump=True
    rl   )ÚonlyascÚonlyhexr€   N)Úhexstrr¤   )r¥   r©   rª   r¦   r§   r2   r2   r3   Úlinehexdump-  s    r¬   c                 C   s4   t | ƒ}d dd„ |D ƒ¡}|r$|S t|ƒ dS dS )aO  Build a per byte hexadecimal representation

    Example:
        >>> chexdump(IP())
        0x45, 0x00, 0x00, 0x14, 0x00, 0x01, 0x00, 0x00, 0x40, 0x00, 0x7c, 0xe7, 0x7f, 0x00, 0x00, 0x01, 0x7f, 0x00, 0x00, 0x01  # noqa: E501

    :param p: a Packet
    :param dump: print the view if False
    :return: a String only if dump=True
    r’   c                 s   s   | ]}d t |ƒ V  qdS )z%#04xN©r   ©r0   r;   r2   r2   r3   r4   Q  r5   zchexdump.<locals>.<genexpr>N)r   rœ   r¤   )r¥   r¦   r;   r§   r2   r2   r3   ÚchexdumpC  s    r¯   c                 C   sJ   t | ƒ}g }|s*| d dd„ |D ƒ¡¡ |s@| t||d�¡ d |¡S )z*Build a fancy tcpdump like hex from bytes.ú c                 s   s   | ]}d t |ƒ V  qdS )ú%02XNr­   )r0   Úbr2   r2   r3   r4   `  r5   zhexstr.<locals>.<genexpr>rŸ   ú  )r   rt   rœ   rƒ   )r¥   r©   rª   r€   r;   r§   r2   r2   r3   r«   Y  s    r«   c                 C   s   d  dd„ | D ƒ¡S )z= Convert provided bitstring to a simple string of hex digits rl   c                 s   s   | ]}d t |ƒ V  qdS )z%02xNr­   r®   r2   r2   r3   r4   i  r5   zrepr_hex.<locals>.<genexpr>©rœ   ©r§   r2   r2   r3   Úrepr_hexf  s    r¶   c           !         sè  t | ƒ‰ t |ƒ‰tjˆ ˆ|d�}‡ fdd„ttˆ ƒƒD ƒ}‡fdd„ttˆƒƒD ƒ}g }g }| ¡ D ]’}|\}	}
}}}|	dkr¢|||
|… 7 }|dg||
  7 }qd|	dkrÎ|dg||  7 }||||… 7 }qd|	dv rd|||
|… 7 }||||… 7 }qd|�r>t|ƒ}t|ƒ}|dgt||ƒ|  7 }|dgt||ƒ|  7 }d	 } }}d
d„ tjj	tjj
dœ}d}d	}t|ƒ}||k �rä|||d … }|||d … }tdd„ |D ƒƒ}tdd„ |D ƒƒ}|�rÔ|�sÔd	}d}|�rè||k�rèd}|�r>|}d	}|| �s|d7 }|d8 }�qöt|||  d| ƒdd� ||7 }|}ntddd� |�r |}d	}|| �sv|d7 }|d8 }�qXt|||  d| ƒdd� ||7 }|}ntddd� tddd� d}tdƒD ]Ú}|| tt|ƒt|ƒƒk �rz|| �rd||| || k||   } t| dt|| ƒ ƒdd� || || k�rN|t|| dd�7 }n|| t|| ƒƒ7 }ntddd� |d7 }ntddd� |dk�rÄtddd� �qÄtd|ƒ |�s¶|�sÈd	}d}|d7 }n|�rØd	}d}n|d7 }�qrdS )a×  
    Show differences between 2 binary strings, Packets...

    For the autojunk parameter, see
    https://docs.python.org/3.8/library/difflib.html#difflib.SequenceMatcher

    :param a:
    :param b: The binary strings, packets... to compare
    :param autojunk: Setting it to True will likely increase the comparison
        speed a lot on big byte strings, but will reduce accuracy (will tend
        to miss insertion and see replacements instead for instance).
    )Úar²   Úautojunkc                    s   g | ]}ˆ ||d  … ‘qS ©rN   r2   ©r0   r�   )Úxbr2   r3   Ú
<listcomp>‚  r5   zhexdiff.<locals>.<listcomp>c                    s   g | ]}ˆ ||d  … ‘qS r¹   r2   rº   )Úybr2   r3   r¼   ƒ  r5   rp   r5   Úinsert)ÚequalÚreplacer   c                 S   s   | S r.   r2   ©r;   r2   r2   r3   Ú<lambda>�  r5   zhexdiff.<locals>.<lambda>)r   r¡   rN   rN   rž   c                 s   s   | ]}t |ƒV  qd S r.   ©r¢   ©r0   Úkr2   r2   r3   r4   §  r5   zhexdiff.<locals>.<genexpr>c                 s   s   | ]}t |ƒV  qd S r.   rÃ   rÄ   r2   r2   r3   r4   ¨  r5   z%04xr°   ©Úendz    rl   r±   TrŸ   r³   é   N)r   ÚdifflibZSequenceMatcherr   r¢   Zget_opcodesÚmaxr   r~   ÚleftÚrightÚsumr¤   Úminr   rƒ   )!r·   r²   r¸   ÚsmZxarrZyarrZ
backtrackxZ
backtrackyÚopcodeÚtypZx0Úx1Zy0Úy1ZlbxZlbyr;   Úyr�   ZcolorizeZdoxZdoyZbtx_lenZlinexZlineyÚxxÚyyZxdr‚   ÚlineZydÚclÚcolr2   )r»   r½   r3   Úhexdiffl  sª    þ







rÚ   ÚHrN   s    c                 C   s   | S r.   r2   ©Zchkr2   r2   r3   rÂ   é  r5   rÂ   c                 C   s   | d? d@ | d> B S )Né   éÿ   r2   rÜ   r2   r2   r3   rÂ   ë  r5   c                 C   sV   t | ƒd dkr| d7 } tt d| ¡ƒ}|d? |d@  }||d? 7 }| }t|ƒd@ S )Né   rN   ó    rÛ   rž   iÿÿ  )r¢   rÍ   ÚarrayÚchecksum_endian_transform)Úpktr§   r2   r2   r3   Úchecksumî  s    rä   c                 C   s>   d }}| D ]}|t |ƒ7 }||7 }q|d; }|d; }||fS )Nr   rÞ   r­   )ZcharbufÚc0Úc1Úcharr2   r2   r3   Ú_fletcher16ù  s    
rè   c                 C   s   t | ƒ\}}|d> |B S )a  Calculates Fletcher-16 checksum of the given buffer.

       Note:
       If the buffer contains the two checkbytes derived from the Fletcher-16 checksum  # noqa: E501
       the result of this function has to be 0. Otherwise the buffer has been corrupted.  # noqa: E501
    rÝ   )rè   )Úbinbufrå   ræ   r2   r2   r3   Úfletcher16_checksum  s    	rê   c                 C   s    t | ƒ|k rtdt | ƒ ƒ‚| d|… d | |d d…  } t| ƒ\}}t | ƒ| d | | d }|dkrt|d7 }d| | }|dkr�|d8 }t|ƒt|ƒ S )	a¯  Calculates the Fletcher-16 checkbytes returned as 2 byte binary-string.

       Including the bytes into the buffer (at the position marked by offset) the  # noqa: E501
       global Fletcher-16 checksum of the buffer will be 0. Thus it is easy to verify  # noqa: E501
       the integrity of the buffer on the receiver side.

       For details on the algorithm, see RFC 2328 chapter 12.1.7 and RFC 905 Annex B.  # noqa: E501
    z"Packet too short for checkbytes %dNs     rß   rN   rÞ   r   iþ  )r¢   Ú	Exceptionrè   r   )ré   Úoffsetrå   ræ   r;   rÔ   r2   r2   r3   Úfletcher16_checkbytes  s     rí   c                 C   s   d  dd„ t| ƒ d¡D ƒ¡S )Nr5   c                 s   s   | ]}t t|d ƒƒV  qdS )rž   N)r   Úintr®   r2   r2   r3   r4   4  r5   zmac2str.<locals>.<genexpr>ú:)rœ   r   Úsplit©Úmacr2   r2   r3   Úmac2str2  s    ró   c                 C   s*   zt t| ƒƒdkW S  ty$   Y n0 dS )Né   F)r¢   ró   Ú
ValueErrorrñ   r2   r2   r3   Ú	valid_mac7  s
    rö   c                 C   sH   t | tƒr,dt| ƒ d d… ttt| ƒƒ S dt| ƒ d d… t| ƒ S )Nz%02x:r¡   )r6   r7   r¢   r›   ÚmapÚordrµ   r2   r2   r3   Ústr2mac@  s    
"rù   c                 C   s   d  dd„ t| ƒD ƒ¡S )z9
    Returns a random string of length (length >= 0)
    r5   c                 s   s"   | ]}t  d t dd¡¡V  qdS )ÚBr   rÞ   N©ÚstructÚpackÚrandomÚrandint©r0   Ú_r2   r2   r3   r4   L  s   ÿzrandstring.<locals>.<genexpr>©rœ   r   ©Úlengthr2   r2   r3   Ú
randstringG  s    
ÿr  c                 C   s   d  dd„ t| ƒD ƒ¡S )zM
    Returns a random string of length (length >= 0) without zero in it.
    r5   c                 s   s"   | ]}t  d t dd¡¡V  qdS )rú   rN   rÞ   Nrû   r   r2   r2   r3   r4   U  s   ÿz&zerofree_randstring.<locals>.<genexpr>r  r  r2   r2   r3   Úzerofree_randstringP  s    
ÿr  c                 C   s   d  tdd„ | |ƒ¡S )zk
    Returns the binary XOR of the 2 provided strings s1 and s2. s1 and s2
    must be of same length.
    r5   c                 S   s   t t| ƒt|ƒA ƒS r.   ©r   r   ©r;   rÔ   r2   r2   r3   rÂ   _  r5   zstrxor.<locals>.<lambda>©rœ   r÷   ©Ús1Ús2r2   r2   r3   ÚstrxorY  s    r  c                 C   s   d  tdd„ | |ƒ¡S )zk
    Returns the binary AND of the 2 provided strings s1 and s2. s1 and s2
    must be of same length.
    r5   c                 S   s   t t| ƒt|ƒ@ ƒS r.   r  r  r2   r2   r3   rÂ   h  r5   zstrand.<locals>.<lambda>r	  r
  r2   r2   r3   Ústrandb  s    r  ú255.255.255.255c                 C   s   | dkrdS t  | ¡S d S )Nr  s   ÿÿÿÿ)ÚsocketÚ	inet_aton)Z	ip_stringr2   r2   r3   r  o  s    r  c                 C   sF   zt | ƒ}W n" tjy.   t t | ¡ƒ}Y n0 ttt d|¡d ƒS )Nú!Ir   )r  r  ÚerrorÚgethostbynamer   rî   rü   Úunpack)r;   Úipr2   r2   r3   Úatol{  s
    r  c              
   C   sP   zt | ƒ} W n ty    Y dS 0 zt| ƒ W n tttjfyJ   Y dS 0 dS )NFT)r   ÚUnicodeDecodeErrorr  r‰   rõ   r  r  ©Úaddrr2   r2   r3   Úvalid_ip„  s    r  c                 C   sn   zt | ƒ} W n ty    Y dS 0 d| v rf|  dd¡\}}t|ƒod| ¡ oddt|ƒ  ko`dkS   S t| ƒS )NFú/rN   r   r{   )r   r  rð   r  Úisdigitrî   ©r  r  Úmaskr2   r2   r3   Ú	valid_net‘  s    ,r   c                 C   s†   zt | ƒ} W n ty    Y dS 0 zttj| ƒ W nN tjy€   z t | d tj¡d d d  W n tjyz   Y Y dS 0 Y n0 dS )NFr   é   T)r   r  r   r  ÚAF_INET6r  Úgetaddrinfor  r2   r2   r3   Ú	valid_ip6�  s     r$  c                 C   sn   zt | ƒ} W n ty    Y dS 0 d| v rf|  dd¡\}}t|ƒod| ¡ oddt|ƒ  ko`dkS   S t| ƒS )NFr  rN   r   é€   )r   r  rð   r$  r  rî   r  r2   r2   r3   Ú
valid_net6­  s    ,r&  c                 C   s   t t d| d@ ¡ƒS )Nr  ì   ÿÿ )Ú	inet_ntoarü   rý   rÁ   r2   r2   r3   Últoa¹  s    r)  c                 C   s   d| ? d@ S )Nl       üÿ r'  r2   rÁ   r2   r2   r3   Úitom¾  s    r*  c                 C   s   | j t ¡ d pddd�S )zy
    Decode bytes into a string using the system locale.
    Useful on Windows where it can be unusual (e.g. cp1252)
    rN   zutf-8rÀ   )ÚencodingÚerrors)ÚdecodeÚlocaleÚ	getlocalerÁ   r2   r2   r3   Údecode_locale_strÃ  s    r0  c                   @   s*   e Zd ZdZd
dd„Zdd„ Zdd„ Zd	S )ÚContextManagerSubprocessa  
    Context manager that eases checking for unknown command, without
    crashing.

    Example:
    >>> with ContextManagerSubprocess("tcpdump"):
    >>>     subprocess.Popen(["tcpdump", "--version"])
    ERROR: Could not execute tcpdump, is it installed?

    Tc                 C   s   || _ || _d S r.   )ÚprogÚsuppress)rA   r2  r3  r2   r2   r3   Ú__init__Ø  s    z!ContextManagerSubprocess.__init__c                 C   s   d S r.   r2   ©rA   r2   r2   r3   Ú	__enter__Ý  s    z"ContextManagerSubprocess.__enter__c                 C   s\   |d u s|d u rd S t |tƒr*d| j }nd| j|jjf }| jsJ||ƒ‚tj|dd� dS )Nz&Could not execute %s, is it installed?z%s: execution failed (%s)T)Úexc_info)r6   ÚEnvironmentErrorr2  rZ   r/   r3  r   r  )rA   Úexc_typeÚ	exc_valueÚ	tracebackÚmsgr2   r2   r3   Ú__exit__á  s    
þz!ContextManagerSubprocess.__exit__N)T)r/   ra   rb   rc   r4  r6  r=  r2   r2   r2   r3   r1  Ì  s   
r1  c                   @   s2   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	d
„ZdS )ÚContextManagerCaptureOutputzÇ
    Context manager that intercept the console's output.

    Example:
    >>> with ContextManagerCaptureOutput() as cmco:
    ...     print("hey")
    ...     assert cmco.get_output() == "hey"
    c                 C   s2   d| _ zdd l}W n ty,   tdƒ‚Y n0 d S )Nrl   r   z'The mock module needs to be installed !)Úresult_export_objectÚmockrë   ÚImportError)rA   r@  r2   r2   r3   r4    s
    z$ContextManagerCaptureOutput.__init__c                 C   s4   dd l }| fdd„}| ¡ }||_tj| _|t_| S )Nr   c                 S   s   | j | 7  _ d S r.   )r?  )r§   Ú	decoratorr2   r2   r3   Úwrite  s    z4ContextManagerCaptureOutput.__enter__.<locals>.write)r@  ZMockrC  rd   ÚstdoutÚ
bck_stdout)rA   r@  rC  Zmock_stdoutr2   r2   r3   r6  	  s    z%ContextManagerCaptureOutput.__enter__c                 G   s   | j t_dS )NF)rE  rd   rD  )rA   Úexcr2   r2   r3   r=    s    z$ContextManagerCaptureOutput.__exit__Fc                 C   s$   | j  d¡r|rtt| j ƒƒS | j S )Nzb')r?  Ú
startswithr   Úeval)rA   Z
eval_bytesr2   r2   r3   Ú
get_output  s    z&ContextManagerCaptureOutput.get_outputN)F)r/   ra   rb   rc   r4  r6  r=  rI  r2   r2   r2   r3   r>  ÷  s
   	r>  c                 C   sf  |du rd}|r| S |dur,t  dt¡ |}|du r<tjj}d}|du r¤tr`td| d�}d}nDttjj	ƒ�( t
jtjj	gt
jd�j}W d  ƒ n1 sš0    Y  |dur´d	| }t|tƒ�r"| d
¡rìt
j|dd…  ¡ dt
jd�j}n6| d¡�rt|dd…  ¡ dƒ}nttj |¡dƒ}ttt |ƒ}t
jd||�p@d|�pHdf dt
j|t
jd�}| t| ƒ¡\}	}
|jdk�rŒtdt|
ƒ ƒ‚z| ¡  W n t�y¬   Y n0 |�rbt   ¡ }tj !|j"¡�sút  #d¡ t   ¡ | dk�r¼t$dt%ƒ �qb�q¼t�r tjj	tjj&k�r t '|j"¡ nBttjj	ƒ�$ t
 tjj	|j"g¡ W d  ƒ n1 �sX0    Y  dS )a	  Processes graph description using an external software.
    This method is used to convert a graphviz format to an image.

    :param graph: GraphViz graph description
    :param prog: which graphviz program to use
    :param format: output type (svg, ps, gif, jpg, etc.), passed to dot's "-T"
        option
    :param string: if not None, simply return the graph string
    :param target: filename or redirect. Defaults pipe to Imagemagick's
        display program
    :param options: options to be passed to prog
    NÚsvgz*type is deprecated, and was renamed formatFr}   )ri   T)Ústdinz-T%sú|rN   )ÚshellrK  ú>Úwbz
"%s" %s %srl   )rM  rK  rD  Ústderrr   z)GraphViz call failed (is it installed?):
gš™™™™™¹?rM   zHTemporary file '%s' could not be written. Graphic will not be displayed.)(ÚwarningsÚwarnÚDeprecationWarningr   r2  Údotr   rk   r1  ÚdisplayrŠ   ÚPopenÚPIPErK  r6   r7   rG  ÚlstripÚopenr…   r†   Úabspathr   r    ÚbytesÚcommunicater   Ú
returncoder‰   r   rv   rë   ÚtimeÚexistsru   Úsleepr   rq   Ú_defaultZ	startfile)Úgraphr2  ÚformatÚtargetr9   ÚstringÚoptionsZstart_viewerÚprocr  rP  Zwaiting_startr2   r2   r3   Údo_graph"  sx    þÿ&
ÿ
ýÿÿ

4rh  z{\tt\char123}z{\tt\char125}z{\tt\char92}z\^{}z\$z\#z\_z\&z\%z{\tt\char124}z{\tt\char126}z{\tt\char60}z{\tt\char62})Ú{Ú}ú\ú^ú$ú#r  ú&ú%rL  ú~ú<rN  c                 C   s"   d}| D ]}|t  ||¡7 }q|S )Nrl   )Ú_TEX_TRÚget)r;   r§   Úcr2   r2   r3   Ú
tex_escapeŠ  s    rv  c               
   o   s¶   t | ƒdk r| d9 } | ddd„ ¡}tt | ƒƒD ]~}tt | ƒƒD ]l}tt | ƒƒD ]Z}||ksl||ksl||krP|| || t | ƒ  | || t | ƒ  | || t | ƒ  ƒV  qPq@q0q$dS )z�Returns a generator that mixes provided quantities forever
    trans: a function to convert the three arguments into a color. lambda x,y,z:(x,y,z) by defaultrß   Útransc                 S   s
   | ||fS r.   r2   )r;   rÔ   r1   r2   r2   r3   rÂ   š  r5   zcolgen.<locals>.<lambda>N)r¢   rt  r   )ZlstcolÚkargsrw  r�   r‚   rÅ   r2   r2   r3   Úcolgen’  s    ry  útag%05ic                 c   s   | | V  |d7 }q d S )NrN   r2   )ÚlabelÚstartr2   r2   r3   Úincremental_label£  s    
r}  c                 C   s   t | ƒdd … S ©Nrß   )Úbin)Úvalr2   r2   r3   Úbinreprª  s    r�  c                 C   s   t |  dd¡ dd¡dƒS )Nr    rl   r°   rž   )rî   rÀ   rµ   r2   r2   r3   Úlong_converter¯  s    r‚  c                   @   sT   e Zd Zdd„ Zdd„ Zdd„ Zdd„ Zd	d
„ Zdd„ Zdd„ Z	dd„ Z
dd„ ZdS )ÚEnumElementc                 C   s   || _ || _d S r.   )Ú_keyÚ_value)rA   ÚkeyÚvaluer2   r2   r3   r4  ¹  s    zEnumElement.__init__c                 C   s    d| j  d| jj¡| j| jf S )Nz<%s %s[%r]>Ú_name)Ú__dict__rt  rZ   r/   r„  r…  r5  r2   r2   r3   Ú__repr__¾  s    zEnumElement.__repr__c                 C   s   t | j|ƒS r.   )Úgetattrr…  ©rA   Úattrr2   r2   r3   Ú__getattr__Â  s    zEnumElement.__getattr__c                 C   s   | j S r.   )r„  r5  r2   r2   r3   Ú__str__Æ  s    zEnumElement.__str__c                 C   s   t |  ¡ ƒS r.   )r   r�  r5  r2   r2   r3   Ú	__bytes__Ê  s    zEnumElement.__bytes__c                 C   s   | j S r.   )r…  r5  r2   r2   r3   Ú__hash__Î  s    zEnumElement.__hash__c                 C   s
   t | jƒS r.   )rî   r…  r5  r2   r2   r3   Ú__int__Ò  s    zEnumElement.__int__c                 C   s   | j t|ƒkS r.   )r…  rî   rD   r2   r2   r3   rW   Ö  s    zEnumElement.__eq__c                 C   s   |   |¡ S r.   )rW   rD   r2   r2   r3   Ú__neq__Ú  s    zEnumElement.__neq__N)r/   ra   rb   r4  rŠ  rŽ  r�  r�  r‘  r’  rW   r“  r2   r2   r2   r3   rƒ  ¸  s   rƒ  c                       sB   e Zd ZeZ‡ fdd„Zdd„ Zdd„ Zddd	„Zd
d„ Z	‡  Z
S )ÚEnum_metaclassc                    s\   i }t  |¡D ].\}}t|tƒr|  ||¡}|||< |||< q||d< tt| ƒ | |||¡S )NÚ	__rdict__)r˜   Ú	iteritemsr6   rî   Úelement_classrV   r”  Ú__new__)Úclsru   ÚbasesÚdctZrdictrÅ   r–   rY   r2   r3   r˜  â  s    

zEnum_metaclass.__new__c                 C   s
   | j | S r.   ©r•  rŒ  r2   r2   r3   Ú__getitem__í  s    zEnum_metaclass.__getitem__c                 C   s
   || j v S r.   rœ  )rA   r€  r2   r2   r3   Ú__contains__ñ  s    zEnum_metaclass.__contains__Nc                 C   s   | j  ||¡S r.   )r•  rt  )rA   r�  r€  r2   r2   r3   rt  õ  s    zEnum_metaclass.getc                 C   s   d| j  d| j¡ S )Nz<%s>ru   )r‰  rt  r/   r5  r2   r2   r3   rŠ  ù  s    zEnum_metaclass.__repr__)N)r/   ra   rb   rƒ  r—  r˜  r�  rž  rt  rŠ  rf   r2   r2   rY   r3   r”  ß  s   
r”  c                 C   s,   dd l }tt| tjj | d¡d¡ƒƒ d S )Nr   rß   é	   )Úzlibr¤   r   Úcompressr˜   ÚmovesÚcPickleÚdumps©Úobjr   r2   r2   r3   Úexport_object  s    r§  c                 C   s6   dd l }| d u rtj ¡ } tjj | t	|  
¡ ƒ¡¡S )Nr   )r   rd   rK  Úreadr˜   r¢  r£  ÚloadsÚ
decompressr   Ústripr¥  r2   r2   r3   Úimport_object	  s    
r¬  c                 C   s(   t  | d¡}tjj ||¡ | ¡  dS )zPickle a Python objectrO  N)ÚgziprY  r˜   r¢  r£  r¦   rv   )Úfnamer¦  rj   r2   r2   r3   Úsave_object  s    r¯  c                 C   s   t jj t | d¡¡S )zunpickle a Python objectÚrb)r˜   r¢  r£  Úloadr­  rY  )r®  r2   r2   r3   Úload_object  s    r²  ç{®Gáz„?c                 C   sz   t   dt| ƒ¡}t|ƒ}|du r2tdt|| ƒƒ}t t|ƒ|¡D ] }|| t dd¡ d ||< qBt	j
rr| ¡ S | ¡ S )z]
    Corrupt a given percentage (at least one byte) or number of bytes
    from a string
    rú   NrN   rÞ   é   )rá   r   r¢   rÊ   rî   rþ   Úsampler   rÿ   r˜   ÚPY2ÚtostringÚtobytes©Údatar¥   Únr§   Zs_lenr�   r2   r2   r3   Úcorrupt_bytes   s    r¼  c                 C   s~   t   dt| ƒ¡}t|ƒd }|du r6tdt|| ƒƒ}t t|ƒ|¡D ] }||d   d|d > N  < qFtj	rv| 
¡ S | ¡ S )zX
    Flip a given percentage (at least one bit) or number of bits
    from a string
    rú   rÝ   NrN   )rá   r   r¢   rÊ   rî   rþ   rµ  r   r˜   r¶  r·  r¸  r¹  r2   r2   r3   Úcorrupt_bits0  s    r½  c                 O   sD   t | g|¢R i |¤Ž�}| |¡ W d  ƒ n1 s60    Y  dS )a8  Write a list of packets to a pcap file

    :param filename: the name of the file to write packets to, or an open,
        writable file-like object. The file descriptor will be
        closed at the end of the call, so do not use an object you
        do not want to close (e.g., running wrpcap(sys.stdout, [])
        in interactive mode will crash Scapy).
    :param gz: set to 1 to save a gzipped capture
    :param linktype: force linktype value
    :param endianness: "<" or ">", force endianness
    :param sync: do not bufferize writes to the capture file
    N)Ú
PcapWriterrC  ©Úfilenamerã   Úargsrx  Úfdescr2   r2   r3   ÚwrpcapD  s    rÃ  c                 C   s6   t | ƒ�}| |¡ W d  ƒ n1 s(0    Y  dS )a�  Write a list of packets to a pcapng file

    :param filename: the name of the file to write packets to, or an open,
        writable file-like object. The file descriptor will be
        closed at the end of the call, so do not use an object you
        do not want to close (e.g., running wrpcapng(sys.stdout, [])
        in interactive mode will crash Scapy).
    :param pkt: packets to write
    N)ÚPcapNgWriterrC  )rÀ  rã   rÂ  r2   r2   r3   Úwrpcapng[  s    
rÅ  r¡   c                 C   s8   t | ƒ�}|j|d�W  d  ƒ S 1 s*0    Y  dS )zeRead a pcap or pcapng file and return a packet list

    :param count: read only <count> packets
    ©ÚcountN)Ú
PcapReaderÚread_all©rÀ  rÇ  rÂ  r2   r2   r3   Úrdpcapm  s    
rË  c                       s4   e Zd ZdZ‡ fdd„Zdd„ Zedd„ ƒZ‡  ZS )ÚPcapReader_metaclassz"Metaclass for (Raw)Pcap(Ng)Readersc                    s,   t t| ƒ | |||¡}d|v r(||d _|S )zxThe `alternative` class attribute is declared in the PcapNg
        variant, and set here to the Pcap variant.

        Úalternative)rV   rÌ  r˜  rÍ  )r™  ru   rš  r›  ZnewclsrY   r2   r3   r˜  ‡  s    
ÿ
zPcapReader_metaclass.__new__c              	   C   sÀ   |   | | j| j| j¡}|  |¡\}}}|s2tdƒ‚z| |||¡ |W S  ttfy\   Y n0 d| jv r´| jd } |   | | j| j| j¡}z| |||¡ |W S  ttfy²   Y n0 tdƒ‚dS )zNCreates a cls instance, use the `alternative` if that
        fails.

        zNo data could be read!rÍ  úNot a supported capture fileN)r˜  r/   r8   r‰  rY  r   r4  ÚEOFError)r™  rÀ  r�   rÂ  Úmagicr2   r2   r3   Ú__call__”  s(    ÿ

zPcapReader_metaclass.__call__c                 C   sv   t | tƒrR| }zt |d¡}| d¡}W ql tyN   t|dƒ}| d¡}Y ql0 n| }t|ddƒ}| d¡}|||fS )z1Open (if necessary) filename, and read the magic.r°  r!  ru   úNo name©r6   r7   r­  rY  r¨  ÚIOErrorr‹  )r®  rÀ  rÂ  rÐ  r2   r2   r3   rY  ±  s    


zPcapReader_metaclass.open)	r/   ra   rb   rc   r˜  rÑ  ÚstaticmethodrY  rf   r2   r2   rY   r3   rÌ  „  s
   rÌ  c                   @   s¢   e Zd ZdZdZe dg d¢¡Zd!dd„Zdd	„ Z	d
d„ Z
dd„ Zefdd„Zefdd„Zdd„ Zd"dd„Zefdd„Zdd„ Zdd„ Zdd„ Zed#dd „ƒZdS )$ÚRawPcapReaderz;A stateful pcap reader. Each packet is returned as a stringTÚPacketMetadata©ÚsecÚusecÚwirelenÚcaplenNc                 C   s¾   || _ || _|dkr"d| _d| _nN|dkr8d| _d| _n8|dkrNd| _d| _n"|dkrdd| _d| _ntd	| ƒ‚| j d
¡}t|ƒd
k r�tdƒ‚t | jd |¡\}}}}}	}
|
| _	|	| _
d S )Ns   ¡²ÃÔrN  Fs   ÔÃ²¡rr  s   ¡²<MTs   M<²¡z'Not a pcap capture file (bad magic: %r)é   zInvalid pcap file (too short)ZHHIIII)rÀ  rw   ÚendianÚnanor   r¨  r¢   rü   r  ÚlinktypeÚsnaplen)rA   rÀ  rÂ  rÐ  ÚhdrZvermajZverminÚtzÚsigrá  rà  r2   r2   r3   r4  Ñ  s2    ÿ
ÿzRawPcapReader.__init__c                 C   s   | S r.   r2   r5  r2   r2   r3   Ú__iter__î  s    zRawPcapReader.__iter__c                 C   s&   z
|   ¡ W S  ty    t‚Y n0 dS )zT
        implement the iterator protocol on a set of packets in a pcap file
        N)Ú_read_packetrÏ  ÚStopIterationr5  r2   r2   r3   Únextò  s    
zRawPcapReader.nextc                 C   s   |   ¡ S r.   )rè  r5  r2   r2   r3   Ú__next__ü  s    zRawPcapReader.__next__c                 C   s\   | j  d¡}t|ƒdk rt‚t | jd |¡\}}}}| j  |¡d|… tj||||d�fS )z¤return a single packet read from the file as a tuple containing
        (pkt_data, pkt_metadata)

        raise EOFError when no more packets are available
        rž   ÚIIIINrØ  )	rw   r¨  r¢   rÏ  rü   r  rÞ  rÖ  r×  )rA   Úsizerâ  rÙ  rÚ  rÜ  rÛ  r2   r2   r3   ræ     s    ÿÿzRawPcapReader._read_packetc                 C   s   t dƒ‚d S )Nz>Cannot call read_packet() in RawPcapReader. Use _read_packet())rë   ©rA   rë  r2   r2   r3   Úread_packet  s    ÿzRawPcapReader.read_packetc                 C   s   | D ]}||ƒ qdS )zÑcall the specified callback routine for each packet read

        This is just a convenience function for the main loop
        that allows for easy launching of packet processing in a
        thread.
        Nr2   )rA   Úcallbackr¥   r2   r2   r3   Údispatch  s    
zRawPcapReader.dispatchr¡   c                 C   sH   g }|dkrD|d8 }z|   ¡ }W n ty6   Y qDY n0 | |¡ q|S )z6return a list of all packets in the pcap file
        r   rN   )rí  rÏ  rt   )rA   rÇ  Úresr¥   r2   r2   r3   Ú	_read_all#  s    
zRawPcapReader._read_allc                 C   s   | j |d�d S )z Emulate a socket
        ©rë  r   )ræ  rì  r2   r2   r3   Úrecv1  s    zRawPcapReader.recvc                 C   s   t rdS | j ¡ S ©Nr¡   ©r   rw   Úfilenor5  r2   r2   r3   rö  7  s    zRawPcapReader.filenoc                 C   s
   | j  ¡ S r.   ©rw   rv   r5  r2   r2   r3   rv   ;  s    zRawPcapReader.closec                 C   s   |   ¡  d S r.   )rv   ©rA   r9  r:  Ztracbackr2   r2   r3   r=  ?  s    zRawPcapReader.__exit__c                 C   s   | S r.   r2   )ÚsocketsZremainr2   r2   r3   ÚselectD  s    zRawPcapReader.select)NN)r¡   )N)r/   ra   rb   rc   Znonblocking_socketÚcollectionsÚ
namedtupler×  r4  rå  rè  ré  r   ræ  rí  rï  rñ  ró  rö  rv   r=  rÕ  rú  r2   r2   r2   r3   rÖ  Å  s(   ÿ


 ÿrÖ  c                       sP   e Zd Zddd„Zdd„ Zef‡ fdd„	Zefdd	„Zd
d„ Zddd„Z	‡  Z
S )rÈ  Nc                 C   sj   t  | |||¡ ztjj| j | _W n@ tyd   td| j| jf ƒ tj	d u rXdd l
}tj	| _Y n0 d S )Nz9PcapReader: unknown LL type [%i]/[%#x]. Using Raw packetsr   )rÖ  r4  r   Úl2typesÚ	num2layerrà  ÚLLclsÚKeyErrorr   Ú	raw_layerÚscapy.packet)rA   rÀ  rÂ  rÐ  rm   r2   r2   r3   r4  M  s    ÿ

zPcapReader.__init__c                 C   s   | S r.   r2   r5  r2   r2   r3   r6  [  s    zPcapReader.__enter__c           	         sÒ   t t| ƒj|d�}|d u rt‚|\}}z|  |¡}W n` tyH   ‚ Y nN ty”   tjrtddl	m
} | j|f|_‚ tjd u r†dd l}t |¡}Y n0 tdƒt| jr¨dndƒ }t|j||j  ƒ|_|j|_|S )Nrò  r   ©Údebugé
   é÷ÿÿÿiúÿÿÿ)rV   rÈ  ræ  rÏ  rÿ  r�   rë   r   Údebug_dissectorÚscapy.sendrecvr  Ú
crashed_onr  r  r   rß  r>   rÙ  rÚ  r^  rÛ  )	rA   rë  Úrpr§   Zpkt_infor¥   r  rm   ÚpowerrY   r2   r3   rí  _  s(    
zPcapReader.read_packetc                 C   s   | j |d�S )Nrò  ©rí  rì  r2   r2   r3   ró  x  s    zPcapReader.recvc                 C   s&   z
|   ¡ W S  ty    t‚Y n0 d S r.   )rí  rÏ  rç  r5  r2   r2   r3   rè  |  s    
zPcapReader.nextr¡   c                 C   s.   |   |¡}ddlm} |j|tj | j¡d�S )Nr   )Úplist)ru   )rñ  rm   r  r,   r…   r†   ÚbasenamerÀ  )rA   rÇ  rð  r  r2   r2   r3   rÉ  ƒ  s    
zPcapReader.read_all)NN)r¡   )r/   ra   rb   r4  r6  r   rí  ró  rè  rÉ  rf   r2   r2   rY   r3   rÈ  L  s   
rÈ  c                   @   sŽ   e Zd ZdZeZe dg d¢¡Zddd„Z	e
fdd„Zd	d
„ Zdd„ Ze
fdd„Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ ZdS )ÚRawPcapNgReaderzEA stateful pcapng reader. Each packet is returned as
    bytes.

    ZPacketMetadataNg©rà  ÚtsresolÚtshighÚtslowrÛ  ÚcommentNc                 C   s~   || _ || _g | _ddi| _| j| j| j| j| jdœ| _	d| _
|dkrRtd| ƒ‚z|  ¡  W n tyx   tdƒ‚Y n0 d S )Nr  é@B )rN   rß   rM   rô   r  ú!ó   

z)Not a pcapng capture file (bad magic: %r)z/The first SHB of the pcapng file is malformed !)rÀ  rw   Ú
interfacesÚdefault_optionsÚ_read_block_idbÚ_read_block_pktÚ_read_block_spbÚ_read_block_epbÚ_read_block_dsbÚ
blocktypesrÞ  r   Ú_read_block_shbrÏ  ©rA   rÀ  rÂ  rÐ  r2   r2   r3   r4  —  s,    ÿûÿÿzRawPcapNgReader.__init__c                 C   sÒ   z"t  | jd | j d¡¡d }W n t jy:   t‚Y n0 |dkrP|  ¡  d S z"t  | jd | j d¡¡d }W n t jyŠ   t‚Y n0 |dk r tdƒ t‚| j |d ¡}|  	|¡ | j
 |dd„ ¡||ƒS )	NÚIr!  r   i

é   zInvalid block length !c                 S   s   d S r.   r2   )Úblockrë  r2   r2   r3   rÂ   Ê  r5   z-RawPcapNgReader._read_block.<locals>.<lambda>)rü   r  rÞ  rw   r¨  r  rÏ  r   r   Ú_read_block_tailr  rt  )rA   rë  Z	blocktypeÚblocklenr$  r2   r2   r3   Ú_read_blockµ  s,    "
"

þýzRawPcapNgReader._read_blockc                 C   sv   |d r*| j  | d ¡}td||f ƒ z.|t | jd | j  d¡¡d krVtdƒ‚W n tjyp   t‚Y n0 d S )Nr!  zDPcapNg: bad blocklen %d (MUST be a multiple of 4. Ignored padding %rr"  r   z+PcapNg: Invalid pcapng block (bad blocklen))rw   r¨  r   rü   r  rÞ  rÏ  r  )rA   r&  Úpadr2   r2   r3   r%  Í  s    ÿ
ÿÿz RawPcapNgReader._read_block_tailc                 C   s–   | j  d¡}| j  d¡}|dkr(d| _n|dkr8d| _ntdƒ t‚t | jd |¡d }|d	k rntd
ƒ t‚| j  |d	 ¡}|  |¡ |  |¡ d S )Nr!  s   +<MrN  ó   M<+rr  z6Bad magic in Section Header block (not a pcapng file?)r"  r   rž   zInvalid SHB block length!)	rw   r¨  rÞ  r   rÏ  rü   r  r%  Ú_read_options)rA   Z	_blocklenrÞ  r&  rf  r2   r2   r3   r   Ú  s    
zRawPcapNgReader._read_block_shbc                 C   s   |   ¡ }|dur |S q dS )z¦Read blocks until it reaches either EOF or a packet, and
        returns None or (packet, (linktype, sec, usec, wirelen)),
        where packet is a string.

        N)r'  )rA   rë  rð  r2   r2   r3   ræ  î  s    zRawPcapNgReader._read_packetc                 C   s(  | j  ¡ }t|ƒdk�r$t | jd |dd… ¡\}}|dkrz|dkrzt|ƒdkrzt|d ƒ}|d@ rjdnd	|d
@  |d< |dkrØ|dkrØd| t|ƒk rØ|dd| … }| d¡}|dkrÈtdƒ �q$|d|… |d< |dkrø|dkrôtd| ƒ �q$|d �r|d|d  7 }|d| d… }q
|S )zSection Header Blockr!  ÚHHNrŸ  rN   é   r%  rß   r  r|   r  ó   
r¡   zPcapNg: invalid comment optionr  r   z2PcapNg: invalid option length %d for end-of-option)	r  Úcopyr¢   rü   r  rÞ  r   Úfindr   )rA   rf  ÚoptsÚcoder  r  r  Znewline_indexr2   r2   r3   r*  ú  s.    
ÿ 

zRawPcapNgReader._read_optionsc                 C   st   |   |dd… ¡}z(t | jd |dd… ¡|d f }W n( tjyb   tdt|ƒ ƒ t‚Y n0 | j 	|¡ dS )zInterface Description BlockrÝ   éüÿÿÿZHxxINr  zPcapNg: IDB is too small %d/8 !)
r*  rü   r  rÞ  r  r   r¢   rÏ  r  rt   )rA   r$  r  rf  Ú	interfacer2   r2   r3   r    s    
þý
zRawPcapNgReader._read_block_idbc                 C   s*   t | jƒ}||kr&td||f ƒ t‚dS )z;Check the interface id value and raise EOFError if invalid.z"PcapNg: invalid interface id %d/%dN)r¢   r  r   rÏ  )rA   ÚintidÚtmp_lenr2   r2   r3   Ú_check_interface_id(  s    
z#RawPcapNgReader._check_interface_idc              	   C   sà   z(t  | jd |dd… ¡\}}}}}W n( t jyP   tdt|ƒ ƒ t‚Y n0 |d rnd| | d  }nd| }|  ||d… ¡}	|	 dd¡}
|  	|¡ |dd| … d|… t
j| j| d | j| d ||||
d	�fS )
zEnhanced Packet BlockZ5INrÝ  z PcapNg: EPB is too small %d/20 !r!  r  r   rß   r  )rü   r  rÞ  r  r   r¢   rÏ  r*  rt  r6  r  r×  r  )rA   r$  rë  r4  r  r  rÜ  rÛ  Z
opt_offsetrf  r  r2   r2   r3   r  0  s.    
þ

ûÿzRawPcapNgReader._read_block_epbc              	   C   s®   d}|   |¡ z t | jd |dd… ¡\}W n( tjyV   tdt|ƒ ƒ t‚Y n0 t|| j	| d ƒ}|dd| … d|… t
j| j	| d | j	| d dd|dd�fS )	zSimple Packet Blockr   r"  Nr!  zPcapNg: SPB is too small %d/4 !rN   rß   r  )r6  rü   r  rÞ  r  r   r¢   rÏ  rÎ   r  r  r×  )rA   r$  rë  r4  rÛ  rÜ  r2   r2   r3   r  P  s"    
 
ûÿzRawPcapNgReader._read_block_spbc           	   	   C   s    z*t  | jd |dd… ¡\}}}}}}W n( t jyR   tdt|ƒ ƒ t‚Y n0 |  |¡ |dd| … d|… tj	| j
| d | j
| d |||dd�fS )z(Obsolete) Packet BlockZHH4INrÝ  z PcapNg: PKT is too small %d/20 !r   rß   r  )rü   r  rÞ  r  r   r¢   rÏ  r6  r  r×  r  )	rA   r$  rë  r4  Zdropsr  r  rÜ  rÛ  r2   r2   r3   r  h  s$    
þ

ûÿzRawPcapNgReader._read_block_pktc                 C   sL  z.t  | jd |dd… ¡\}}|dd… }W n& t jyT   tdt|ƒƒ t‚Y n0 || d  }t|ƒ|k r|tdƒ t‚|d|… d|… }||d… r¤tdƒ |dk�r>ttd	d
ƒd
u rÈtdƒ ntddl	m
} tƒ }t|dƒ�"}	|	 |¡ |	 ¡  W d  ƒ n1 �s0    Y  ||ƒ}
|
�s0tdƒ n|
t_dt_n
td|ƒ dS )zDecryption Secrets BlockZIINrÝ   zPcapNg: DSB is too small %d!r!  z#PcapNg: invalid DSB secrets length!z&PcapNg: DSB options are not supported!iKSLTÚtls_nss_keysFzkPcapNg: TLS Key Log available, but the TLS layer is not loaded! Scapy won't be able to decrypt the packets.r   )Úload_nss_keysrO  z#PcapNg: invalid TLS Key Log in DSB!Tz(PcapNg: Unknown DSB secrets type (0x%x)!)rü   r  rÞ  r  r   r¢   rÏ  r‹  r   Zscapy.layers.tls.sessionr8  rk   rY  rC  rv   r7  Ztls_session_enable)rA   r$  rë  Zsecrets_typeZsecrets_lengthZpadded_secrets_lengthZsecrets_datar8  rÀ  rj   Úkeysr2   r2   r3   r  }  s<    
þ



(
zRawPcapNgReader._read_block_dsb)NN)r/   ra   rb   rc   rÖ  rÍ  rû  rü  r×  r4  r   r'  r%  r   ræ  r*  r  r6  r  r  r  r  r2   r2   r2   r3   r  Š  s"   ÿ
 r  c                       sB   e Zd ZeZd
dd„Zdd„ Zef‡ fdd„	Zefdd	„Z	‡  Z
S )ÚPcapNgReaderNc                 C   s   t  | |||¡ d S r.   )r  r4  r!  r2   r2   r3   r4  ¶  s    zPcapNgReader.__init__c                 C   s   | S r.   r2   r5  r2   r2   r3   r6  º  s    zPcapNgReader.__enter__c                    sÂ   t t| ƒj|d�}|d u rt‚|\}\}}}}}}	ztjj| }
|
|ƒ}W nH ty^   ‚ Y n6 ty’   tj	rr‚ tj
d u r„dd l}t 
|¡}Y n0 |d ur²t|d> | ƒ| |_||_|	|_|S )Nrò  r   r{   )rV   r:  ræ  rÏ  r   rý  rþ  r�   rë   r  r  r  r>   r^  rÛ  r  )rA   rë  r
  r§   rà  r  r  r  rÛ  r  r™  r¥   rm   rY   r2   r3   rí  ¾  s(    
zPcapNgReader.read_packetc                 C   s   |   ¡ S r.   r  rì  r2   r2   r3   ró  Ö  s    zPcapNgReader.recv)NN)r/   ra   rb   rÈ  rÍ  r4  r6  r   rí  ró  rf   r2   r2   rY   r3   r:  ²  s
   
r:  c                   @   s@   e Zd ZdZdZdd„ Zddd„Zdd„ Zd	d
„ Zddd„Z	dS )ÚGenericPcapWriterFNc                 C   s   t ‚d S r.   ©ÚNotImplementedError©rA   rã   r2   r2   r3   Ú_write_headerß  s    zGenericPcapWriter._write_headerc                 C   s   t ‚d S r.   r<  ©rA   ÚpacketrÙ  rÚ  rÜ  rÛ  r  r2   r2   r3   Ú_write_packetã  s    	zGenericPcapWriter._write_packetc                 C   sb   t |dƒrF|d u rF|j}t|ƒ}tt|| | jr4dnd ƒƒ}t|ƒ}|d urZ|d u rZd}||fS )Nr^  é Êš;r  r   )Úhasattrr^  rî   Úroundrß  rX   )rA   rA  rÙ  rÚ  Zpacket_timeÚtmpr2   r2   r3   Ú	_get_timeî  s    

ÿzGenericPcapWriter._get_timec                 C   st   | j d u rfz*|d u st|tƒr"t‚tjj|j | _ W n0 tyd   d}t|| jj	|jj	ƒ t
| _ Y n0 |  |¡ d S )Nz3%s: unknown LL type for %s. Using type 1 (Ethernet))rà  r6   r[  r   r   rý  Z	layer2numrZ   r   r/   r   r?  )rA   rã   r<  r2   r2   r3   Úwrite_headerÿ  s    
ÿ
zGenericPcapWriter.write_headerc           	      C   sx   |   |||¡\}}t|ƒ}|du r*t|ƒn|}|du rFt|dƒrF|j}|du rR|}t|ddƒ}| j||||||d� dS )aW  
        Writes a single packet to the pcap file.

        :param packet: Packet, or bytes for a single packet
        :type packet: scapy.packet.Packet or bytes
        :param sec: time the packet was captured, in seconds since epoch. If
                    not supplied, defaults to now.
        :type sec: float
        :param usec: If ``nano=True``, then number of nanoseconds after the
                     second that the packet was captured. If ``nano=False``,
                     then the number of microseconds after the second the
                     packet was captured. If ``sec`` is not specified,
                     this value is ignored.
        :type usec: int or long
        :param caplen: The length of the packet in the capture file. If not
                       specified, uses ``len(raw(packet))``.
        :type caplen: int
        :param wirelen: The length of the packet on the wire. If not
                        specified, tries ``packet.wirelen``, otherwise uses
                        ``caplen``.
        :type wirelen: int
        :return: None
        :rtype: None
        NrÛ  r  )rÙ  rÚ  rÜ  rÛ  r  )rG  r   r¢   rD  rÛ  r‹  rB  )	rA   rA  rÙ  rÚ  rÜ  rÛ  Zf_secZrawpktr  r2   r2   r3   Úwrite_packet  s     
üzGenericPcapWriter.write_packet)NNNNN)NNNN)
r/   ra   rb   rß  rà  r?  rB  rG  rH  rI  r2   r2   r2   r3   r;  Û  s         ú
    ûr;  c                   @   sL   e Zd ZdZdZdZdZdd„ Zdd„ Zdd„ Z	d	d
„ Z
dd„ Zdd„ ZdS )ÚGenericRawPcapWriterFNc                 C   s   t rdS | j ¡ S rô  rõ  r5  r2   r2   r3   rö  J  s    zGenericRawPcapWriter.filenoc                 C   s
   | j  ¡ S r.   )rw   Úflushr5  r2   r2   r3   rK  N  s    zGenericRawPcapWriter.flushc                 C   s   | j s|  d ¡ | j ¡ S r.   )Úheader_presentrH  rw   rv   r5  r2   r2   r3   rv   R  s    
zGenericRawPcapWriter.closec                 C   s   | S r.   r2   r5  r2   r2   r3   r6  X  s    zGenericRawPcapWriter.__enter__c                 C   s   |   ¡  |  ¡  d S r.   )rK  rv   rø  r2   r2   r3   r=  \  s    zGenericRawPcapWriter.__exit__c                 C   sŠ   t |tƒr&| js|  |¡ |  |¡ n`ddlm} ||ƒjD ]H}| jsP|  |¡ t |tƒsz| jt	j
 t|ƒd¡krztdƒ |  |¡ q<dS )a   
        Writes a Packet, a SndRcvList object, or bytes to a pcap file.

        :param pkt: Packet(s) to write (one record for each Packet), or raw
                    bytes to write (as one record).
        :type pkt: iterable[scapy.packet.Packet], scapy.packet.Packet or bytes
        r   ©Ú
IterSocketNzRInconsistent linktypes detected! The resulting file might contain invalid packets.)r6   r[  rL  rH  rI  Úscapy.supersocketrN  Úiterrà  r   rý  rt  r9   r   ©rA   rã   rN  r¥   r2   r2   r3   rC  a  s    	



ÿzGenericRawPcapWriter.write)r/   ra   rb   rL  rß  Úsyncrw   rö  rK  rv   r6  r=  rC  r2   r2   r2   r3   rJ  D  s   rJ  c                   @   s:   e Zd ZdZddddddefdd„Zdd„ Zdd	d
„ZdS )ÚRawPcapWriterú4A stream PCAP writer with more control than wrpcap()NFrl   c	           
      C   sš   || _ || _|| _|| _|| _|| _|| _d}	|r6d}	t|tƒr‚|| _	|rjt
tt ||r\dp^dd¡ƒ| _q–t||rvdpxd|	ƒ| _n|| _t|ddƒ| _	dS )	a  
        :param filename: the name of the file to write packets to, or an open,
            writable file-like object.
        :param linktype: force linktype to a given value. If None, linktype is
            taken from the first writer packet
        :param gz: compress the capture on the fly
        :param endianness: force an endianness (little:"<", big:">").
            Default is native
        :param append: append packets to the capture file instead of
            truncating it
        :param sync: do not bufferize writes to the capture file
        :param nano: use nanosecond-precision (requires libpcap >= 1.5.0)

        é   r   ÚabrO  rŸ  ru   rÒ  N)rà  rá  rt   ÚgzrÞ  rR  rß  r6   r7   rÀ  r   Ú_ByteStreamr­  rY  rw   r‹  )
rA   rÀ  rà  rW  Z
endiannessrt   rR  rß  rá  Zbufszr2   r2   r3   r4  ‚  s&    
ÿ
zRawPcapWriter.__init__c                 C   s²   d| _ | jr^| jr"t | jd¡}nt| jdƒ}z$| d¡rHW | ¡  d S W | ¡  n
| ¡  0 | jd u rpt	dƒ‚| j
 t | jd | jrŒdnddd	d
d
| j| j¡¡ | j
 ¡  d S )NTr°  rž   zOlinktype could not be guessed. Please pass a linktype while creating the writerZIHHIIIIl   M<dC l   ÔCeC rß   r!  r   )rL  rt   rW  r­  rY  rÀ  r¨  rv   rà  rõ   rw   rC  rü   rý   rÞ  rß  rá  rK  )rA   rã   Úgr2   r2   r3   r?  ³  s&    
þ
ÿÿzRawPcapWriter._write_headerc           	   	   C   s¸   |du rt |ƒ}|du r|}|du s,|du rtt ¡ }t|ƒ}|du rh|}tt|| | jr\dnd ƒƒ}n|du rtd}| j t | j	d t|ƒ|||¡¡ | j |¡ | j
r´| j ¡  dS )añ  
        Writes a single packet to the pcap file.

        :param packet: bytes for a single packet
        :type packet: bytes
        :param sec: time the packet was captured, in seconds since epoch. If
                    not supplied, defaults to now.
        :type sec: float
        :param usec: not used with pcapng
                     packet was captured
        :type usec: int or long
        :param caplen: The length of the packet in the capture file. If not
                       specified, uses ``len(packet)``.
        :type caplen: int
        :param wirelen: The length of the packet on the wire. If not
                        specified, uses ``caplen``.
        :type wirelen: int
        :return: None
        :rtype: None
        NrC  r  r   rê  )r¢   r^  rî   rE  rß  rw   rC  rü   rý   rÞ  rR  rK  )	rA   rA  rÙ  rÚ  rÜ  rÛ  r  r<   Úitr2   r2   r3   rB  Ð  s(    
ÿ
ÿzRawPcapWriter._write_packet)NNNNN)r/   ra   rb   rc   r   r4  r?  rB  r2   r2   r2   r3   rS    s    ø
1     úrS  c                   @   sf   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	d
„Zdd„ Zdd„ Z	dd„ Z
dd„ Zddd„Zddd„ZdS )ÚRawPcapNgWriterú8A stream pcapng writer with more control than wrpcapng()c                 C   s6   d| _ d| _t| _d| _d| _|| _t|ddƒ| _d S )NFr  rr  r)  rO  rU  )	rL  r  r   rà  rÞ  Úendian_magicrÀ  rY  rw   )rA   rÀ  r2   r2   r3   r4    s    zRawPcapNgWriter.__init__c                 C   s0   t |dƒr|d u rt|jƒ}|d u r(d}||fS ©Nr^  r   ©rD  rX   r^  ©rA   rA  rÙ  rÚ  r2   r2   r3   rG    s    

zRawPcapNgWriter._get_timec                 C   s   |t |ƒ d d 7 }|S )Nr!  rà   rÃ   )rA   Úraw_datar2   r2   r3   Ú_add_padding$  s    zRawPcapNgWriter._add_paddingNc                 C   s^   |   |¡}|r||7 }dt|ƒ }|}|t | jd |¡7 }||7 }|t | jd |¡7 }|S )Nr#  r"  )rb  r¢   rü   rý   rÞ  )rA   Ú
block_typeZ
block_bodyrf  Zblock_total_lengthr$  r2   r2   r3   Úbuild_block)  s    
zRawPcapNgWriter.build_blockc                 C   s    | j sd| _ |  ¡  |  ¡  d S )NT)rL  Ú_write_block_shbÚ_write_block_idbr>  r2   r2   r3   r?  @  s    zRawPcapNgWriter._write_headerc                 C   sd   d}| j }|t | jd d¡7 }|t | jd d¡7 }|t | jd d¡7 }| j |  ||¡¡ d S )Nr  rÛ   rN   r   ÚQ)r]  rü   rý   rÞ  rw   rC  rd  )rA   rc  Z	block_shbr2   r2   r3   re  G  s    z RawPcapNgWriter._write_block_shbc                 C   sj   t  | jd d¡}t  | jd | j¡}|t  | jd d¡7 }|t  | jd d¡7 }| j |  ||¡¡ d S )Nr"  rN   rÛ   r   i   )rü   rý   rÞ  rà  rw   rC  rd  )rA   rc  Z	block_idbr2   r2   r3   rf  W  s
    z RawPcapNgWriter._write_block_idbc                 C   sH   t  | jd d¡}t  | jd t|ƒ¡}||7 }| j |  ||¡¡ d S )Nr"  rM   )rü   rý   rÞ  r¢   rw   rC  rd  )rA   Úraw_pktrc  Z	block_spbr2   r2   r3   Ú_write_block_spbe  s    z RawPcapNgWriter._write_block_spbc                 C   sJ  |r$t || j ƒ}|d? }|d@ }nd }}|s8t|ƒ}|sDt|ƒ}t | jd d¡}	t | jd d¡}
|
t | jd |¡7 }
|
t | jd |¡7 }
|
t | jd |¡7 }
|
t | jd |¡7 }
|
|7 }
d }|�r.t|ƒ}| d¡sì|d7 }t | jd dt|ƒ¡}||  t|ƒ¡7 }|t | jd dd¡7 }| j	 
| j|	|
|d	�¡ d S )
Nr{   r'  r   r"  rô   r-  r+  rN   )rf  )rî   r  r¢   rü   rý   rÞ  r   r£   rb  rw   rC  rd  )rA   rh  Ú	timestamprÜ  Úorglenr  Ztmp_tsZts_highZts_lowrc  Z	block_epbZcomment_optr2   r2   r3   Ú_write_block_epbq  s6    	

ÿz RawPcapNgWriter._write_block_epbc                 C   sD   |du rt |ƒ}|du r|}| j|||||d� | jr@| j ¡  dS )a~  
        Writes a single packet to the pcap file.

        :param packet: bytes for a single packet
        :type packet: bytes
        :param sec: time the packet was captured, in seconds since epoch. If
                    not supplied, defaults to now.
        :type sec: float
        :param caplen: The length of the packet in the capture file. If not
                       specified, uses ``len(packet)``.
        :type caplen: int
        :param wirelen: The length of the packet on the wire. If not
                        specified, uses ``caplen``.
        :type wirelen: int
        :return: None
        :rtype: None
        N)rj  rÜ  rk  r  )r¢   rl  rR  rw   rK  r@  r2   r2   r3   rB  ¥  s    
ÿzRawPcapNgWriter._write_packet)N)NNNN)NNNNN)r/   ra   rb   rc   r4  rG  rb  rd  r?  re  rf  ri  rl  rB  r2   r2   r2   r3   r[    s(   
    û
6     úr[  c                   @   s   e Zd ZdZdS )r¾  rT  N)r/   ra   rb   rc   r2   r2   r2   r3   r¾  Ê  s   r¾  c                   @   s   e Zd ZdZdd„ ZdS )rÄ  r\  c                 C   s0   t |dƒr|d u rt|jƒ}|d u r(d}||fS r^  r_  r`  r2   r2   r3   rG  Ò  s    

zPcapNgWriter._get_timeN)r/   ra   rb   rc   rG  r2   r2   r2   r3   rÄ  Ï  s   rÄ  c                 C   s8   t | ƒ�}|j|d�W  d  ƒ S 1 s*0    Y  dS )zZRead a ERF file and return a packet list

    :param count: read only <count> packets
    rÆ  N)ÚERFEthernetReaderrÉ  rÊ  r2   r2   r3   Úrderfâ  s    
rn  c                   @   s    e Zd Zdd„ Zedd„ ƒZdS )ÚERFEthernetReader_metaclassc              	   C   s®   |   | | j| j| j¡}|  |¡\}}z| ||¡ |W S  ttfyL   Y n0 d| jv r¢| jd } |   | | j| j| j¡}z| ||¡ |W S  ttfy    Y n0 tdƒ‚d S )NrÍ  rÎ  )r˜  r/   r8   r‰  rY  r4  r   rÏ  )r™  rÀ  r�   rÂ  r2   r2   r3   rÑ  î  s     

z$ERFEthernetReader_metaclass.__call__c                 C   sŒ   t | tƒrt| }zFt |d¡�}| d¡ W d  ƒ n1 s<0    Y  t |d¡}W q„ typ   t|dƒ}Y q„0 n| }t|ddƒ}||fS )zOpen (if necessary) filenamer°  rN   Nru   rÒ  rÓ  )r®  rÀ  rF  rÂ  r2   r2   r3   rY  	  s    
(z ERFEthernetReader_metaclass.openN)r/   ra   rb   rÑ  rÕ  rY  r2   r2   r2   r3   ro  í  s   ro  c                   @   s*   e Zd Zddd„Zdd„ Zefdd„ZdS )	rm  Nc                 C   s"   || _ || _tdƒtdƒ | _d S )Nr  r  )rÀ  rw   r   r  )rA   rÀ  rÂ  r2   r2   r3   r4  	  s    zERFEthernetReader.__init__c                 C   sB   |d? }|d@ }|d9 }||d@ d> 7 }|dL }t || j|  ƒS )Nr{   r'  rC  l        rN   )r>   r  )rA   r<   rÙ  Zfrac_secr2   r2   r3   Ú_convert_erf_timestamp"	  s    z(ERFEthernetReader._convert_erf_timestampc                 C   s<  | j  d¡}t|ƒdk rt‚t d|d d… ¡d }t d|dd … ¡\}}}}}|d@ dkrftdƒ‚|d@ rŒ| j  d¡}| j  |d	 ¡}n| j  |d ¡}|d|… }	dd
lm}
 z|
|	ƒ}	W nd t	yÔ   ‚ Y nR t
�y$   tj�rddlm} |
|f|_‚ tjd u �rdd l}t |¡}	Y n0 |  |¡|	_||	_|	S )Nrž   ú<QrÝ   r   z>BBHHHrß   zInvalid ERF Type (Not TYPE_ETH)r%  é   )ÚEtherr  )rw   r¨  r¢   rÏ  rü   r  r   Zscapy.layers.l2rs  r�   rë   r   r  r  r  r	  r  r  rp  r^  rÛ  )rA   rë  râ  r^  r9   r  ÚrlenZwlenr§   r¥   rs  r  rm   r2   r2   r3   rí  -	  s8    
zERFEthernetReader.read_packet)N)r/   ra   rb   r4  rp  r   rí  r2   r2   r2   r3   rm  	  s   
rm  c                 O   sD   t | g|¢R i |¤Ž�}| |¡ W d  ƒ n1 s60    Y  dS )a/  Write a list of packets to a ERF file

    :param filename: the name of the file to write packets to, or an open,
        writable file-like object. The file descriptor will be
        closed at the end of the call, so do not use an object you
        do not want to close (e.g., running wrerf(sys.stdout, [])
        in interactive mode will crash Scapy).
    :param gz: set to 1 to save a gzipped capture
    :param append: append packets to the capture file instead of
        truncating it
    :param sync: do not bufferize writes to the capture file
    N)ÚERFEthernetWriterrC  r¿  r2   r2   r3   Úwrerf_	  s    rv  c                       s:   e Zd ZdZd‡ fdd„	Zdd„ Zdd„ Zd	d
„ Z‡  ZS )ru  z;A stream ERF Ethernet writer with more control than wrerf()Fc                    s   t t| ƒj||||d� dS )aR  
        :param filename: the name of the file to write packets to, or an open,
            writable file-like object.
        :param gz: compress the capture on the fly
        :param append: append packets to the capture file instead of
            truncating it
        :param sync: do not bufferize writes to the capture file
        )rW  rt   rR  N)rV   ru  r4  )rA   rÀ  rW  rt   rR  rY   r2   r3   r4  y	  s
    ýzERFEthernetWriter.__init__c                 C   s*   ddl m} ||ƒjD ]}|  |¡ qdS )zÚ
        Writes a Packet, a SndRcvList object, or bytes to a ERF file.

        :param pkt: Packet(s) to write (one record for each Packet)
        :type pkt: iterable[scapy.packet.Packet], scapy.packet.Packet
        r   rM  N)rO  rN  rP  rI  rQ  r2   r2   r3   rC  �	  s    	zERFEthernetWriter.writec                 C   sÌ   t |dƒrDt|jƒ}ttt|j| d ƒƒd> d ƒ}|d> | }ntt ¡ ƒd> }t|ƒd }t |dƒrp|j}|d u r||}| j t 	d|¡¡ | j t 	ddd	|d	|d	¡¡ | j t
|ƒ¡ | j ¡  d S )
Nr^  rC  r{   é   rÛ  rq  z>BBHHHHrß   r   )rD  rî   r^  rE  r¢   rÛ  rw   rC  rü   rý   r[  rK  )rA   rã   rÙ  rÚ  r<   rt  rÛ  r2   r2   r3   rI  š	  s    

"
zERFEthernetWriter.write_packetc                 C   s
   | j  ¡ S r.   r÷  r5  r2   r2   r3   rv   ²	  s    zERFEthernetWriter.close)FFF)	r/   ra   rb   rc   r4  rC  rI  rv   rf   r2   r2   rY   r3   ru  v	  s      üru  c                 C   sœ   t  d¡}d}zf| r"t | ¡j}nt}|ƒ  ¡ }|s6qrz|| |¡ ¡ d 7 }W q& t	yn   t
dƒ Y q&Y q&0 q&W n ty†   Y n0 | dd¡}t|ƒS )zêImports a tcpdump like hexadecimal view

    e.g: exported via hexdump() or tcpdump or wireshark's "export as hex"

    :param input_string: String containing the hexdump input to parse. If None,
        read from standard input.
    z@^((0x)?[0-9a-fA-F]{2,}[ :\t]{,3}|) *(([0-9a-fA-F]{2} {,2}){,16})rl   rß   zParsing error during hexcapr°   )ÚreÚcompiler˜   ÚStringIOÚreadliner   r«  ÚmatchÚgroupsrë   r   rÏ  rÀ   r   )Zinput_stringZre_extract_hexcapr¥   Zinput_functionr×   r2   r2   r3   Úimport_hexcap·	  s$    


r~  c                 K   s   t | ftjj|dœ|¤ŽS )z³
    Runs Wireshark on a list of packets.

    See :func:`tcpdump` for more parameter description.

    Note: this defaults to wait=False, to run Wireshark in the background.
    )r2  Úwait)Útcpdumpr   r2  Ú	wireshark)Úpktlistr  Úkwargsr2   r2   r3   r�  Ø	  s    
r�  c                 K   s(   |du rdg}t | ftjj|dœ|¤ŽS )z—
    Run tshark on a list of packets.

    :param args: If not specified, defaults to ``tshark -V``.

    See :func:`tcpdump` for more parameters.
    Nz-V)r2  rÁ  )r€  r   r2  Ztshark)r‚  rÁ  rƒ  r2   r2   r3   Útdecodeå	  s    r„  c                 C   s   ddl m} tt|| ƒƒ ¡ S )z"Guess the DLT name from its value.r   )Úpcap_datalink_val_to_name)Úscapy.libs.winpcapyr…  r   r[  r-  )r‡  r…  r2   r2   r3   Ú_guess_linktype_nameø	  s    r‡  c                 C   s8   ddl m} tt||  ¡ ƒƒ}|dkr4td| ƒ tS |S )zGuess the value of a DLT name.r   )Úpcap_datalink_name_to_valr¡   z"Unknown linktype: %s. Using EN10MB)r†  rˆ  r   rî   Úencoder   r   )ru   rˆ  r€  r2   r2   r3   Ú_guess_linktype_valueÿ	  s    
rŠ  Tc                    sr  |p|}|du r,t jjs tdƒ‚t jjg}nt|tjƒr@|g}ntdƒ‚|
durÚt|
tƒr€zt	|
ƒ}W q¾ t
y|   d}
Y q¾0 n>|
 d¡r–|
dd… }
|
}zt|
ƒ}
W n ty¼   d}
Y n0 |
dkrÎtdƒ‚|d|g7 }|du règ }nt|ƒ}|du�r¸|
du �r–tˆ tƒ�r–tˆ ƒ�l}t|tƒ�rpz*| ¡ \}}|j}
t�rN|
d	k�rNt}
W n t�yl   td
ƒ‚Y n0 n|j}
W d  ƒ n1 �sŒ0    Y  ddlm} |||
d� | |¡ |�sÄ|�rÊtjnd}|�rÞttjƒnd}d‰|du �rt�o|d t jjk}|	du �rX|d t jj k�r,ddg}	n*|d t jjk�rNt�sNg d¢}	nddg}	nt|	ƒ}	ˆ du �r´t!|d |d��$ tj"|| ||d�‰W d  ƒ n1 �s¦0    Y  �n^tˆ tjƒ�rt!|d |d��, tj"|dˆ g | ||d�‰W d  ƒ n1 �s0    Y  �nþ|�rât#t$t%t& df ˆ ƒ‰ t'ddd�}z| (t)‡ fdd„dƒ¡ W n, t*�y„   t#dˆ ƒ‰ t+|ˆ |
d� Y n
0 | ,¡  t!|d |d��. tj"|d|j-g | ||d�‰W d  ƒ n1 �sÔ0    Y  �n0zXˆ  .¡  t!|d |d��* tj"||	 | ˆ ||d�‰W d  ƒ n1 �s.0    Y  W nÖ t*tf�y   t!|d |d��, tj"||	 | tj||d�‰W d  ƒ n1 �s’0    Y  ˆdu �r¬Y dS zˆj/ (t)‡ fdd„dƒ¡ W n6 t*�yî   t+ˆj/ˆ |
d� Y n t0�y    Y n0 ˆj/ ,¡  Y n0 ˆdu �r dS |�rJd 1t)‡fdd„dƒ¡}ˆ 2¡  |S |�rTˆS |�r`ˆj3S |�rnˆ 4¡  dS )a  Run tcpdump or tshark on a list of packets.

    When using ``tcpdump`` on OSX (``prog == conf.prog.tcpdump``), this uses a
    temporary file to store the packets. This works around a bug in Apple's
    version of ``tcpdump``: http://apple.stackexchange.com/questions/152682/

    Otherwise, the packets are passed in stdin.

    This function can be explicitly enabled or disabled with the
    ``use_tempfile`` parameter.

    When using ``wireshark``, it will be called with ``-ki -`` to start
    immediately capturing packets from stdin.

    Otherwise, the command will be run with ``-r -`` (which is correct for
    ``tcpdump`` and ``tshark``).

    This can be overridden with ``read_stdin_opts``. This has no effect when
    ``use_tempfile=True``, or otherwise reading packets from a regular file.

    :param pktlist: a Packet instance, a PacketList instance or a list of
        Packet instances. Can also be a filename (as a string), an open
        file-like object that must be a file format readable by
        tshark (Pcap, PcapNg, etc.) or None (to sniff)
    :param flt: a filter to use with tcpdump
    :param dump:    when set to True, returns a string instead of displaying it.
    :param getfd:   when set to True, returns a file-like object to read data
        from tcpdump or tshark from.
    :param getproc: when set to True, the subprocess.Popen object is returned
    :param args:    arguments (as a list) to pass to tshark (example for tshark:
        args=["-T", "json"]).
    :param prog:    program to use (defaults to tcpdump, will work with tshark)
    :param quiet:   when set to True, the process stderr is discarded
    :param use_tempfile: When set to True, always use a temporary file to store
        packets.
        When set to False, pipe packets through stdin.
        When set to None (default), only use a temporary file with
        ``tcpdump`` on OSX.
    :param read_stdin_opts: When set, a list of arguments needed to capture
        from stdin. Otherwise, attempts to guess.
    :param linktype: A custom DLT value or name, to overwrite the default
        values.
    :param wait: If True (default), waits for the process to terminate before
        returning to Scapy. If False, the process will be detached to the
        background. If dump, getproc or getfd is True, these have the same
        effect as ``wait=False``.

    Examples::

        >>> tcpdump([IP()/TCP(), IP()/UDP()])
        reading from file -, link-type RAW (Raw IP)
        16:46:00.474515 IP 127.0.0.1.20 > 127.0.0.1.80: Flags [S], seq 0, win 8192, length 0  # noqa: E501
        16:46:00.475019 IP 127.0.0.1.53 > 127.0.0.1.53: [|domain]

        >>> tcpdump([IP()/TCP(), IP()/UDP()], prog=conf.prog.tshark)
          1   0.000000    127.0.0.1 -> 127.0.0.1    TCP 40 20->80 [SYN] Seq=0 Win=8192 Len=0  # noqa: E501
          2   0.000459    127.0.0.1 -> 127.0.0.1    UDP 28 53->53 Len=0

    To get a JSON representation of a tshark-parsed PacketList(), one can::

        >>> import json, pprint
        >>> json_data = json.load(tcpdump(IP(src="217.25.178.5",
        ...                                  dst="45.33.32.156"),
        ...                               prog=conf.prog.tshark,
        ...                               args=["-T", "json"],
        ...                               getfd=True))
        >>> pprint.pprint(json_data)
        [{u'_index': u'packets-2016-12-23',
          u'_score': None,
          u'_source': {u'layers': {u'frame': {u'frame.cap_len': u'20',
                                              u'frame.encap_type': u'7',
        [...]
                                              },
                                   u'ip': {u'ip.addr': u'45.33.32.156',
                                           u'ip.checksum': u'0x0000a20d',
        [...]
                                           u'ip.ttl': u'64',
                                           u'ip.version': u'4'},
                                   u'raw': u'Raw packet data'}},
          u'_type': u'pcap_file'}]
        >>> json_data[0]['_source']['layers']['ip']['ip.ttl']
        u'64'
    Nztcpdump is not availablezprog must be a stringr¡   ZDLT_r!  z7Unknown linktype. Try passing its datalink name insteadz-yéä   z)Cannot get linktype from a PcapNg packet.r   )Úcompile_filter)rà  z-kiú-)z-Uú-rr�  rŽ  )r3  )rD  rP  r+   z.pcapT)ri   rj   c                      s
   ˆ   d¡S ©Ni   ©r¨  r2   ©r‚  r2   r3   rÂ   Û
  r5   ztcpdump.<locals>.<lambda>r5   )rK  rD  rP  c                      s
   ˆ   d¡S r�  r�  r2   r‘  r2   r3   rÂ     r5   c                      s   ˆ j  d¡S r�  )rD  r¨  r2   )rg  r2   r3   rÂ     r5   )5r   r2  r€  r   r6   r˜   Ústring_typesrõ   rî   r‡  rç  rG  rŠ  r   r�   r7   rÈ  r:  ræ  rà  r
   r   rÏ  Zscapy.arch.commonrŒ  rt   rŠ   rW  rY  r…   Údevnullr	   r�  r1  rV  r   r(   r    r[  rk   Ú
writelinesrP  ÚAttributeErrorrÃ  rv   ru   rö  rK  ÚUnboundLocalErrorrœ   Ú	terminaterD  r  )r‚  r¦   ZgetfdrÁ  Zfltr2  ZgetprocÚquietZuse_tempfileZread_stdin_optsrà  r  Z	_suppressZlinktype_nameÚrdr  ÚmetadatarŒ  rD  rP  Ztmpfilerº  r2   )r‚  rg  r3   r€  

  s   dÿ


ÿ

ÿ&






ý*ý*þÿ
ý*
ü*
ü&
ÿ
ÿr€  c                 C   sd   t ƒ }t|| ƒ ttjjƒ�" t tjj|g¡ W d  ƒ n1 sD0    Y  t|ƒ}t	 
|¡ |S )zARun hexedit on a list of packets, then return the edited packets.N)rk   rÃ  r1  r   r2  ÚhexeditrŠ   r‹   rË  r…   Úunlink)r‚  rw   Zrpktlistr2   r2   r3   r›    s    
0
r›  c                  C   s2  d} t js.ddl}|jdd�d } | dkr.| S tr ddlm}m} |j 	d¡}|dƒ}|j 
||¡}|rœt d|j¡\}}}	}
}}}}}}}|| d	 } | S | S zttjd
 ƒ} W n tyÄ   Y n0 | rÎ| S zFddl}ddl}t ddddd¡}| d	|j|¡}t d|¡d	 } W n t�y(   Y n0 | S dS )z§Get terminal width (number of characters) if in a window.

    Notice: this will try several methods in order to
    support as many terminals and OS as possible.
    Nr   )r   r   )Úfallback)ÚwindllÚcreate_string_bufferiôÿÿÿé   ZhhhhHhhhhhhrN   ÚCOLUMNSZHHHH)r˜   r¶  ÚshutilÚget_terminal_sizer   Úctypesrž  rŸ  Zkernel32ZGetStdHandleZGetConsoleScreenBufferInforü   r  Úrawrî   r…   Úenvironrë   ÚfcntlÚtermiosrý   ÚioctlÚ
TIOCGWINSZrÔ  )Zsizexr¢  rž  rŸ  ÚhZcsbirð  ZbufxZbufyZcurxZcuryZwattrrË   ÚtoprÌ   ÚbottomZmaxxZmaxyr§  r¨  r§   r;   r2   r2   r3   Úget_terminal_width(  sB    	ÿr®  c                    sD  |r
d}nd}t |d ƒ}t |ƒ|d  ttƒ }d}| j‡fdd„d� t| ƒD ]¸\‰}g }	g }
t|ƒD ]*\}}t|tƒrj|	 |¡ |
 |p�d	¡ qj|
rR| ˆ= d}t|
d
d	iŽD ]V}|rÆd	g| }nt|ƒ}t|	ƒD ]\}}|| ||< qÖ|  	ˆ| t
|ƒ¡ |d7 }q²qRttttdf  | ƒ}|| }dd„ t|Ž D ƒ}tƒ }tj�rè|�rè|| }t|ƒ|k�rèd}| t|ƒ¡‰‡fdd„|D ƒ}| t|ƒ¡}t|| ƒ}|ˆ dd… d |ˆ< t
|ƒ||< t |ˆ ƒ||< t|ƒ|ˆ< �qX|�røt d¡ | dd„ |D ƒ¡‰ |�r,| 	dt
dd„ |D ƒƒ¡ d ‡ fdd„|D ƒ¡S )aO  
    Pretty list to fit the terminal, and add header.

    :param rtlst: a list of tuples. each tuple contains a value which can
        be either a string or a list of string.
    :param sortBy: the column id (starting with 0) which will be used for
        ordering
    :param borders: whether to put borders on the table or not
    rL  r³   r   rN   Fc                    s   | ˆ  S r.   r2   rÁ   )ÚsortByr2   r3   rÂ   r  r5   zpretty_list.<locals>.<lambda>©r†  r°   Ú	fillvalue.c                 S   s   g | ]}t d d„ |D ƒƒ‘qS )c                 s   s   | ]}t |ƒV  qd S r.   rÃ   ©r0   rÔ   r2   r2   r3   r4   ‹  r5   z)pretty_list.<locals>.<listcomp>.<genexpr>)rÊ   r®   r2   r2   r3   r¼   ‹  r5   zpretty_list.<locals>.<listcomp>Tc                    s   g | ]}t |ˆ  ƒ‘qS r2   rÃ   r®   )r�   r2   r3   r¼   –  r5   Néþÿÿÿr  z?Table cropped to fit the terminal (conf.auto_crop_tables==True)c                 S   s   g | ]}d | ‘qS )z%%-%dsr2   r®   r2   r2   r3   r¼   £  r5   c                 s   s   | ]}d | V  qdS )r�  Nr2   r®   r2   r2   r3   r4   ¦  r5   zpretty_list.<locals>.<genexpr>r    c                 3   s   | ]}ˆ | V  qd S r.   r2   r®   )Úfmtr2   r3   r4   ¨  r5   )r¢   rî   r   ÚsortÚ	enumerater6   r�   rt   r   r¾   r›   r   r"   r&   r7   Úzipr®  r   Zauto_crop_tablesrÍ   ÚindexrÊ   r   Úinforœ   )ZrtlstÚheaderr¯  ZbordersZ_spaceÚcolsZ	_spacelenZ_cropedr×   ZidsÚvaluesr‚   r€  rÅ   Zex_valsZ
extra_liner«  ZrtslstÚcolwidthÚwidthÚrowr<   r2   )r´  r�   r¯  r3   Úpretty_listZ  s^    


rÀ  c	                    s‚  i ‰ i }	i }
i }t |ƒ}d}|D ]^}dd„ ||Ž D ƒ\}}}tt|ƒ|ƒ}tˆ  |d¡t|ƒt|ƒƒˆ |< d|	|< ||
||f< q tˆ ƒ}t|	ƒ}|r¢|j|d� nPz|jtd� W n> tyð   z|jtd� W n tyê   | ¡  Y n0 Y n0 |�r|j|d� nTz|jtd� W nB t�yX   z|jtd� W n t�yR   | ¡  Y n0 Y n0 d}|�rˆ||‡ fdd„|D ƒƒ}||d 7 }| |ƒ}||d 7 }|d	7 }|D ].}|ˆ | ƒ||< ||| | 7 }|d	7 }�q¨||d 7 }|�rö||d 7 }|D ]V}||| 7 }|d	7 }|D ]*}||| |
 ||fd
¡ 7 }|d	7 }�q||d 7 }�qú|�rd||d 7 }|�rn|S t	|dd� dS dS )z@Core function of the make_table suite, which generates the tabler   c                 S   s   g | ]}t |ƒ‘qS r2   )r7   )r0   r§   r2   r2   r3   r¼   Â  r5   z __make_table.<locals>.<listcomp>Nr°  rl   c                    s   g | ]}ˆ | ‘qS r2   r2   r®   ©Zvxr2   r3   r¼   á  r5   r    r°   r�  rÆ   )
r   rÊ   r¢   rt  r�   rµ  rî   rë   r  r¤   )ZyfmtfuncZfmtfuncÚendlinerº  ZfxyzZsortxZsortyÚseplinefuncr¦   ZvyZvzZvxfr5  ÚerÕ   rÖ   ÚzzZvxkZvykr§   Zsepliner´  r;   rÔ   r2   rÁ  r3   Ú__make_table«  sv     rÆ  c                  O   s"   t dd„ dd„ dg| ¢R i |¤ŽS )Nc                 S   s   d|  S ©Nz%%-%isr2   ©Úlr2   r2   r3   rÂ     r5   zmake_table.<locals>.<lambda>c                 S   s   d|  S rÇ  r2   rÈ  r2   r2   r3   rÂ     r5   rl   ©rÆ  ©rÁ  rx  r2   r2   r3   Ú
make_tableÿ  s    ýüûrÌ  c                  O   s*   t dd„ dd„ dg| ¢R ddd„ i|¤ŽS )Nc                 S   s   d|  S ©Nz%%-%is |r2   rÈ  r2   r2   r3   rÂ     r5   z"make_lined_table.<locals>.<lambda>c                 S   s   d|  S rÍ  r2   rÈ  r2   r2   r3   rÂ     r5   rl   rÃ  c                 S   s$   d  dd„ | d g| dg D ƒ¡S )Nú+c                 s   s   | ]}d |d  V  qdS )r�  rß   Nr2   r²  r2   r2   r3   r4     s   z5make_lined_table.<locals>.<lambda>.<locals>.<genexpr>rN   r³  r´   ©r·   r;   r2   r2   r3   rÂ     s   
ÿrÊ  rË  r2   r2   r3   Úmake_lined_table
  s    ýüûørÐ  c                  O   s*   t dd„ dd„ dg| ¢R ddd„ i|¤ŽS )Nc                 S   s   dS )Nz%sr2   rÈ  r2   r2   r3   rÂ     r5   z make_tex_table.<locals>.<lambda>c                 S   s   dS )Nz& %sr2   rÈ  r2   r2   r3   rÂ     r5   z\\rÃ  c                 S   s   dS )Nz\hliner2   rÏ  r2   r2   r3   rÂ     r5   rÊ  rË  r2   r2   r3   Úmake_tex_table  s    ýüûúrÑ  c                    sà   t | ƒ}zt |¡}W n ty,   |}Y n0 t tjtj¡}| d¡ | | d¡d ¡ d}| 	d¡}||7 }|s`qzq`| 
¡  d‰ ‡ fdd„| d	¡D ƒ}td
t|ƒƒD ] }||   ¡ sÈ|| = q¬ qÎq¬d	 |dd… ¡S )zWhois client for Python)zwhois.ripe.neté+   Úutf8s   
r5   rU  s   remarks:c                    s"   g | ]}|r|r|  ˆ ¡s|‘qS r2   )rG  )r0   r×   ©Z
ignore_tagr2   r3   r¼   <  r5   zwhois.<locals>.<listcomp>r-  rN   rM   N)r7   r  r  rë   ÚAF_INETÚSOCK_STREAMÚconnectÚsendr‰  ró  rv   rð   r   r¢   r«  rœ   )Ú
ip_addressZwhois_ipÚqueryr§   ZanswerÚdÚlinesr�   r2   rÔ  r3   Úwhois(  s*    



rÝ  c                   @   s&   e Zd Zd	dd„Zdd„ Zdd„ ZdS )
ÚPeriodicSenderThreadç      à?c                 C   sF   t |tƒstd|ƒg| _n|| _|| _t ¡ | _|| _tj	 
| ¡ dS )zÝ Thread to send packets periodically

        Args:
            sock: socket where packet is sent periodically
            pkt: packet or list of packets to send
            interval: interval between two packets
        r*   N)r6   r�   r   Ú_pktsÚ_socketÚ	threadingÚEventÚ_stoppedÚ	_intervalÚThreadr4  )rA   Úsockrã   Úintervalr2   r2   r3   r4  K  s    	

zPeriodicSenderThread.__init__c                 C   sR   | j  ¡ sN| jjsN| jD ]2}| j |¡ t | j¡ | j  ¡ sF| jjr q qq d S r.   )	rä  Úis_setrá  Úclosedrà  rØ  r^  r`  rå  )rA   r¥   r2   r2   r3   Úrun]  s    
zPeriodicSenderThread.runc                 C   s   | j  ¡  |  | jd ¡ d S r~  )rä  Úsetrœ   rå  r5  r2   r2   r3   Ústopf  s    
zPeriodicSenderThread.stopN)rß  )r/   ra   rb   r4  rë  rí  r2   r2   r2   r3   rÞ  J  s   
	rÞ  c                   @   s@   e Zd Zdd„ Zedd„ ƒZdd„ Zdd„ Zd	d
„ Zdd„ Z	dS )ÚSingleConversationSocketc                 C   s   || _ t ¡ | _d S r.   )Ú_innerrâ  ÚRLockÚ	_tx_mutex)rA   Úor2   r2   r3   r4  m  s    z!SingleConversationSocket.__init__c                 C   s   | j jS r.   )rï  r‰  r5  r2   r2   r3   r‰  r  s    z!SingleConversationSocket.__dict__c                 C   s   t | j|ƒS r.   )r‹  rï  )rA   ru   r2   r2   r3   rŽ  v  s    z$SingleConversationSocket.__getattr__c                 O   s<   | j �" | jj|i |¤ŽW  d   ƒ S 1 s.0    Y  d S r.   )rñ  rï  Úsr1©rA   rÁ  rx  r2   r2   r3   ró  z  s    zSingleConversationSocket.sr1c                 O   s<   | j �" | jj|i |¤ŽW  d   ƒ S 1 s.0    Y  d S r.   )rñ  rï  Úsrrô  r2   r2   r3   rõ    s    zSingleConversationSocket.src                 C   s~   | j �d z| j |¡W W  d   ƒ S  ttfyZ } z| j ¡  |‚W Y d }~n
d }~0 0 W d   ƒ n1 sp0    Y  d S r.   )rñ  rï  rØ  ÚConnectionErrorr‰   rv   )rA   r;   rÄ  r2   r2   r3   rØ  „  s    
zSingleConversationSocket.sendN)
r/   ra   rb   r4  Úpropertyr‰  rŽ  ró  rõ  rØ  r2   r2   r2   r3   rî  l  s   
rî  )Frl   F)Frl   F)F)F)F)r   r   F)F)r   r   F)F)NNNNNN)rz  r   )N)r³  N)r³  N)r¡   )r¡   )N)F)N)NFFNNNFFNNNTF)r   F)NNNF)±rc   Ú
__future__r   r   r[   r   rá   rû  rÉ   r­  r.  r…   rþ   rx  r  rü   rŠ   rd   rq   râ  r^  rQ  Zscapy.libs.sixZlibsr˜   Zscapy.libs.six.movesr   r   r   Zscapy.configr   Zscapy.constsr	   r
   r   Z
scapy.datar   r   r   Zscapy.compatr   r   r   r   r   r   r   r   Zscapy.errorr   r   r   Zscapy.pton_ntopr   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r  r*   Zscapy.plistr+   r,   rO  r-   Z_SuperSocketÚobjectr[  ÚGzipFilerX  r=   rî   Z_Decimalr>   rk   rz   rƒ   ÚcommandsÚregisterr�   r”   r¨   r¬   r¯   r«   r¶   rÚ   rý   râ   rä   rè   rê   rí   ró   rö   rù   r  r  r  r  r  r  r(  r  r  r   r$  r&  r)  r*  r0  r1  r>  rh  rs  rv  ry  r}  r�  r‚  rƒ  r9   r”  r§  r¬  r¯  r²  r¼  r½  rÃ  rÅ  rË  rÌ  Úadd_metaclassrÖ  rÈ  r  r:  r;  rJ  rS  r[  r¾  rÄ  rn  ro  rm  rv  ru  r~  r�  r„  r‡  rŠ  r€  r›  r®  rÀ  rÆ  rÌ  rÐ  rÑ  rÝ  ræ  rÞ  rî  r2   r2   r2   r3   Ú<module>   s”  (DL




{


				
		+-      ù
Xó
	'$
	

A >  *)i;  I
*G
A  þ             ó  
4  ý
W    ÷
T""