B

Ôà›534^ã@sèdZd
dl
mZ
d
dl
mZ
d
dlmZ
d
dlZd
dlZd
dlZd
dlZd
dl	Z	d
dl
Z
d
dlZd
dlZd
dl
Z
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlm
mZ
d
dlmZmZmZ
d
dlmZ
d
dlmZm Z m!Z!
d
d	l"m#Z#m$Z$
d
d
l%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-
d
dl.m/Z/m0Z0m1Z1
d
dl2m3Z3
d
d
l%m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZB
e>
r¾d
dlCmDZD
d
dlEmFZFmGZG
d
dlHmIZI
eIZJneKZJeAe9eLe	jMfZNdd„ZOeAeePfZQGdd„deƒZReBdd„ƒ
ZSeBdÀdd„
ƒ
ZSdÁdd„
ZSdÂdd„
ZTdÃdd„
ZUejVjWdd „ƒ
ZXd!d"„ZYejVjWdÄd#d$„
ƒ
ZZejVjWdÅd%d&„
ƒ
Z[ejVjWdÆd'd(„
ƒ
Z\ejVjWdÇd)d*„
ƒ
Z]d+d,„Z^ejVjWdÈd-d.„
ƒ
Z_e `d/d0¡d1krÆd2d3„Zand4d3„Zad5d6„Zbd7d8„ZcejVjWd9d:„ƒ
ZdejVjWd;d<„ƒ
Zed=d>„Zfd?d@„ZgdAdB„ZhdCdD„ZidEdF„ZjdGdH„ZkdIdJ„Zlye
 mdK¡

Wn e
jnk
rd


dLdM„ZmYnXe
jmZme
joZodNdO„ZpdPdQ„ZqdRdS„ZrdTdU„ZsdVdW„ZtdXdY„ZudZd[„ZvGd\d]„d]eKƒZwGd^d_„d_eKƒZxdÉd`da„
Zydbdcdddedfdgdhdidjdkdldmdndoœ
Zzdpdq„Z{drds„Z|dÊdudv„
Z}dwdx„Z~dydz„ZGd{d|„d|ƒZ€Gd}d~„d~eƒZ‚dd€„ZƒdËdd‚„
Z„dƒd„„Z…d…d†„Z†ejVjWdÌdˆd‰„
ƒ
Z‡ejVjWdÍdŠd‹„
ƒ
ZˆejVjWdŒd„ƒ
Z‰ejVjWdÎdd„
ƒ
ZŠGd‘d’„d’eƒZ‹e Œe‹¡
Gd“d”„d”ƒƒ
ZGd•d–„d–eeJƒZŽGd—d˜„d˜eƒZGd™dš„dšeeJƒZGd›dœ„dœƒZ‘Gddž„dže‘ƒZ’ejVjWdÏdŸd „
ƒ
Z“ejVjWdÐd¡d¢„
ƒ
Z”ejVjWdÑd£d¤„
ƒ
Z•d¥d¦„Z–d§d¨„Z—ejVjWdÒdªd«„
ƒ
Z˜ejVjWd¬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 Gd¼d½„d½ej¡ƒZ¢Gd¾d¿„d¿eKƒZ£dS)Õz
General utility functions.
é)
Úabsolute_import)
Úprint_function)
ÚDecimalN)ÚrangeÚinputÚzip_longest)
Úconf)ÚDARWINÚOPENBSDÚWINDOWS)ÚMTUÚ
DLT_EN10MB)Ú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)
ÚSuperSocketcCs:t|
t
ƒr|
d
d„|jDƒ
kSt|tƒr6t||
ƒr6dSdS)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
ss|]}
|
jV
qdS)
N)
Ú__name__)Ú.0Ú
z©r0ú/build/wlanpi-profiler-CSvHZ8/wlanpi-profiler-1.0.7~rc2/debian/wlanpi-profiler/opt/wlanpi-profiler/lib/python3.7/site-packages/scapy/utils.pyú	<genexpr>Xszissubtype.<locals>.<genexpr>TF)Ú
isinstanceÚstrÚ	__bases__ÚtypeÚ
issubclass)Ú
xÚ
tr0r0r1Ú	issubtypeMs






r:cs¬eZ
dZd
Zd$dd„
Zdd„Zdd„Zd	d
„Zdd„Zd
d„Z	dd„Z
dd„Zej
dkrbdd„Zndd„Zdd„Zdd„Zdd„Zd%dd„
Z‡f
d d!„Z‡f
d"d#„Z‡ZS)&ÚEDecimalznExtended Decimal

    This implements arithmetic and comparison with float for
    backward compatibility
    NcCstt
 |t
|
ƒ
¡ƒ
S)
N)r;rÚ__add__)ÚselfÚotherÚcontextr0r0r1r<hszEDecimal.__add__cCstt
 |t
|
ƒ
¡ƒ
S)
N)r;rr<)r=r>r0r0r1Ú__radd__lszEDecimal.__radd__cCstt
 |t
|
ƒ
¡ƒ
S)
N)r;rÚ__sub__)r=r>r0r0r1rApszEDecimal.__sub__cCstt
 |t
|
ƒ
¡ƒ
S)
N)r;rÚ__rsub__)r=r>r0r0r1rBtszEDecimal.__rsub__cCstt
 |t
|
ƒ
¡ƒ
S)
N)r;rÚ__mul__)r=r>r0r0r1rCxszEDecimal.__mul__cCstt
 |t
|
ƒ
¡ƒ
S)
N)r;rrC)r=r>r0r0r1Ú__rmul__|szEDecimal.__rmul__cCstt
 |t
|
ƒ
¡ƒ
S)
N)r;rÚ__truediv__)r=r>r0r0r1rE€szEDecimal.__truediv__cCstt
 |t
|
ƒ
¡ƒ
S)
N)r;rÚ__floordiv__)r=r>r0r0r1rF„szEDecimal.__floordiv__)
écCs(t 
|t|
ƒ
¡}t|d
ƒ
t|dƒ
fS)Nr
é
)rÚ
__divmod__r;)r=r>Ú
rr0r0r1rI‰s
zEDecimal.__divmod__cCstt
 |t
|
ƒ
¡ƒ
S)
N)r;rÚ__div__)r=r>r0r0r1rKŽszEDecimal.__div__cCstt
 |t
|
ƒ
¡ƒ
S)
N)r;rÚ__rdiv__)r=r>r0r0r1rL’szEDecimal.__rdiv__cCstt
 |t
|
ƒ
¡ƒ
S)
N)r;rÚ__mod__)r=r>r0r0r1rM–szEDecimal.__mod__cCstt
 |t
|
ƒ
¡ƒ
S)
N)r;rÚ__rmod__)r=r>r0r0r1rNšszEDecimal.__rmod__cCstt
 |t
|
ƒ
|¡ƒ
S)
N)r;rÚ__pow__)r=r>Zmodulor0r0r1rOžszEDecimal.__pow__cstt
|ƒ |
¡
pt|ƒ
|
kS)
N)Úsuperr;Ú__eq__Úfloat)r=r>)
Ú	__class__r0r1rQ¢szEDecimal.__eq__c	s.t 
¡}|
|_ttt|ƒ |¡
ƒ
SQRXdS)
N)ÚdecimalÚlocalcontextÚprecr;rPÚ	normalize)r=Z	precisionÚctx)
rSr0r1rW¦s


zEDecimal.normalize)
N)
N)r-Ú
__module__Ú__qualname__Ú__doc__r<r@rArBrCrDrErFÚsysÚversion_inforIrKrLrMrNrOrQrWÚ
__classcell__r0r0)
rSr1r;as$




r;c
CsdS)
Nr0)ÚkeepÚautoextÚfdr0r0r1Ú
get_temp_file­srbFÚc
CsdS)
Nr0)r_r`rar0r0r1rb³scCs<tj
d
|
dd}|s"tj |j¡

|r*|S| ¡
|jSdS)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)r_r`raÚ
fr0r0r1rb¹s	




c
Cs tj
d
d
}
|stj |
¡

|
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.
    rd)
re)rhÚmkdtemprrjrk)r_Zdnamer0r0r1Úget_temp_dirÏs	
rpcCsZd
}xP|D]H}t|ƒ
}|dks&|dkrF|
r<|t
j d¡
7}qR|d7}q
|t|ƒ
7}q
W|S)Nrcé éÚ
.)rrÚcolor_themeZ
not_printableÚchr)r8ÚcolorrJÚ
iÚ
jr0r0r1Úsaneàs







ryc
	Cs„tj
rtj tjd
¡
s tdƒ
‚
trhz6yt	 
tjg
tj¡
}Wntk
rV


d}YnXWdt 
|¡

