a k#d @szdZddlmZmZddlZddlmZmZddlZddl Z ddl Z ddl Z ddl m Z ddlmZddlmZddlmZdd lmZmZmZdd lmZdd lmZmZmZmZmZm Z dd l!m"Z"m#Z#m$Z$dd lm%Z%m&Z&m'Z'ddl(m)Z)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0m1Z1ddl m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;ddlmdurxddl?Z@GdddZAdZBe:e9e.e.fZCGdddeDZEddZFdQddZGdRdd ZHejIjJdSd!d"ZKejIjJdTd#d$ZLejIjJdUd%d&ZMd'd(ZNd)d*ZOejIjJdVd+d,ZPejIjJd-d.ZQejIjJdddddefd/d0ZRejIjJd1d2ZSeReSePeQfD] ZTeTjdurheTjeB7_qhd3d4d5d4d6dddd6fd7d8ZUejIjJd9d:ZVejIjJd;d<ZWGd=d>d>eDZXdWd?d@ZYejIjJdXdAdBZZejIjJdYdCdDZ[ejIjJdZdEdFZ\ejIjJd[dGdHZ]GdIdJdJeDZ^ejIjJdKdLZ_e^je__ejIjJd\dMdNZ`ejIjJdOdPZadS)]z( Functions to send and receive packets. )absolute_importprint_functionN)ThreadEvent) plain_str ETH_P_ALL)conf)warning) network_name resolve_ifaceNetworkInterface)Packet) get_temp_filetcpdumpwrpcapContextManagerSubprocess PcapReaderEDecimal) PacketList QueryAnswer SndRcvList) log_runtimelog_interactiveScapy_Exception)GenSetGen)six)DefaultSession) SuperSocket IterSocket) AnyCallableDictIteratorListOptionalTupleTypeUnioncast)_GlobInterfaceType)_PacketIterablec@s.eZdZegdZegdZegdZdZdS)debugReceivedSentMatchedN) __name__ __module__ __qualname__rrecvsentrmatchZ crashed_onr7r7E/var/www/html/gsl.tools/lib/python3.9/site-packages/scapy/sendrecv.pyr-Bs   r-a8 :param pks: SuperSocket instance to send/receive packets :param pkt: the packet to send :param timeout: how much time to wait after the last packet has been sent :param inter: delay between two packets during sending :param verbose: set verbosity level :param chainCC: if True, KeyboardInterrupts will be forwarded :param retry: if positive, how many times to resend unanswered packets if negative, how many times to retry when no more packets are answered :param multi: whether to accept multiple answers for the same stimulus :param rcv_pks: if set, will be used instead of pks to receive packets. packets will still be sent through pks :param prebuild: pre-build the packets before starting to send them. Automatically enabled when a generator is passed as the packet :param _flood: :param threaded: if True, packets will be sent in an individual thread :param session: a flow decoder used to handle stream of packets :param chainEX: if True, exceptions during send will be forwarded c @s:eZdZdZdddZddZd d Zd d Zd dZdS) SndRcvHandlera Util to send/receive packets, used by sr*(). Do not use directly. This matches the requests and answers. Notes:: - threaded mode: enabling threaded mode will likely break packet timestamps, but might result in a speedup when sending a big amount of packets. Disabled by default - DEVS: store the outgoing timestamp right BEFORE sending the packet to avoid races that could result in negative latency. We aren't Stadia NrFcCsx|durtj}tjr8tgdt_tgdt_tgdt_d|_ g|_ ||_ | pP||_ ||_ ||_||_||_||_| |_||_d|_d|_d|_| |_| r|jst||_n||_|dkr| }}nd}|dur|dkrd|_|dkri|_| s|jr6t|jd}d|_||j|jr,|j |!n ||j|rfdd t"j#t$%|jD}ntt"j#t$%|j}|rt&|dkrt&|t&|jkr|}||_t&|jdkrq|d 8}qtjrt|dddt_t|j ddt_|r$|j D]\}}t'|d r|`(q|r\t)d |j t&|j t&|j t*d|j|jft|j |_+t|d |_,dS)Nr.r/r0rF)targetTcSsg|]}t|ds|qS) _answered)hasattr).0pr7r7r8 s z*SndRcvHandler.__init__..r;z: Received %i packets, got %i answers, remaining %i packetsZ Unanswered)-r verb debug_matchrr-r4r5rr6nbrecvanspksrcv_pksinterverbosechainCCmultitimeoutsessionchainEX _send_donenotansnoans_floodlisttobesenthsentr _sndrcv_snddaemon _sndrcv_rcvstartstopjoin itertoolschainr itervalueslenr<r;printmax ans_result unans_result)selfrEpktrKrGrHrIretryrJrFZprebuildrQZthreadedrLrMZautostopZ snd_threadremainZsnd_r7r7r8__init__ts                zSndRcvHandler.__init__cCs |j|jfSN)rarbrcr7r7r8resultsszSndRcvHandler.resultscCs^d}d}zzh|jrtd|jD]<}|j|g||j|t |j |d7}q |jrptd|Wn6t yYn&t y|jrn tdYn0Wztt|jtt|j_WntyYn0|jr|jj|_n |js||_d|_nZztt|jtt|j_Wnty.Yn0|jrD|jj|_n|jsR||_d|_0dS)z/Function used in the sending thread of sndrcv()rNzBegin emission:r@zFinished sending %i packets.z--- Error sending packetsT)rHr_rSrT setdefaulthashretappendrEsendtimesleeprG SystemExit ExceptionrMr exceptionr*r sent_timeAttributeErrorrQiterlenrOrN)rcir>r7r7r8rUsL           zSndRcvHandler._sndrcv_sndcCs |dur dSd}|}||jvr|j|}t|D]|\}}||r4|jt|||jdkrnt ddd}|j s||=|j d7_ nt |ds|j d7_ d|_ qq4|jr|j |jkr|j s|jr|jjdd|s|jdkrt dd|jd7_tjrtj|dS) z.Internal function used to process each packet.NFr@*Tr;)rZ.)rmrT enumerateZanswersrDrnrrHoswriterJrPr<r;rNrOsnifferrYrCr rBr-r4)rcrokhZhlstrxZsentpktr7r7r8_process_packets8        zSndRcvHandler._process_packetcCsRd|_z,t|_|jj|j|jd|j|j|dWntyL|jrHYn0dS)z8Function used to receive packets and check their hashretNF)prnrKstore opened_socketrLstarted_callback) r~ AsyncSniffer_runrrKrFrLKeyboardInterruptrI)rccallbackr7r7r8rW1s  zSndRcvHandler._sndrcv_rcv) NrNFrFNFNFNF) r1r2r3__doc__rhrkrUrrWr7r7r7r8r9fs$ r&!r9cOst|i|}|S)zScapy raw function to send a packet and receive its answer. WARNING: This is an internal function. Using sr/srp/sr1/srp is more appropriate in many cases. )r9rk)argskwargsZsndrcverr7r7r8sndrcvDsrFcOst|trtj|d}t|ts(t|}|dur6tj}d} |durJ| }n|sRd}|r\tnd} d} zz|rd} |D]} |rt}| r| t | j|}|dkrt |n|t | j} | | | dur| | | d7} |rt ddt |qv|dkrh|d7}qhWnty&Yn0Wztt| jtt|_WntyVYn0n0ztt| jtt|_WntyYn00|rtd| | S)z An internal function used by send/sendp to actually send the packets, implement the send logic... It will take care of iterating through the different packets )loadNrr@rzz Sent %i packets.) isinstancestrr Z raw_layerrrrArrpfloatrqrornr|r}rr*rrurvr_)sxrGloopcountrHrealtimereturn_packetsrkargsnZ sent_packetsr>Zdt0ctstr7r7r8 __gen_sendNs\         rc KsX| du} t|ptj}| p.||fd|i| } t| |||||||d} | rT| | S)z(Internal function used by send and sendpNiface)rGrrrHrr)r r rrclose) rZ_funcrGrrrrHrrsocketrZ need_closingrkr7r7r8_sends rcKs$t||}t|ddfd|i|S)aq Send packets at layer 3 :param x: the packets :param inter: time (in s) between two packets (default 0) :param loop: send packet indefinitely (default 0) :param count: number of packets to send (default None=1) :param verbose: verbose mode (default None=conf.verb) :param realtime: check that a packet was sent before sending the next one :param return_packets: return the sent packets :param socket: the socket to use (default is conf.L3socket(kargs)) :param iface: the interface to send the packets on :param monitor: (not on linux) send in monitor mode :returns: None cSs|Sri)l3socketrr7r7r8zsend..r)_interface_selectionr)rrrr7r7r8ros rocKsD|dur(|dur(|dur(tj|d}t|ddf||d|S)aq Send packets at layer 2 :param x: the packets :param inter: time (in s) between two packets (default 0) :param loop: send packet indefinitely (default 0) :param count: number of packets to send (default None=1) :param verbose: verbose mode (default None=conf.verb) :param realtime: check that a packet was sent before sending the next one :param return_packets: return the sent packets :param socket: the socket to use (default is conf.L3socket(kargs)) :param iface: the interface to send the packets on :param monitor: (not on linux) send in monitor mode :returns: None NrcSs|Sri)l2socketrr7r7r8rrzsendp..)rr)r router)rr iface_hintrrr7r7r8sendpsrc  Cs|durtj}tjjdt|g} |dur:| d|n:|durR| d|n"|durj| d|n | d|dur| d||r| d|dur| |t} | | t| |d} t tjjzt j | t j t j d } Wn<t y td Ynnty*t| YnP0| \} }|rLt||r`t| || } ntjd krzt| Wdn1s0Ytj| rt| | S) aSend packets at layer 2 using tcpreplay for performance :param pps: packets per second :param mbps: MBits per second :param realtime: use packet's timestamp, bending time with real-time value :param loop: number of times to process the packet list. 0 implies infinite loop :param file_cache: cache packets in RAM instead of reading from disk at each iteration :param iface: output interface :param replay_args: List of additional tcpreplay args (List[str]) :param parse_results: Return a dictionary of information outputted by tcpreplay (default=False) :returns: stdout, stderr, command used Nz --intf1=%sz--pps=%iz --mbps=%fz--multiplier=%fz --topspeedz --loop=%iz--preload-pcap)stdoutstderrzInterrupted by user)r rprogZ tcpreplayr rnextendrrr subprocessPopenPIPErrinforsr|unlink communicaterr decode_parse_tcpreplay_resultrApathexists)rppsmbpsrr file_cacherZ replay_argsZ parse_resultsargvfrkcmdrrr7r7r8 sendpfastsP          . rc sz.r@ commandNrwarningszError parsing output: %s)rlowerstripsplitintritems startswithrZresearchr{getgrouprsr interactivererror)Zstdout_bZstderr_brrkrrelementsrJZ float_regZint_regZany_reglineelt_typesregexmatchesrxtypnameZparse_exceptionr7rr8r1sT        rcCsF|durBzt|d}Wnty6d}Yn0|p@tjS|S)zK Select the network interface according to the layer 3 destination Nr)next__iter__rrvr r)rpacketZiffr7r7r8rjs   rc Os@t||}tj||||d}t||g|Ri|}||S)z- Send and receive packets at layer 3 promiscfilterrnofilter)rr ZL3socketrr) rrrrrrrrresultr7r7r8sr|s rcOs,t|i|\}}|r(tt|ddSdS)zB Send packets at layer 3 and return only the first answer rr@N)rr*rrrrDrgr7r7r8sr1src Osh|dur |dur tj|d}t|p*tj}||||||d} t| |g|Ri|} | | S)z- Send and receive packets at layer 2 Nr)rrrrtype)r rr rrrr) rrrrrrrrrrrr7r7r8srps rcOs4t|i|\}}t|dkr0tt|ddSdS)zN Send and receive packets at layer 2 and return only the first answer rr@N)rr^r*rrr7r7r8srp1s rcCs |dS)Nr@summaryrr7r7r8rrrcCs|Srirrr7r7r8rrr@c Osd} d} tj} |durtj}d}g}g}|dur>td|d}zF|dN}| j| jg|}|durv|dkrnq|d8}t}|dkrtddd||g| R|ddd | }| t|dt|d7} | t|d7} |dkrX|rXt|ddkrXd t|d}td | |dd|dD]*}t|||tdt|ddq,|dkr|rt|ddkrd t|d}td | |dd|dD]*}t|||tdt|ddq|dkr|s|std t t t|dd|dkr>|dr(t dd|dr>t dd|r\||d7}||d7}t}|||krBt|||qBWntyYn0|r| dkrt| d| | d| | ft|t|fS)Nrrr@z send... r)endT)rKrHrIzRECV %i: zfail %i:zrecv:%i fail:%iryrzz4 Sent %i packets, received %i packets. %3.1f%% hits.gY@)r Z color_themerAminZevenZoddrpr_r^successZfailtuplemapr|r}rqrnormalrr)ZsrfuncpktsrZprnfailrGrKrrHrrrrrrZparityrDZunanscolrXresmsgr>rr7r7r8 __sr_loopsj  " "          rcOstt|g|Ri|S)z Send a packet at layer 3 in loop and print the answer each time srloop(pkts, [prn], [inter], [count], ...) --> None )rrrrrr7r7r8srloops rcOstt|g|Ri|S)z Send a packet at layer 2 in loop and print the answer each time srloop(pkts, [prn], [inter], [count], ...) --> None )rrrr7r7r8srploops rc@s>eZdZddZddZeddZejddZdd Zd S) _FloodGeneratorcCs||_||_t|_d|_dS)Nr)rS maxretriesr stopeventrw)rcrSrr7r7r8rh.sz_FloodGenerator.__init__ccsdd}|d7}d}|jr$||jkr$dS|jD]"}|jr>dS|d7}|Vq*|jdkr||_qdS)Nrr@)rrSris_setrw)rcrxjr>r7r7r8r5s   z_FloodGenerator.__iter__cCstt|jjSrir*rrSrurjr7r7r8ruEsz_FloodGenerator.sent_timecCs|tt|j_dSrir )rcvalr7r7r8ruJscCs|jdSri)rsetrjr7r7r8rYOsz_FloodGenerator.stopN) r1r2r3rhrpropertyrusetterrYr7r7r7r8r-s  rc Cs t||}t|||||||dS)zsndrcv equivalent for flooding.)rGrHrIrKrQ)rr)rErdrGrrHrIrKZ flood_genr7r7r8 sndrcvfloodTs rc OsFt|p tj}|||||d}t||g|Ri|}||S)a<Flood and receive packets at layer 3 :param prn: function applied to packets received :param unique: only consider packets whose print :param nofilter: put 1 to avoid use of BPF filters :param filter: provide a BPF filter :param iface: listen answers only on the given interface r)r r rrrr) rrrrrrrrrr7r7r8srfloodhs rc Osht|p tj}|||||d}t||g|Ri|\}} |t|dkrdtt|ddSdS)aOFlood and receive packets at layer 3 and return only the first answer :param prn: function applied to packets received :param verbose: set verbosity level :param nofilter: put 1 to avoid use of BPF filters :param filter: provide a BPF filter :param iface: listen answers only on the given interface rrrrrr@N) r r rrrrr^r*r rrrrrrrrrDrgr7r7r8sr1floods rc Osf|dur |dur tj|d}t|p*tj}|||||d}t||g|Ri|} || S)a<Flood and receive packets at layer 2 :param prn: function applied to packets received :param unique: only consider packets whose print :param nofilter: put 1 to avoid use of BPF filters :param filter: provide a BPF filter :param iface: listen answers only on the given interface Nrr)r rr rrrr) rrrrrrrrrrr7r7r8srpfloodsrc Osht|p tj}|||||d}t||g|Ri|\}} |t|dkrdtt|ddSdS)aOFlood and receive packets at layer 2 and return only the first answer :param prn: function applied to packets received :param verbose: set verbosity level :param nofilter: put 1 to avoid use of BPF filters :param filter: provide a BPF filter :param iface: listen answers only on the given interface rrr@N) r r rrrrr^r*rrr7r7r8 srp1floods rc@s`eZdZdZddZddZdddd dddddddddifd d Zd d ZdddZddZ dS)ra Sniff packets and return a list of packets. Args: count: number of packets to capture. 0 means infinity. store: whether to store sniffed packets or discard them prn: function to apply to each packet. If something is returned, it is displayed. --Ex: prn = lambda x: x.summary() session: a session = a flow decoder used to handle stream of packets. --Ex: session=TCPSession See below for more details. filter: BPF filter to apply. lfilter: Python function applied to each packet to determine if further action may be done. --Ex: lfilter = lambda x: x.haslayer(Padding) offline: PCAP file (or list of PCAP files) to read packets from, instead of sniffing them quiet: when set to True, the process stderr is discarded (default: False). timeout: stop sniffing after a given time (default: None). L2socket: use the provided L2socket (default: use conf.L2listen). opened_socket: provide an object (or a list of objects) ready to use .recv() on. stop_filter: Python function applied to each packet to determine if we have to stop the capture after this packet. --Ex: stop_filter = lambda x: x.haslayer(TCP) iface: interface or list of interfaces (default: None for sniffing on all interfaces). monitor: use monitor mode. May not be available on all OS started_callback: called as soon as the sniffer starts sniffing (default: None). The iface, offline and opened_socket parameters can be either an element, a list of elements, or a dict object mapping an element to a label (see examples below). For more information about the session argument, see https://scapy.rtfd.io/en/latest/usage.html#advanced-sniffing-sniffing-sessions Examples: synchronous >>> sniff(filter="arp") >>> sniff(filter="tcp", ... session=IPSession, # defragment on-the-flow ... prn=lambda x: x.summary()) >>> sniff(lfilter=lambda pkt: ARP in pkt) >>> sniff(iface="eth0", prn=Packet.summary) >>> sniff(iface=["eth0", "mon0"], ... prn=lambda pkt: "%s: %s" % (pkt.sniffed_on, ... pkt.summary())) >>> sniff(iface={"eth0": "Ethernet", "mon0": "Wifi"}, ... prn=lambda pkt: "%s: %s" % (pkt.sniffed_on, ... pkt.summary())) Examples: asynchronous >>> t = AsyncSniffer(iface="enp0s3") >>> t.start() >>> time.sleep(1) >>> print("nice weather today") >>> t.stop() cOs"||_||_d|_d|_d|_dSNF)rrrunningthreadrkrcrrr7r7r8rhs zAsyncSniffer.__init__cCs$t|j|j|jdd|_d|j_dS)Nr)r:rrrT)rrrrrrVrjr7r7r8 _setup_threadszAsyncSniffer._setup_threadrTNFc sDd_t| ts.| pt} | f||d|} n || _|| _i}| durt| trj|ddt| Dn.t| tr|ddt | Dnd|| <|dur dt|t r|g}t|trt dd|Dr|fd d|Dnt|tr"|fd dt |Dntt|tttfrjt|}||durN|ntt|d d gdd <n,||tdur~|nt|d d gdd <|r| dur0fddt| tr|fdd| DnVt| tr|fddt | Dn(| ptj} | || ft| d<tt|}|jt|dd}t fdd|Dsntdd|sddlm}|dd|<fdd}|_nfdd}|_z,| r| d_|durt|}d}|rjr|dur |t}|dkr qt| |}g}|D]x}|urPqz |!}Wnt"yz |#Wnt$yYn0|%|Yq:Ynt$y@}zd}z |#Wn.t$y}zd|}WYd}~n d}~00td||f||%|tj&d krWYd}~q:WYd}~n d}~00|durPq:|rd||sdq:|||_'| (|| r| |sd|kr| j)kr:nn d_qq:|D]*}||=t*|d!kr|vr|=qqWnt+yYn0d_| dur(|D]}|#qnr6#| ,_-dS)"NTrrcss|]\}}|d|fVqdS)zsocket%dNr7)r=rxrr7r7r8 Hsz$AsyncSniffer._run..css|]\}}||fVqdSrir7)r=rlabelr7r7r8rMsZsocket0rcss|]}t|tVqdSri)rr)r=rr7r7r8rZrc 3s8|]0}tdur|nt|ddgdd|fVqdSN-w-TrfltZgetfdquietrr)r=fnamer!r"r7r8r\s c 3s<|]4\}}tdur|nt|ddgdd|fVqdSrr#)r=r$rr%r7r8rfs rrr cspt|Sri)r Zl2listenrx)L2socketr7r8rrz#AsyncSniffer._run..c3s*|]"}|ft|d|fVqdSrrNr)r=ifname_RL2kargr7r8rsc3s.|]&\}}|ft|d|fVqdSr(r)r=r*Ziflabelr+r7r8rsr)nonblocking_socketFc3s|]}|jkVqdSri)select)r=sock) select_funcr7r8rrzaWarning: inconsistent socket types ! The used select function will be the one of the first socketr) ObjectPipeZcontrol_socketcsjrrdd_dSr)rrocontinue_sniffr7) close_pipercr7r8stop_cbs  z"AsyncSniffer._run..stop_cbcs d_dSr)r3r7rjr7r8r5sz It was closed.z close() failed with '%s'zSocket %s failed with '%s'.rr@).rrrrrrRupdater{dictr iteritemsrrallrrr rrr rrriterr/getattrr Zscapy.automatonr2r5r3rpkeysr4EOFErrorrrsrnZdebug_dissector sniffed_onZon_packet_receivedrr^rZ toPacketListrk)rcrroffliner"rZlfilterr'rKrZ stop_filterrrrLZsession_kwargsr-Z sniff_socketsZ _main_socketr.r2r5ZstoptimerfsocketsZ dead_socketsrr>exrZex2r7)r'r,r4r!r-r"r1rcr8r(s,                                        $       zAsyncSniffer._runcCs||jr|jdS)z!Starts AsyncSniffer in async modeN)rrrXrjr7r7r8rXszAsyncSniffer.startcCsP|jrDz |Wnty,tdYn0|r@||jSdStddS)z'Stops AsyncSniffer if not in async modez+Unsupported (offline or unsupported socket)Nz#Not running ! (check .running attr))rr5rvrrZrk)rcrZr7r7r8rYs   zAsyncSniffer.stopcOs|jr|jj|i|dSri)rrZrr7r7r8rZszAsyncSniffer.join)T) r1r2r3rrhrrrXrYrZr7r7r7r8rs,>   V rcOs"t}|j|i|tt|jSri)rrr*rrk)rrr~r7r7r8sniffsrBc sdD]}||vrtd|||=q|fdd} | |d\} }| |d\} }|| || ii|durl||<|dur|||<fdd |dur}n|fd d }t|| || |i|d |S) aForward traffic between interfaces if1 and if2, sniff and return the exchanged packets. :param if1: the interfaces to use (interface names or opened sockets). :param if2: :param xfrm12: a function to call when forwarding a packet from if1 to if2. If it returns True, the packet is forwarded as it. If it returns False or None, the packet is discarded. If it returns a packet, this packet is forwarded instead of the original packet one. :param xfrm21: same as xfrm12 for packets forwarded from if2 to if1. The other arguments are the same than for the function sniff(), except for offline, opened_socket and iface that are ignored. See help(sniff) for more. )rr?rz@Argument %s cannot be used in bridge_and_sniff() -- ignoring it.cSsBt|tr|d|fS|s0t|p$tj}|}||d|fSdS)Nziface%dr)rrr r rr)rrr'r7r7r8 _init_socketGs   z&bridge_and_sniff.._init_socketr@rNc sz|jp d}Wnty&YdS0|jvrz|j|}Wn,typtjd||jddYdS0t|tr|sdS|}q|}n|}z||Wn*tytjd||jddYn0dS)NzOException in transformation function for packet [%s] received on %s -- droppingT)exc_infoz)Cannot forward packet [%s] received on %s) r>KeyErrorrsrr rrboolro)rdZsendsockZ_newpktZnewpkt)peersxfrmsr7r8prn_send\s2       z"bridge_and_sniff..prn_sendcs||Srir7rd)prn_origrJr7r8rszbridge_and_sniff..prn)rr)rr rB) Zif1Zif2Zxfrm12Zxfrm21rr'rrargrCZsckt1Zsckt2r7)rHrLrJrIr8bridge_and_sniff&s4  rNcsd|vr|d}n"d|vr0tt|dj}ntj}td|dgfdd}t||dd|td ddd krd nd fd S)z|Sniff packets and print them calling pkt.summary(). This tries to replicate what text-wireshark (tshark) would look likerrzCapturing on '%s'rcs,tdd|fdd7<dS)Nz%5d %srr@)r_rrKr&r7r8_cbsztshark.._cbFrz %d packet%s capturedr@rrDN)rr*rrr r_rB)rrrrOr7r&r8tsharks   rP)rrNNFF)rrNNNFFN)N)NNN)NNFNFNNF)NNNr)rNNFN)NNNN)NNNr)NNNNN)NNNr)NNNN)br __future__rrr[ threadingrrr|rrrpZ scapy.compatrZ scapy.datarZ scapy.configr Z scapy.errorr Zscapy.interfacesr r r Z scapy.packetrZ scapy.utilsrrrrrrZ scapy.plistrrrrrrZscapy.base_classesrrZ scapy.libsrZscapy.sessionsrZscapy.supersocketrr r!r"r#r$r%r&r'r(r)r*r+r,rZ scapy.routeZscapyr-Z_DOC_SNDRCV_PARAMSZ_GlobSessionTypeobjectr9rrrcommandsregisterrorrrrrrrrZsr_funcrrrrrrrrrrrBrNrPr7r7r7r8s$        0    _  B   ! I9      F  )     H  a