Xt tjtjg
tj¡
dS)zRestarts scapyr
z"Scapy was not started from consolerHN)rÚinteractiveÚosÚpathÚisfiler\ÚargvÚOSErrorrÚ
subprocessÚcallÚ
executableÚKeyboardInterruptÚ_exitÚexecv)
Zres_coder0r0r1Úrestartïs






r†c
Cs|d
dlm
}

t||
ƒrt|ƒ
St|ƒ
tjkr4t|ƒ
St|tƒrRdd 	t
t|ƒ¡
St|tƒrpdd 	t
t|ƒ¡
St
|ƒ
SdS)Nr
)
Ú
VolatileValuez(%s)z, z[%s])Zscapy.volatiler‡r3Úreprr6ÚsixÚ
integer_typesÚhexÚtupleÚjoinÚmapÚlhexÚlistr4)r8r‡r0r0r1rÿs










rcCsÌd
}t|ƒ
}t
|ƒ
}d}x€||kr˜|d|7}x>tdƒ
D]2}|||krb|dt|||ƒ
7}q8|d7}q8W|dt|||d…dd	7}|d7}qW| d
¡
r°|dd…n|}|
r¼|St|ƒ

dSdS)
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
    rcr
z%04x  éz%02X z   z %s
T)
rvÚ

Néÿÿÿÿ)rÚlenrrryÚendswithÚprint)Ú
pÚdumpÚ
sr8Zx_lenrwrxr0r0r1Úhexdump
s"	









 



ršcCs.d
}t||
||d}|r|St
|ƒ

dSdS)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
    rc)ÚonlyascÚonlyhexrvN)Úhexstrr–)r—r›rœr˜r™r0r0r1Úlinehexdump-
s




ržcCs4t|ƒ
}d
 
dd„|Dƒ
¡
}|
r$|St|ƒ

dSdS)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
    z, c
ss|]}
dt|
ƒ
V
qd
S)z%#04xN)
r)r.r8r0r0r1r2Q
szchexdump.<locals>.<genexpr>N)rrr–)r—r˜r8r™r0r0r1ÚchexdumpC
s




rŸcCsJt|ƒ
}g}|
s*| 
d
 dd„|Dƒ
¡
¡

|s@| 
t||d¡

d |¡
S)z*Build a fancy tcpdump like hex from bytes.ú
 c
ss|]}
dt|
ƒ
V
qd
S)z%02XN)
r)r.Ú
br0r0r1r2`
szhexstr.<locals>.<genexpr>)
rvz  )rrkrry)r—r›rœrvr8r™r0r0r1rY
s





rc

Csd
 dd„|Dƒ
¡
S)z= Convert provided bitstring to a simple string of hex digits rcc
ss|]}
dt|
ƒ
V
qd
S)z%02xN)
r)r.r8r0r0r1r2i
szrepr_hex.<locals>.<genexpr>)
r)
r™r0r0r1Úrepr_hexf
sr¢c!sðt|ƒ
‰t|
ƒ
‰
t
jˆˆ
|d
}‡f
dd„ttˆƒ
ƒ
Dƒ
}‡
f
dd„ttˆ
ƒ
ƒ
Dƒ
}g}g}xž| ¡D]’}|\}	}
}}}
|	dkr¤|||
|…7}|dg
||
7}qf|	dkrÐ|dg
|
|7}||||
…7}qf|	dkrf|||
|…7}||||
…7}qfW|
rBt|ƒ
}t|ƒ
}|dg
t||ƒ|7}|dg
t||ƒ|7}d	}}}d
d„tjj	tjj
dœ}d
}d	}t|ƒ
}xr||krê|||d…}|||d…}tdd„|Dƒ
ƒ
}tdd„|Dƒ
ƒ
}|
rÜ|
sÜd	}d
}|
rð||k
rðd
}|rJ|}d	}x ||s|d
7}|d
8}qWt|||d|ƒ
dd
||7}|}ntddd
|r°|}d	}x ||s„|d
7}|d
8}qfWt|||d|ƒ
dd
||7}|}ntddd
tddd
d}xØtdƒ
D]Ì}|||kr~||rh|||||k||} t| dt
||ƒ
ƒ
dd
||||krR|t||dd7}n|| t||ƒ
ƒ
7}ntddd
|d7}ntddd
|dkrÖtddd
qÖWtd|ƒ
|s¼|sÎd	}d
}|d7}n|rÞd	}d
}n|d7}
qzWdS)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
sg|]}
ˆ|
|
d…‘qS)
rHr0)r.rw)
Úxbr0r1ú
<listcomp>‚
szhexdiff.<locals>.<listcomp>c
sg|]}
ˆ|
|
d…‘qS)
rHr0)r.rw)
Úybr0r1r¦ƒ
srgóÚinsert)ÚequalÚreplacer
c


Ss|S)
Nr0)
r8r0r0r1Ú<lambda>
r¨zhexdiff.<locals>.<lambda>)r
r“rHrHr‘c
ss|]}
t|
ƒ
V
qdS)
N)
r”)r.Ú
kr0r0r1r2§
szhexdiff.<locals>.<genexpr>c
ss|]}
t|
ƒ
V
qdS)
N)
r”)r.r­r0r0r1r2¨
sz%04xr )
Úendz    rcz%02XT)
rvz  éN)rÚdifflibZSequenceMatcherrr”Zget_opcodesÚmaxrrtÚleftÚrightÚsumr–rry)!r£r¡r¤ÚsmZxarrZyarrZ
backtrackxZ
backtrackyÚopcodeÚtypZx0Úx1Zy0Úy1ZlbxZlbyr8Ú
yrwZcolorizeZdoxZdoyZbtx_lenZlinexZlineyÚxxÚyyZxdrxÚlineZydZclÚcolr0)r¥r§r1Úhexdiffl
s¨





































































r¿Ú
HrHs
c


Cs|S)
Nr0)
Úchkr0r0r1r¬é
r¨r¬c

Cs|d
?d@|d
>BS)Nééÿr0)
rÁr0r0r1r¬ë
r¨c
CsVt|ƒ
d
dkr|d7}t
t d|¡ƒ
}
|
d?|
d@}
|
|
d?7}
|
}
t|
ƒ
d@S)NérHó
rÀr‘iÿÿ)r”r´ÚarrayÚchecksum_endian_transform)Úpktr™r0r0r1Úchecksumî
s





rÉc
CsBd
}
}x |D]}|
t|ƒ
7}
||
7}qW|
d;}
|d;}|
|fS)Nr
rÃ)
r)ZcharbufÚc0Úc1Úcharr0r0r1Ú_fletcher16ù
s





rÍc
Cst|ƒ
\}
}|d
>|
BS)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Ër0r0r1Úfletcher16_checksums	
rÏcCs t|ƒ
|
krt
d
t|ƒ
ƒ
‚
|d|
…d||
dd…}t|ƒ
\}}t|ƒ
|
d||d}|dk
rt|d7}d||}|dkr|d8}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 %dNsrÄrHrÃr
iþ
)r”Ú	ExceptionrÍr)rÎÚoffsetrÊrËr8rºr0r0r1Úfletcher16_checkbytess

 



rÒc

Csd
 dd„t
|ƒ
 d¡
Dƒ
¡
S)Nr¨c
ss|]}
tt
|
dƒƒ
V
qd
S)r‘N)rÚint)r.r8r0r0r1r24szmac2str.<locals>.<genexpr>ú
:)rrÚsplit)
Úmacr0r0r1Úmac2str2sr×c

Cs*ytt
|ƒ
ƒ
d
kStk
r$


YnXdS)NéF)r”r×Ú
ValueError)
rÖr0r0r1Ú	valid_mac7s




rÚc

Cs8t|t
ƒr$d
dd…ttt|ƒƒ
Sd
dd…t|ƒ
S)Nz%02x:%02x:%02x:%02x:%02x:%02x:r“)r3r4rŒrŽÚord)
r™r0r0r1Ústr2mac@s


rÜc

Csd
 dd„t
|ƒ
Dƒ
¡
S)z9
    Returns a random string of length (length >= 0)
    r¨c
ss"|]}
t 
dt d
d¡¡V
qdS)Ú
Br
rÃN)ÚstructÚpackÚrandomÚrandint)r.Ú
_r0r0r1r2Ls
zrandstring.<locals>.<genexpr>)rr)
Úlengthr0r0r1Ú
randstringGs

räc

Csd
 dd„t
|ƒ
Dƒ
¡
S)zM
    Returns a random string of length (length >= 0) without zero in it.
    r¨c
ss"|]}
t 
dt d
d¡¡V
qdS)rÝrHrÃN)rÞrßràrá)r.râr0r0r1r2Us
z&zerofree_randstring.<locals>.<genexpr>)rr)
rãr0r0r1Úzerofree_randstringPs

råcCsd
 t
dd„||
ƒ¡
S)zk
    Returns the binary XOR of the 2 provided strings s1 and s2. s1 and s2
    must be of same length.
    r¨cSstt
|ƒ
t
|
ƒ
Aƒ
S)
N)rr)r8rºr0r0r1r¬_r¨zstrxor.<locals>.<lambda>)rrŽ)Ús1Ús2r0r0r1ÚstrxorYsrècCsd
 t
dd„||
ƒ¡
S)zk
    Returns the binary AND of the 2 provided strings s1 and s2. s1 and s2
    must be of same length.
    r¨cSstt
|ƒ
t
|
ƒ
@ƒ
S)
N)rr)r8rºr0r0r1r¬hr¨zstrand.<locals>.<lambda>)rrŽ)rærçr0r0r1Ústrandbsréz255.255.255.255c

Cs|d
krdSt 
|¡
SdS)Nz255.255.255.255sÿÿÿÿ)ÚsocketÚ	inet_aton)
Z	ip_stringr0r0r1rëos
rëc
CsHyt|ƒ
}
Wn$t
jk
r0


tt
 |¡
ƒ
}
YnXttt d
|
¡dƒS)Nz!Ir
)rërêÚerrorÚ
gethostbynamerrÓrÞÚunpack)r8Úipr0r0r1Úatol{s




rðc


CsPyt|ƒ
}Wnt
k
r 


d
SXyt|ƒ

Wntttjfk
rJ


d
SXdS)NFT)rÚUnicodeDecodeErrorrðrrÙrêrì)
Úaddrr0r0r1Úvalid_ip„s







róc
Csnyt|ƒ
}Wnt
k
r 


d
SXd|krf| dd¡\}
}t|
ƒ
od| ¡oddt|ƒ
k
o`dk
S
St|ƒ
S)NFú
/rHr
rq)rrñrÕróÚisdigitrÓ)ròrïÚmaskr0r0r1Ú	valid_net‘s





,
r÷c

Cs†yt|ƒ
}Wnt
k
r 


d
SXyttj|ƒ
WnNtjk
r€


y t |dtj¡ddd
Wntjk
rz


d
SXYnXdS)NFr
éT)rrñrrêÚAF_INET6rìÚgetaddrinfo)
ròr0r0r1Ú	valid_ip6s







 


rûc
Csnyt|ƒ
}Wnt
k
r 


d
SXd|krf| dd¡\}
}t|
ƒ
od| ¡oddt|ƒ
k
o`dk
S
St|ƒ
S)NFrôrHr
é€)rrñrÕrûrõrÓ)ròrïrör0r0r1Ú
valid_net6­s





,
rýc

Cstt
 d
|d@¡ƒ
S)Nz!Ilÿÿ)Ú	inet_ntoarÞrß)
r8r0r0r1Últoa¹srÿc

Csd
|?d@S)Nlüÿlÿÿr0)
r8r0r0r1Úitom¾sr
c@s*eZ
dZd
Zd
dd„
Zdd„Zdd„Zd	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?

    TcCs|
|_||_
dS)
N)ÚprogÚsuppress)r=r
r
r0r0r1Ú__init__Ïs
z!ContextManagerSubprocess.__init__c


CsdS)
Nr0)
r=r0r0r1Ú	__enter__Ôsz"ContextManagerSubprocess.__enter__cCs\|dks|
dkrdSt|t
ƒr*d
|j}nd|j|
jjf}|jsJ|
|ƒ
‚
tj|dd
dS)Nz&Could not execute %s, is it installed?z%s: execution failed (%s)T)
Úexc_info)r3ÚEnvironmentErrorr
rSr-r
rrì)r=Úexc_typeÚ	exc_valueÚ	tracebackÚmsgr0r0r1Ú__exit__Øs







z!ContextManagerSubprocess.__exit__N)
T)r-rYrZr[r
r
r
r0r0r0r1r

Ãs

r

c@s2eZ
dZd
Zdd„Zdd„Zdd„Zdd	d
„
ZdS)
ÚContextManagerCaptureOutputzÇ
    Context manager that intercept the console's output.

    Example:
    >>> with ContextManagerCaptureOutput() as cmco:
    ...     print("hey")
    ...     assert cmco.get_output() == "hey"
    c
Cs4d
|_yddl
}
Wntk
r.


tdƒ
‚
YnXdS)Nrcr
z'The mock module needs to be installed !)Úresult_export_objectÚmockrÐÚImportError)r=r
r0r0r1r
øs




z$ContextManagerCaptureOutput.__init__c
Cs4d
dl}
|f
dd„
}|
 
¡}||_tj|_|t_|S)Nr
cSs|
j|7_dS)
N)
r
)r™Ú	decoratorr0r0r1Úwritesz4ContextManagerCaptureOutput.__enter__.<locals>.write)r
ZMockr
r\ÚstdoutÚ
bck_stdout)r=r
r
Zmock_stdoutr0r0r1r
s



z%ContextManagerCaptureOutput.__enter__c
Gs|jt
_d
S)NF)r
r\r
)r=Úexcr0r0r1r

s
z$ContextManagerCaptureOutput.__exit__FcCs$|j 
d
¡
r|
rtt|jƒ
ƒ
S|jS)Nzb')r
Ú
startswithrÚeval)r=Z
eval_bytesr0r0r1Ú
get_outputs

z&ContextManagerCaptureOutput.get_outputN)
F)r-rYrZr[r
r
r
r
r0r0r0r1r

îs

r

c	Cs8|d
krd}|r|S|d
k	r,t 
dt¡
|}|
d
kr<tjj}
d}|d
krtr`td|d
}d}n0ttjj	ƒ

t
jtjj	g
t
jdj
}Wd
QRX|d
k	r d	|}t|tƒ
r| d
¡
rØt
j|dd
… ¡dt
jdj
}n4| d
¡
rút|dd
… ¡dƒ}nttj |¡
dƒ}ttt|ƒ}t
jd|
|
p*d|
p2dfdt
j|t
jd}| t|ƒ
¡
\}	}
|jdk
rvtdt|
ƒ
ƒ
‚
y| ¡
Wntk

r˜


YnX|r4t   ¡}xŠtj !|j"¡

sæt  #d¡

t   ¡|dk
rªt$dt%ƒ
P
qªWtjj	tjj&krt '|j"¡

n,ttjj	ƒ

t
 tjj	|j"g¡

Wd
QRXd
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 formatFrs)
r`T)
Ústdinz-T%sú
|rH)Úshellr
ú
>Úwbz
"%s" %s %src)r
r
r
Ústderrr
z)GraphViz call failed (is it installed?):
gš™™™™™¹?rGzHTemporary file '%s' could not be written. Graphic will not be displayed.)(ÚwarningsÚwarnÚDeprecationWarningrr
Údotrrbr

Zdisplayr€ÚPopenÚPIPEr
r3r4r
ÚlstripÚopenr{r|ÚabspathrrÚbytesÚcommunicaterÚ
returncoderrrmrÐÚtimeÚexistsrlÚsleeprrhÚ_defaultZ	startfile)Úgraphr
ÚformatÚtargetr6ÚstringÚoptionsZstart_viewerÚprocrâr
Z
waiting_startr0r0r1Údo_graphsl

















































r6
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âú
&ú
%r
ú
~ú
<r
c
Cs&d
}
x|D]}|
t 
||¡7}
q
W|
S)Nrc)Ú_TEX_TRÚget)r8r™Ú
cr0r0r1Ú
tex_escapes



rD
c
osÆt|ƒ
d
kr|d
9}|
 
ddd„¡}xœx–tt|ƒ
ƒ
D]†}x€tt|ƒ
ƒ
D]p}xjtt|ƒ
ƒ
D]Z}||kst||kst||krX||||t|ƒ
|||t|ƒ
|||t|ƒ
ƒV
qXWqFWq4Wq&WdS)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ÄÚtranscSs
||
|fS)
Nr0)r8rºr/r0r0r1r¬‘r¨zcolgen.<locals>.<lambda>N)r”rB
r)ZlstcolÚkargsrE
rwrxr­r0r0r1Úcolgen‰s







rG
útag%05iccsx||
V
|
d
7}
qWdS)NrHr0)ÚlabelÚstartr0r0r1Úincremental_labelšs


rK
c

Cst|ƒ
d
d…S)NrÄ)
Úbin)
Úvalr0r0r1Úbinrepr¡srN
c

Cst| 
d
d¡ 
dd¡dƒS)Nr’rcr r‘)rÓr«)
r™r0r0r1Úlong_converter¦srO
c@sTeZ
dZd
d„Zdd„Zdd„Zdd„Zd	d
„Zdd„Zd
d„Z	dd„Z
dd„ZdS)ÚEnumElementcCs|
|_||_
dS)
N)Ú_keyÚ_value)r=ÚkeyÚvaluer0r0r1r
°s
zEnumElement.__init__c

Cs d
|j 
d|jj¡|j|jfS)Nz<%s %s[%r]>Ú_name)Ú__dict__rB
rSr-rQ
rR
)
r=r0r0r1Ú__repr__µszEnumElement.__repr__cCst|j
|
ƒS)
N)ÚgetattrrR
)r=Úattrr0r0r1Ú__getattr__¹szEnumElement.__getattr__c


Cs|jS)
N)
rQ
)
r=r0r0r1Ú__str__½szEnumElement.__str__c

Cst| 
¡ƒ
S)
N)rr[
)
r=r0r0r1Ú	__bytes__ÁszEnumElement.__bytes__c


Cs|jS)
N)
rR
)
r=r0r0r1Ú__hash__ÅszEnumElement.__hash__c

Cs
t|j
ƒ
S)
N)rÓrR
)
r=r0r0r1Ú__int__ÉszEnumElement.__int__cCs|jt
|
ƒ
kS)
N)rR
rÓ)r=r>r0r0r1rQÍszEnumElement.__eq__cCs| |
¡
S)
N)
rQ)r=r>r0r0r1Ú__neq__ÑszEnumElement.__neq__N)r-rYrZr
rW
rZ
r[
r\
r]
r^
rQr_
r0r0r0r1rP
¯s
rP
csBeZ
dZeZ‡f
d
d„Zdd„Zdd„Zddd	„
Zd
d„Z	‡Z
S)
ÚEnum_metaclasscs`i}x<t 
|¡
D].\}}t|tƒr| ||¡}|||<|||<qW||d
<tt|ƒ ||
||¡S)NÚ	__rdict__)r‰Ú	iteritemsr3rÓÚ
element_classrPr`
Ú__new__)ÚclsrlÚbasesÚdctZrdictr­Ú
v)
rSr0r1rd
Ùs







zEnum_metaclass.__new__cCs
|j|
S)
N)
ra
)r=rY
r0r0r1Ú__getitem__äszEnum_metaclass.__getitem__cCs
|
|jkS)
N)
ra
)r=rM
r0r0r1Ú__contains__èszEnum_metaclass.__contains__NcCs|j 
|
|¡S)
N)ra
rB
)r=rY
rM
r0r0r1rB
ìszEnum_metaclass.getc

Csd
|j 
d|j¡S)Nz<%s>rl)rV
rB
r-)
r=r0r0r1rW
ðszEnum_metaclass.__repr__)
N)r-rYrZrP
rc
rd
ri
rj
rB
rW
r^r0r0)
rSr1r`
Ös

r`
c
Cs,d
dl}
t
t|
 tjj |d¡d¡ƒ
ƒ

dS)Nr
rÄé	)Úzlibr–rÚcompressr‰ÚmovesÚcPickleÚdumps)Úobjrl
r0r0r1Ú
export_objectús
rr
c
Cs6d
dl}
|dkrt
j ¡}tjj |
 t	| 
¡ƒ
¡
¡
S)Nr
)rl
r\r
Úreadr‰rn
ro
ÚloadsÚ
decompressrÚstrip)rq
rl
r0r0r1Ú
import_objects



rw
cCs(t 
|d
¡}tjj |
|¡
| ¡
dS)zPickle a Python objectr
N)Úgzipr'
r‰rn
ro
r˜rm)Úfnamerq
rar0r0r1Úsave_objects

rz
c

Cstj
j t |d
¡¡
S)zunpickle a Python objectÚrb)r‰rn
ro
Úloadrx
r'
)
ry
r0r0r1Úload_objectsr}
ç{®Gáz„?cCs~t d
t
|ƒ
¡}t|ƒ
}|dkr2tdt||
ƒ
ƒ}x4t t|ƒ
|¡D] }||t dd¡d||<qDWt	j
rv| ¡S| ¡S)z]
    Corrupt a given percentage (at least one byte) or number of bytes
    from a string
    rÝNrHrÃé
)
rÆrr”r±rÓràÚsamplerrár‰ÚPY2ÚtostringÚtobytes)Údatar—Ú
nr™Ús_lenrwr0r0r1Ú
corrupt_bytess




 
r‡
cCs‚t d
t
|ƒ
¡}t|ƒ
d}|dkr6tdt||
ƒ
ƒ}x4t t|ƒ
|¡D] }||dd|d>N<qHWtj	rz| 
¡S| ¡S)zX
    Flip a given percentage (at least one bit) or number of bits
    from a string
    rÝrÂNrH)rÆrr”r±rÓràr€
rr‰r
r‚
rƒ
)r„
r—r…
r™r†
rwr0r0r1Úcorrupt_bits's




 
rˆ
c	Os*t|f
|ž|Ž
}| 
|
¡

Wd
QRXd
S)a8Write 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)Ú
PcapWriterr
)ÚfilenamerÈÚargsrF
Úfdescr0r0r1Úwrpcap;s
r
r“c	Cs t|ƒ
}|j
|
d

SQRXdS)zeRead a pcap or pcapng file and return a packet list

    :param count: read only <count> packets
    )
ÚcountN)Ú
PcapReaderÚread_all)rŠ
rŽ
rŒ
r0r0r1ÚrdpcapRs

r‘
cs4eZ
dZd
Z‡f
dd„Zdd„Zedd„ƒ
Z‡ZS)ÚPcapReader_metaclassz"Metaclass for (Raw)Pcap(Ng)Readerscs,tt
|ƒ ||
||¡}d
|kr(||d
_|S)zxThe `alternative` class attribute is declared in the PcapNg
        variant, and set here to the Pcap variant.

        Úalternative)rPr’
rd
r“
)re
rlrf
rg
Znewcls)
rSr0r1rd
ls





zPcapReader_metaclass.__new__c	CsÀ| ||j
|j|j¡}| |
¡
\}
}}|s2td
ƒ
‚
y| |
||¡
|Sttfk
r\


YnXd|jkr´|jd}| ||j
|j|j¡}y| |
||¡
|Sttfk
r²


YnXtdƒ
‚
dS)zNCreates a cls instance, use the `alternative` if that
        fails.

        zNo data could be read!r“
zNot a supported capture fileN)rd
r-r5rV
r'
rr
ÚEOFError)re
rŠ
rwrŒ
Úmagicr0r0r1Ú__call__ys&
















zPcapReader_metaclass.__call__c
Csxt|t
ƒrT|}
yt |
d
¡}| d¡
}Wqntk
rP


t|
d
ƒ}| d¡
}YqnXn|}t|ddƒ}
| d¡
}|
||fS)z1Open (if necessary) filename, and read the magic.r{
rørlzNo name)r3r4rx
r'
rs
ÚIOErrorrX
)ry
rŠ
rŒ
r•
r0r0r1r'
–s












zPcapReader_metaclass.open)	r-rYrZr[rd
r–
Ústaticmethodr'
r^r0r0)
rSr1r’
is

r’
c@s¬eZ
dZd
ZdZe dddddg¡Zd$d	d
„
Zdd„Z	d
d„Z
e
Zef
dd„
Z
ef
dd„
Zdd„Zd%dd„
Zd&dd„
Zef
dd„
Zdd„Zdd„Zd d!„Zed'd"d#„
ƒ
ZdS)(Ú
RawPcapReaderz;A stateful pcap reader. Each packet is returned as a stringTÚPacketMetadataÚsecÚusecÚwirelenÚcaplenNcCs¾|
|_||_
|d
kr"d|_d|_nN|dkr8d|_d|_n8|dkrNd|_d|_n"|dkrdd|_d|_ntd	|ƒ
‚
|j
 d
¡
}t|ƒ
d
krtdƒ
‚
t |jd|¡\}}}}}	}
|
|_	|	|_
dS)
Ns¡²ÃÔr
FsÔò¡r@
s¡²<MTsM<²¡z'Not a pcap capture file (bad magic: %r)ézInvalid pcap file (too short)ZHHIIII)rŠ
rnÚendianÚnanorrs
r”rÞrîÚlinktypeÚsnaplen)r=rŠ
rŒ
r•
ÚhdrZvermajZverminÚtzÚsigr£
r¢
r0r0r1r
²s.



















zRawPcapReader.__init__c


Cs|S)
Nr0)
r=r0r0r1Ú__iter__ÏszRawPcapReader.__iter__c

Cs&y| ¡St
k
r 


t‚
YnXd
S)zT
        implement the iterator protocol on a set of packets in a pcap file
        N)Úread_packetr”
Ú
StopIteration)
r=r0r0r1ÚnextÓs


zRawPcapReader.nextcCs\|j 
d
¡
}t|ƒ
d
krt‚
t |jd|¡\}}}}|j 
|¡
d|
…tj||||dfS)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‘ÚIIIIN)r›
rœ
r
rž
)	rnrs
r”r”
rÞrîr 
r™
rš
)r=Úsizer¤
r›
rœ
rž
r
r0r0r1Ú_read_packetÞs





zRawPcapReader._read_packetcCstt
| ¡d
ƒS)Nr
)rr)r­
)r=r¬
r0r0r1r¨
ís

zRawPcapReader.read_packetcCsx|D]}|
|ƒ

qWd
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.
        Nr0)r=Úcallbackr—r0r0r1Údispatchôs


zRawPcapReader.dispatchr“cCs.| |
¡
}d
dl
m}
|j|tj |j¡
dS)Nr
)
Úplist)
rl)Ú	_read_allrdr°
r+r{r|ÚbasenamerŠ
)r=rŽ
Úresr°
r0r0r1r

s


zRawPcapReader.read_allcCsLg}xB|
d
krF|
d8}
y| ¡}Wnt
k
r8


PYnX| |¡

qW|S)z6return a list of all packets in the pcap file
        r
rH)r¨
r”
rk)r=rŽ
r³
r—r0r0r1r±
s








zRawPcapReader._read_allcCs|j|
d

dS)z Emulate a socket
        )
r¬
r
)
r­
)r=r¬
r0r0r1ÚrecvszRawPcapReader.recvc

Cs
|j 
¡S)
N)rnÚfileno)
r=r0r0r1rµ
szRawPcapReader.filenoc

Cs
|j 
¡S)
N)rnrm)
r=r0r0r1rmszRawPcapReader.closecCs| ¡
dS)
N)
rm)r=r
r	
Útracbackr0r0r1r
#szRawPcapReader.__exit__c
Cs|S)
Nr0)ÚsocketsZremainr0r0r1Úselect(szRawPcapReader.select)NN)
r“)
r“)
N)r-rYrZr[Znonblocking_socketÚcollectionsÚ
namedtuplerš
r
r§
rª
Ú__next__rr­
r¨
r¯
r
r±
r´
rµ
rmr
r˜
r¸
r0r0r0r1r™
ªs&


	

r™
cs>eZ
dZd
dd„
Zdd„Zef
‡f
dd„	Zef
dd	„
Z‡ZS)r
NcCslt 
||
||¡
ytjj|j|_WnBtk
rf


td
|j|jfƒ

tj	dkrZddl
}tj	|_YnXdS)Nz9PcapReader: unknown LL type [%i]/[%#x]. Using Raw packetsr
)r™
r
rÚl2typesÚ	num2layerr¢
ÚLLclsÚKeyErrorrÚ	raw_layerÚscapy.packet)r=rŠ
rŒ
r•
rdr0r0r1r
1s






zPcapReader.__init__c


Cs|S)
Nr0)
r=r0r0r1r
?szPcapReader.__enter__c	sÖtt
|ƒj|
d

}|dkrt‚
|\}}y| |¡
}Wndtk
rJ


‚YnPtk
r˜


tjrxddl	m
}
|j|f|_‚tjdkrŠddl
}t |¡
}YnXtdƒ
t|jr¬dndƒ
}t|j||jƒ
|_|j|_|S)N)
r¬
r
)
Údebugé
i÷ÿÿÿiúÿÿÿ)rPr
r­
r”
r¾
rƒrÐrÚdebug_dissectorZscapy.sendrecvrÂ
Z
crashed_onrÀ
rÁ
rr¡
r;r›
rœ
r,
r
)	r=r¬
Úrpr™Zpkt_infor—rÂ
rdÚpower)
rSr0r1r¨
Cs(

















zPcapReader.read_packetcCs|j|
d

S)N)
r¬
)
r¨
)r=r¬
r0r0r1r´
\szPcapReader.recv)NN)	r-rYrZr
r
rr¨
r´
r^r0r0)
rSr1r
0s

r
c@sŒeZ
dZd
ZeZe ddddddg¡Zdd	d
„
Z	e
f
dd„
Zd
d„Zdd„Z
e
f
dd„
Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„ZdS) ÚRawPcapNgReaderzEA stateful pcapng reader. Each packet is returned as
    bytes.

    rš
r¢
ÚtsresolÚtshighÚtslowr
NcCs||
|_||_
g|_d
di
|_|j|j|j|jdœ|_d|_	|dkrNt
d|ƒ
‚
y| ¡
Wntk
rv


t
dƒ
‚
YnXdS)NrÈ
i@B)rHrÄrGrØú
!s


z)Not a pcapng capture file (bad magic: %r)z/The first SHB of the pcapng file is malformed !)
rŠ
rnÚ
interfacesÚdefault_optionsÚ_read_block_idbÚ_read_block_pktÚ_read_block_spbÚ_read_block_epbÚ
blocktypesr 
rÚ_read_block_shbr”
)r=rŠ
rŒ
r•
r0r0r1r
ms"











zRawPcapNgReader.__init__cCsÖy"t 
|jd
|j d¡
¡d}Wntjk
r<


t‚
YnX|dkrR| ¡
dSy"t 
|jd
|j d¡
¡d}Wntjk
rŽ


t‚
YnX|dkr¤tdƒ

t‚
|j |d¡
}| 	|¡

|j
 |dd„¡||
ƒS)	NÚ
Irør
i


ézInvalid block length !c
SsdS)
Nr0)Úblockr¬
r0r0r1r¬Ÿr¨z-RawPcapNgReader._read_block.<locals>.<lambda>)rÞrîr 
rnrs
rìr”
rÓ
rÚ_read_block_tailrÒ
rB
)r=r¬
Z	blocktypeÚblocklenrÖ
r0r0r1Ú_read_blockŠs(
"






"












zRawPcapNgReader._read_blockcCsx|
d
r*|j 
|
d
¡
}td|
|fƒ

y.|
t |jd|j 
d
¡
¡dkrVtdƒ
‚
Wntjk
rr


t‚
YnXdS)NrøzDPcapNg: bad blocklen %d (MUST be a multiple of 4. Ignored padding %rrÔ
r
z+PcapNg: Invalid pcapng block (bad blocklen))rnrs
rrÞrîr 
r”
rì)r=rØ
Úpadr0r0r1r×
¢s








z RawPcapNgReader._read_block_tailc
Cs–|j 
d
¡
}
|j 
d
¡
}|dkr(d|_n|dkr8d|_ntdƒ

t‚
t |jd|
¡d}|d	krntd
ƒ

t‚
|j 
|d	¡
}| |¡

| |¡

dS)Nrøs+<Mr
sM<+r@
z6Bad magic in Section Header block (not a pcapng file?)rÔ
r
r‘zInvalid SHB block length!)	rnrs
r 
rr”
rÞrîr×
Ú
_read_options)r=Z	_blocklenr 
rØ
r4
r0r0r1rÓ
¯s












zRawPcapNgReader._read_block_shbcCsx| ¡}|d
k	r|SqWd
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Ù
)r=r¬
r³
r0r0r1r­
Ãs


zRawPcapNgReader._read_packetcCsÈ|j 
¡}x¸t|
ƒ
d
krÂt |jd|
dd
…¡\}}|dkrz|dkrzt|
ƒ
dkrzt|
d
ƒ
}|d@rjdnd	|d
@|d<|dkr˜|dkr–td
|ƒ

P|d
r°|d
|d
7}|
d
|d…}
qW|S)zSection Header BlockrøZHHNrk
rHérürÄrÃ
rrrÈ
r
z2PcapNg: invalid option length %d for end-of-option)rÍ
Úcopyr”rÞrîr 
rr)r=r4
ÚoptsÚcoderãrÈ
r0r0r1rÛ
Ïs












zRawPcapNgReader._read_optionscCsv| |
d
d…¡
}y(t
 |jd|
dd
…¡|df
}Wn*t
jk
rd


tdt|
ƒ
ƒ

t‚
YnX|j 	|¡

dS)zInterface Description BlockrÂéüÿÿÿZHxxINrÈ
zPcapNg: IDB is too small %d/8 !)
rÛ
rÞrîr 
rìrr”r”
rÌ
rk)r=rÖ
râr4
Z	interfacer0r0r1rÎ
æs









zRawPcapNgReader._read_block_idbcCs*t|j
ƒ
}|
|kr&td
|
|fƒ

t‚
dS)z;Check the interface id value and raise EOFError if invalid.z"PcapNg: invalid interface id %d/%dN)r”rÌ
rr”
)r=ÚintidÚtmp_lenr0r0r1Ú_check_interface_idös



z#RawPcapNgReader._check_interface_idcCsžy(t 
|jd
|
dd…¡\}}}}}Wn*tjk
rR


tdt|
ƒ
ƒ

t‚
YnX| |¡

|
dd|…d|…tj	|j
|d|j
|d|||dfS)zEnhanced Packet BlockZ5INrŸ
z PcapNg: EPB is too small %d/20 !r
rÄ)r¢
rÈ
rÉ
rÊ
r
)rÞrîr 
rìrr”r”
rã
rÇ
rš
rÌ
)r=rÖ
r¬
rá
rÉ
rÊ
rž
r
r0r0r1rÑ
þs












zRawPcapNgReader._read_block_epbcCs®d
}| |¡

y t
 |jd|
dd…¡\
}Wn*t
jk
rX


tdt|
ƒ
ƒ

t‚
YnXt||j	|dƒ}|
dd|…d|…t
j|j	|d
|j	|ddd|dfS)	zSimple Packet Blockr
rÔ
NrøzPcapNg: SPB is too small %d/4 !rHrÄ)r¢
rÈ
rÉ
rÊ
r
)rã
rÞrîr 
rìrr”r”
ÚminrÌ
rÇ
rš
)r=rÖ
r¬
rá
r
rž
r0r0r1rÐ
s


 









zRawPcapNgReader._read_block_spbc	Cs y*t 
|jd
|
dd…¡\}}}}}}Wn*tjk
rT


tdt|
ƒ
ƒ

t‚
YnX| |¡

|
dd|…d|…tj	|j
|d|j
|d|||dfS)z(Obsolete) Packet BlockZHH4INrŸ
z PcapNg: PKT is too small %d/20 !r
rÄ)r¢
rÈ
rÉ
rÊ
r
)rÞrîr 
rìrr”r”
rã
rÇ
rš
rÌ
)	r=rÖ
r¬
rá
ZdropsrÉ
rÊ
rž
r
r0r0r1rÏ
)s












zRawPcapNgReader._read_block_pkt)NN)r-rYrZr[r™
r“
r¹
rº
rš
r
rrÙ
r×
rÓ
r­
rÛ
rÎ
rã
rÑ
rÐ
rÏ
r0r0r0r1rÇ
as 



rÇ
csBeZ
dZeZd
dd„
Zdd„Zef
‡f
dd„	Zef
dd	„
Z	‡Z
S)ÚPcapNgReaderNcCst 
||
||¡
dS)
N)rÇ
r
)r=rŠ
rŒ
r•
r0r0r1r
BszPcapNgReader.__init__c


Cs|S)
Nr0)
r=r0r0r1r
FszPcapNgReader.__enter__cs¾tt
|ƒj|
d

}|dkrt‚
|\}\}}}}}ytjj|}	|	|ƒ
}
WnLtk
r^


‚Yn8tk
r”


tj	rt‚tj
dkr†ddl}t 
|¡
}
YnX|dk	r´t|d>|ƒ
||
_
||
_|
S)N)
r¬
r
rq)rPrå
r­
r”
rr¼
r½
rƒrÐrÄ
rÀ
rÁ
r;r,
r
)r=r¬
rÅ
r™r¢
rÈ
rÉ
rÊ
r
re
r—rd)
rSr0r1r¨
Js&

















zPcapNgReader.read_packetcCs| ¡S)
N)
r¨
)r=r¬
r0r0r1r´
aszPcapNgReader.recv)NN)r-rYrZr
r“
r
r
rr¨
r´
r^r0r0)
rSr1rå
>s

rå
c@s|eZ
dZd
Zddddddefdd„
Zdd„Zd	d
„Zdd„Zd
d„Z	ddd„
Z
ddd„
Zdd„Zdd„Z
dd„Zdd„ZdS)Ú
RawPcapWriterz4A stream PCAP writer with more control than wrpcap()NFrcc	
Cs ||_||_
d
|_||_||_||_||_||_d}	|r<d
}	t|
t	ƒrˆ|
|_
|rpttt
 |
|rbdpddd¡ƒ|_qœt|
|r|dp~d|	ƒ|_n|
|_t|
ddƒ|_
dS)	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
iÚabr
rk
rlzNo nameN)r¢
r£
Úheader_presentrkÚgzr 
Úsyncr¡
r3r4rŠ
rÚ_ByteStreamrx
r'
rnrX
)
r=rŠ
r¢
ré
Z
endiannessrkrê
r¡
r£
Zbufszr0r0r1r
is&















zRawPcapWriter.__init__c

Cs
|j 
¡S)
N)rnrµ
)
r=r0r0r1rµ
›szRawPcapWriter.filenocCs| t
|
ƒ
¡
S)
N)Ú
_write_headerr)r=rÈr0r0r1Úwrite_headerŸszRawPcapWriter.write_headercCsŽd
|_|j
rL|jr"t |jd¡}nt|jdƒ}z| d¡
r>dSWd| ¡
X|j 	t
 |jd|j
rhdndddd	d	|j|j¡¡

|j ¡
dS)
NrHr{
r‘ZIHHIIIIlM<dClÔCeCrÄrør
)rè
rkré
rx
r'
rŠ
rs
rmrnr
rÞrßr 
r¡
r£
r¢
Úflush)r=rÈÚ
gr0r0r1rì
£s







zRawPcapWriter._write_headercCsŽt|
t
ƒr&|js| |
¡

| |
¡

ndd
dlm}
xV||
ƒ
jD]H}|jsR| |¡

t|t
ƒs||jt	j
 t|ƒ
d¡kr|t
dƒ

| |¡

q>WdS)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
)
Ú
IterSocketNzWInconsistent linktypes detected! The resulting PCAP file might contain invalid packets.)r3r)
rè
rí
Úwrite_packetÚscapy.supersocketrð
Úiterr¢
rr¼
rB
r6r)r=rÈrð
r—r0r0r1r
ºs	











zRawPcapWriter.writecCs|jt
|
ƒ
||||d

dS)N)r›
rœ
rž
r
)Ú
_write_packetr)
)r=Úpacketr›
rœ
rž
r
r0r0r1rñ
×s


zRawPcapWriter.write_packetc	Cs´|d
krt|
ƒ
}|d
kr|}|d
ks,|d
krtt
 
¡}t|ƒ
}|d
krh|}tt|||jr\dndƒ
ƒ
}n|d
krtd}|j t |j	d||||¡¡

|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: int or long
        :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
        :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
        Niʚ;i@Br
r«
)r”r,
rÓÚroundr¡
rnr
rÞrßr 
rê
rî
)r=rõ
r›
rœ
rž
r
r9Úitr0r0r1rô
ås$
















zRawPcapWriter._write_packetc

Cs
|j 
¡S)
N)rnrî
)
r=r0r0r1rî
szRawPcapWriter.flushc

Cs|js| 
d¡

|j ¡S)
N)rè
rí
rnrm)
r=r0r0r1rms


zRawPcapWriter.closec


Cs|S)
Nr0)
r=r0r0r1r
!szRawPcapWriter.__enter__cCs| ¡
| 
¡
dS)
N)rî
rm)r=r
r	
r¶
r0r0r1r
%s
zRawPcapWriter.__exit__)NNNN)NNNN)r-rYrZr[rr
rµ
rí
rì
r
rñ
rô
rî
rmr
r
r0r0r0r1ræ
fs0






*







-ræ
c@s"eZ
dZd
Zdd„Zddd„
ZdS)r‰
z4A stream PCAP writer with more control than wrpcap()cCsl|jdkr^y*|
dkst
|
tƒr"t‚
tjj|
j|_Wn(tk
r\


td
|
jj	ƒ
t
|_YnX| |
¡

dS)Nz;PcapWriter: unknown LL type for %s. Using type 1 (Ethernet))r¢
r3r)
r¿
rr¼
Z	layer2numrSrr-r
rì
)r=rÈr0r0r1rí
.s







zPcapWriter.write_headerNcCs t|
d
ƒr<|dkr<t
|
jƒ
}t
t|
j||jr2dndƒ
ƒ
}|dkrHd}t|
ƒ
}|dkr`t|ƒ
n|}|dkr|t|
dƒr||
j}|dkrˆ|}|j|||||d
dS)a]
        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: int or long
        :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
        r,
Niʚ;i@Br
r
)r›
rœ
rž
r
)	ÚhasattrrÓr,
rö
r¡
rr”r
rô
)r=rõ
r›
rœ
rž
r
Zrawpktr0r0r1rñ
=s$ 
















zPcapWriter.write_packet)NNNN)r-rYrZr[rí
rñ
r0r0r0r1r‰
+s



r‰
c
Cs¢t 
d
¡
}
d}yj|r"t |¡
j}nt}xN|ƒ ¡}|s8Py||
 |¡
 ¡d7}Wq(t	k
rp


t
dƒ

w(Yq(Xq(WWntk
rŒ


YnX| dd¡}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})rcrÄzParsing error during hexcapr )ÚreÚcompiler‰ÚStringIOÚreadlinerrv
ÚmatchÚgroupsrÐrr”
r«r)Zinput_stringZre_extract_hexcapr—Zinput_functionr½r0r0r1Ú
import_hexcapus&


















rÿ
cKst|f
t
jj|
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.
    )r
Úwait)Útcpdumprr
Ú	wireshark)ÚpktlistrÚkwargsr0r0r1r–s
rcKs(|
d
krdg
}
t|f
t
jj|
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)r
r‹
)r
rr
Ztshark)rr‹
rr0r0r1Útdecode£s

rc
Csd
dlm
}

tt|
|ƒ
ƒ ¡S)z"Guess the DLT name from its value.r
)
Úpcap_datalink_val_to_name)Úscapy.libs.winpcapyrrr)
Údecode)rT
rr0r0r1Ú_guess_linktype_name¶s
r	c
Cs8d
dlm
}

tt|
| ¡ƒ
ƒ}|dkr4td|ƒ
tS|S)zGuess the value of a DLT name.r
)
Úpcap_datalink_name_to_valr“z"Unknown linktype: %s. Using EN10MB)rr
rrÓÚencoderr
)rlr
rM
r0r0r1Ú_guess_linktype_value½s





rTc
s¤|p|}|d
kr,tj
js tdƒ
‚
tj
jg
}nt|tjƒr@|g
}ntdƒ
‚
|
d
k	rÞt|
tƒr‚yt	|
ƒ
}
WqÂt
k
r~


d}
YqÂXn@|
 d¡
r˜|
dd
…}
|
}
yt|
ƒ
}
Wnt
k
rÀ


d}
YnX|
dkrÒtdƒ
‚
|d|
g7}|d
krìg}nt|ƒ
}|d
k	
rP|
d
k
r.tˆtƒ
r.tˆƒ
}|j}
Wd
QRXd	d
lm}
|||
d
| |¡

|

s\|
rbtjnd
}|
rvttjƒ
nd
}d
‰
|d
k
ržt
oœ|d	tj
jk}|	d
k
rò|d	tj
jk
rÄdd
g}	n,|d	tj
jk
rèt
sèddd
g}	ndd
g}	nt|	ƒ
}	ˆd
kr8t|d	|d
tj||||d‰
Wd
QRXntˆtjƒr‚t|d	|d"
tj|dˆg|||d‰
Wd
QRX
nÂ|r<tt t!t"dfˆƒ‰t#ddd}y| $t%‡f
dd„dƒ¡

Wn.t&k
rô


tdˆƒ‰t'|ˆ|
d
Yn
X| (¡
t|d	|d$
tj|d|j)g|||d‰
Wd
QRX
nyBˆ *¡
t|d	|d 
tj||	|ˆ||d‰
Wd
QRXWnÄt&tfk
rB


t|d	|d"
tj||	|tj||d‰
Wd
QRXˆ
d
krÚd
Syˆ
j+ $t%‡f
dd„dƒ¡

Wn:t&k
r


t'ˆ
j+ˆ|
d
Yn t,k
r2


YnXˆ
j+ (¡
YnXˆ
d
krRd
S|
r|d -t%‡
f
dd„dƒ¡
}ˆ
 .¡
|S|r†ˆ
S|r’ˆ
j/S|r ˆ
 0¡
d
S)aRun 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'
    Nztcpdump is not availablezprog must be a stringr“ZDLT_røz7Unknown linktype. Try passing its datalink name insteadz-yr
)
Úcompile_filter)
r¢
z-kiú
-z-Uz-r)
r
)r
r
r*z.pcapT)r`racs
ˆ d
¡
S)Ni)
rs
r0)
rr0r1r¬r¨ztcpdump.<locals>.<lambda>r¨)r
r
r
cs
ˆ d
¡
S)Ni)
rs
r0)
rr0r1r¬³r¨csˆj 
d
¡
S)Ni)r
rs
r0)
r5
r0r1r¬Ár¨)1rr
r
rr3r‰Ústring_typesrÙrÓr	r©
r
rr¿
rr4r
r¢
Zscapy.arch.commonr
rkr€r%
r'
r{Údevnullr	rr
r

r$
rr'rr)
rbÚ
writelinesró
ÚAttributeErrorr
rmrlrµ
r
ÚUnboundLocalErrorrÚ	terminater
r)rr˜Zgetfdr‹
Zfltr
ZgetprocÚquietZuse_tempfileZread_stdin_optsr¢
rZ	_suppressZ
linktype_nameÚrdr
r
r
Ztmpfiler„
r0)rr5
r1r
Èsæd



























































































r
c
	CsPtƒ}
t
|
|ƒ
ttjjƒ

t tjj|
g¡

Wd
QRXt|
ƒ
}t	 
|
¡

|S)zARun hexedit on a list of packets, then return the edited packets.N)rbr
r

rr
Úhexeditr€rr‘
r{Úunlink)rrnZrpktlistr0r0r1rÍs







rcCs6
d
}tj
s.dd
l}
|
jdd
d}|dkr.|Str ddlm}m}
|j 	d¡
}|dƒ
}|j 
||¡}|rœt d|j
¡\}}}	}
}}}
}}}}||d	}|S|Syttjd
ƒ
}Wntk
rÆ


YnX|rÐ|SyFdd
l}dd
l}t ddddd¡}| d	|j|¡}t d|¡d	}Wntk

r,


YnX|Sd
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ôÿÿÿéZhhhhHhhhhhhrHÚCOLUMNSZHHHH)r‰r
ÚshutilÚget_terminal_sizerÚctypesrrÚkernel32ZGetStdHandleÚGetConsoleScreenBufferInforÞrîÚrawrÓr{ÚenvironrÐÚfcntlÚtermiosrßZioctlÚ
TIOCGWINSZr—
)ZsizexrrrÚ
hÚcsbir³
ZbufxZbufyZcurxZcuryZwattrr²Útopr³ZbottomZmaxxZmaxyr%r&r™r8r0r0r1Úget_terminal_widthÚs>	








$














r+csX|r
d
}nd}t|
dƒ
}t|ƒ
|dt
tƒ
}d}|j‡f
dd„d

xÐt|ƒ
D]Ä\‰
}g}	g}
x6t|ƒ
D]*\}}t|tƒrn|	 |¡

|
 |p”d	¡

qnW|
rT|ˆ
=d}
xlt|
d
d	i
Ž
D]Z}|
rÎd	g
|}nt|ƒ
}x t|	ƒ
D]\}}||||<qàW| 	ˆ
|
t
|ƒ
¡
|
d7}
qºWqTWttt
tdf|ƒ}|
|}dd
„t|ŽDƒ
}tƒ}tj
rü|
rü||}x’t|ƒ
|k
rúd}| t|ƒ
¡
‰
‡
f
dd
„|Dƒ
}| t|ƒ
¡
}t||ƒ
}|ˆ
dd…d|ˆ
<t
|ƒ
||<t|ˆ
ƒ
||<t|ƒ
|ˆ
<
qjW|rt d¡

| dd
„|Dƒ
¡
‰|r@| 	dt
dd„|Dƒ
ƒ
¡
d ‡f
dd„|Dƒ
¡
S)aP

    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 whill be used for
        ordering
    :param borders: whether to put borders on the table or not
    r
z  r
rHFc

s|ˆS)
Nr0)
r8)
ÚsortByr0r1r¬$	r¨zpretty_list.<locals>.<lambda>)
rS
r Ú	fillvalue.c
Ssg|]}
tdd
„|
Dƒ
ƒ
‘qS)c
ss|]}
t|
ƒ
V
qdS)
N)
r”)r.rºr0r0r1r2=	sz)pretty_list.<locals>.<listcomp>.<genexpr>)
r±)r.r8r0r0r1r¦=	szpretty_list.<locals>.<listcomp>Tc
sg|]}
t|
ˆƒ
‘qSr0)
r”)r.r8)
rwr0r1r¦H	sNéþÿÿÿrâz?Table cropped to fit the terminal (conf.auto_crop_tables==True)c
Ssg|]}
d|
‘qS)
z%%-%dsr0)r.r8r0r0r1r¦U	sc
ss|]}
d|
V
qd
S)rNr0)r.r8r0r0r1r2X	szpretty_list.<locals>.<genexpr>r’c
3s|]}
ˆ|
V
qdS)
Nr0)r.r8)
Úfmtr0r1r2Z	s)r”rÓrÚsortÚ	enumerater3rrkrr©rŒrr!r%r4Úzipr+rZauto_crop_tablesr´Úindexr±rÚinfor)ZrtlstÚheaderr,ZbordersZ_spaceÚcolsZ	_spacelenZ_cropedr½ÚidsÚvaluesrxrM
r­Zex_valsZ
extra_liner(ZrtslstÚcolwidthÚwidthÚrowr9r0)r/rwr,r1Úpretty_list	s^
































r<c	sši‰i}	i}
i}t|ƒ
}d
}xf|D]^}
dd„||
ŽDƒ
\}}}t
t|ƒ
|ƒ}t
ˆ |d
¡t|ƒ
t|ƒ
ƒˆ|<d|	|<||
||f<q"Wtˆƒ
}t|	ƒ
}|r¦|j|d

nTy|jtd

WnBtk
rø


y|jtd

Wntk
rò


| ¡
YnXYnX|
r|j|d

nXy|jtd

WnFtk

rd


y|jtd

Wntk

r^


| ¡
YnXYnXd}|
r”||‡f
dd„|Dƒ
ƒ}||d7}||ƒ
}||d7}|d	7}x6|D].}|
ˆ|ƒ
||<||||7}|d	7}
q¶W||d7}|r||d7}xb|D]Z}|||7}|d	7}x2|D]*}||||
 ||fd
¡7}|d	7}q*W||d7}qW|r|||d7}|r†|St	|dd
dSdS)z@Core function of the make_table suite, which generates the tabler
c
Ssg|]}
t|
ƒ
‘qSr0)
r4)r.r™r0r0r1r¦t	sz __make_table.<locals>.<listcomp>N)
rS
rcc
sg|]}
ˆ|
‘qSr0r0)r.r8)
Úvxr0r1r¦“	sr’r r)
r®)
rr±r”rB
rr0rÓrÐrðr–)ZyfmtfuncZfmtfuncÚendliner„
ZfxyzZsortxZsortyÚseplinefuncr˜ZvyZvzZvxfrâ
Ú
er»r¼ÚzzZvxkZvykr™Zsepliner/r8rºr0)
r=r1Ú__make_table]	sv








 












































rBcOstd
d„dd„df|ž|
Ž
S)Nc

Ssd
|S)Nz%%-%isr0)
Ú
lr0r0r1r¬´	r¨zmake_table.<locals>.<lambda>c

Ssd
|S)Nz%%-%isr0)
rCr0r0r1r¬µ	r¨rc)
rB)r‹
rF
r0r0r1Ú
make_table±	s




rDcOs(td
d„dd„df|žddd„i
|
—Ž
S)Nc

Ssd
|S)Nz%%-%is |r0)
rCr0r0r1r¬¿	r¨z"make_lined_table.<locals>.<lambda>c

Ssd
|S)Nz%%-%is |r0)
rCr0r0r1r¬À	r¨rcr?cSs$d
 dd„|dg
|
dg
Dƒ
¡
S)Nú
+c
ss|]}
d|
d
V
qdS)rrÄNr0)r.rºr0r0r1r2Ä	sz5make_lined_table.<locals>.<lambda>.<locals>.<genexpr>rHr.)
r)r£r8r0r0r1r¬Ã	s
)
rB)r‹
rF
r0r0r1Úmake_lined_table¼	s




rFcOs(td
d„dd„df|žddd„i
|
—Ž
S)Nc


Ssd
S)Nz%sr0)
rCr0r0r1r¬Í	r¨z make_tex_table.<locals>.<lambda>c


Ssd
S)Nz& %sr0)
rCr0r0r1r¬Î	r¨z\\r?c
Ssd
S)Nz\hliner0)r£r8r0r0r1r¬Ñ	r¨)
rB)r‹
rF
r0r0r1Úmake_tex_tableÊ	s





rGc
sèt|ƒ
}
yt
 |
¡
}Wntk
r.


|
}YnXt
 
t
jt
j¡}| d
¡

| | d¡
d¡

d}x| 	d¡
}||7}|sdPqdW| 
¡
d‰‡f
dd„| d	¡
Dƒ
}x0td
t
|ƒ
ƒD]}|| ¡sÐ||=q´Pq´Wd	 |dd…¡
S)
zWhois client for Python)zwhois.ripe.neté+Úutf8s
r¨isremarks:c
s"g|]}
|
r|
r|
 ˆ¡
s|
‘qSr0)
r
)r.r½)
Ú
ignore_tagr0r1r¦î	szwhois.<locals>.<listcomp>ó

rHrGN)r4rêrírÐÚAF_INETÚSOCK_STREAMÚconnectÚsendrr´
rmrÕrr”rv
r)Ú
ip_addressZwhois_ipÚqueryr™ZanswerÚ
dÚlinesrwr0)
rJr1ÚwhoisÚ	s,





















rTc@s&eZ
dZd	dd„
Zdd„Zdd„ZdS)
ÚPeriodicSenderThreadçà?cCsFt|t
ƒstd
|ƒg
|_n||_|
|_t ¡|_||_tj	 
|¡

dS)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)r3rrÚ_pktsÚ_socketÚ	threadingÚEventÚ_stoppedÚ	_intervalÚThreadr
)r=ÚsockrÈÚintervalr0r0r1r
ý	s	






zPeriodicSenderThread.__init__c
CsHxB|j 
¡sBx2|jD](}
|j |
¡

t |j¡

|j 
¡rPqWqWdS)
N)r[Úis_setrWrXrOr,
r.
r\)r=r—r0r0r1Úrun
s





zPeriodicSenderThread.runc

Cs|j 
¡
dS)
N)r[Úset)
r=r0r0r1Ústop
szPeriodicSenderThread.stopN)
rV)r-rYrZr
rarcr0r0r0r1rUü	s

	rUc@s@eZ
dZd
d„Zedd„ƒ
Zdd„Zdd„Zd	d
„Zdd„Z	d
S)ÚSingleConversationSocketcCs|
|_t
 ¡|_dS)
N)Ú_innerrYÚRLockÚ	_tx_mutex)r=Ú
or0r0r1r

s
z!SingleConversationSocket.__init__c


Cs|jj
S)
N)rerV
)
r=r0r0r1rV
#
sz!SingleConversationSocket.__dict__cCst|j
|
ƒS)
N)rX
re)r=rlr0r0r1rZ
'
sz$SingleConversationSocket.__getattr__c
	Os |j
|j
j|
|Ž
SQRXdS)
N)rgreÚsr1)r=r‹
rF
r0r0r1ri+
s
zSingleConversationSocket.sr1c
	Os |j
|j
j|
|Ž
SQRXdS)
N)rgreÚsr)r=r‹
rF
r0r0r1rj0
s
zSingleConversationSocket.src	Cs|j
|j
 |
¡
SQRXdS)
N)rgrerO)r=r8r0r0r1rO5
s
zSingleConversationSocket.sendN)
r-rYrZr
ÚpropertyrV
rZ
rirjrOr0r0r0r1rd
s
rd)FrcF)FrcF)
F)
F)
F)r
r
F)
F)r
r
F)
F)NNNNNN)rH
r
)
N)r~
N)r~
N)
r“)
N)
F)
N)
NFFNNNFFNNNTF)r
F)NNNF)¤r[Ú
__future__rrrTrrÆr¹
r°rx
r{ràrù
rêrÞr€r\rhrYr,
r 
Zscapy.modules.sixÚmodulesr‰Zscapy.modules.six.movesrrrZscapy.configrZscapy.constsr	r
rZ
scapy.datarr
Zscapy.compatrrrrrrrrZscapy.errorrrrZscapy.pton_ntoprrrrrrrr r!r"r#r$r%r&r'r(rÁ
r)Zscapy.plistr*r+rò
r,Z_SuperSocketÚobjectr)
ÚGzipFilerë
r:rÓZ_Decimalr;rbrpryÚ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
r

r

r6
rA
rD
rG
rK
rN
rO
rP
r6r`
rr
rw
rz
r}
r‡
rˆ
r
r‘
r’
Ú
add_metaclassr™
r
rÇ
rå
ræ
r‰
rÿ
rrr	rr
rr+r<rBrDrFrGrTr]rUrdr0r0r0r1Ú<module>sT




















(
D



L








{



				



	
+-





Q












	'$
	


A1^(FJ
 












x
4

T



K"!