a
    kÄ#dyî ã                	   @   s¾  d 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mZ ddlmZ ddlmZ ddlmZ ddlmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z& dd	l'm(Z( dd
l)m*Z*m+Z+ ddl,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 ddl3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z< ddl=m>Z>m?Z?m@Z@mAZAmBZBmCZC ddlDmEZEmFZFmGZGmHZH ddl)mIZI ddlJmK  mLZL ddlJmMZM zddlNmOZO W n eP�yÎ   dZOY n0 ddl,mQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^ e^�r"ddl_m`Z` G dd„ dƒZaG dd„ deTebecf ƒZde[dƒZee[dƒZfeL geH¡G dd„ deVeeeff ƒƒZhG dd„ deiƒZje\eheQeQf ejf ZkG dd „ d ejƒZlG d!d"„ d"ejƒZmG d#d$„ d$ejƒZnG d%d&„ d&ejƒZoG d'd(„ d(ejƒZpG d)d*„ d*epƒZqG d+d,„ d,erƒZsG d-d.„ d.ejƒZtG d/d0„ d0etƒZuG d1d2„ d2ehecerf ƒZvG d3d4„ d4eheWec erf ƒZwG d5d6„ d6ehe\eceFf erf ƒZxG d7d8„ d8exƒZyG d9d:„ d:eheWe\eceBf  erf ƒZzG d;d<„ d<ezƒZ{G d=d>„ d>ezevƒZ|G d?d@„ d@ehebebf ƒZ}G dAdB„ dBe}ƒZ~G dCdD„ dDe}ƒZG dEdF„ dFehebebf ƒZ€G dGdH„ dHe€e~ƒZ�G dIdJ„ dJe}ƒZ‚G dKdL„ dLe‚e~ƒZƒG dMdN„ dNehebeUeb f ƒZ„G dOdP„ dPe„ƒZ…G dQdR„ dRehebebf ƒZ†G dSdT„ dTe+ƒZ‡G dUdV„ dVe+ƒZˆG dWdX„ dXe}ƒZ‰G dYdZ„ dZehebebf ƒZŠG d[d\„ d\ehebebf ƒZ‹G d]d^„ d^ehebebf ƒZŒG d_d`„ d`ehebebf ƒZ�G dadb„ dbeŠƒZŽG dcdd„ ddehebebf ƒZ�G dedf„ dfehebebf ƒZ�G dgdh„ dhehebebf ƒZ‘G didj„ djehebebf ƒZ’G dkdl„ dle�ƒZ“G dmdn„ dne‘e“ƒZ”G dodp„ dpeŒeŽƒZ•G dqdr„ drehebebf ƒZ–G dsdt„ dtehebebf ƒZ—G dudv„ dve–ƒZ˜G dwdx„ dxehebebf ƒZ™G dydz„ dze–ƒZšG d{d|„ d|e˜ešƒZ›G d}d~„ d~ehebebf ƒZœG dd€„ d€ehebebf ƒZ�G d�d‚„ d‚eheeerf ƒZžG dƒd„„ d„ežer ƒZŸG d…d†„ d†eŸƒZ G d‡dˆ„ dˆƒZ¡G d‰dŠ„ dŠe¡eŸƒZ¢e[d‹eUeG eGeWeG ƒZ£G dŒd�„ d�eže£ ƒZ¤G dŽd�„ d�e¤eG ƒZ¥G d�d‘„ d‘e¤eWeG  ƒZ¦G d’d“„ d“e¤eUeG  ƒZ§G d”d•„ d•eŸƒZ¨G d–d—„ d—e¨e ƒZ©G d˜d™„ d™e¡e¨ƒZªG dšd›„ d›e¨ƒZ«G dœd�„ d�eŸƒZ¬G dždŸ„ dŸehererf ƒZ­G d d¡„ d¡e­eŸƒZ®G d¢d£„ d£e­e¬ƒZ¯G d¤d¥„ d¥e­e¨ƒZ°G d¦d§„ d§e¯ƒZ±G d¨d©„ d©e¬e ƒZ²G dªd«„ d«e¬ƒZ³G d¬d­„ d­eheUeQ eUeQ f ƒZ´G d®d¯„ d¯ehebebf ƒZµG d°d±„ d±eŸƒZ¶G d²d³„ d³e¶e ƒZ·G d´dµ„ dµeŸƒZ¸G d¶d·„ d·ehebebf ƒZ¹G d¸d¹„ d¹eheºebf ƒZ»G dºd»„ d»eheeebf ƒZ¼G d¼d½„ d½e¼eb ƒZ½G d¾d¿„ d¿e½ƒZ¾G dÀdÁ„ dÁe½ƒZ¿G dÂdÃ„ dÃe½ƒZÀG dÄdÅ„ dÅehe\eUee eef eef ƒZÁG dÆdÇ„ dÇeÁee ƒZÂG dÈdÉ„ dÉeÂec ƒZÃG dÊdË„ dËe¼e\eUeb ebf  eÁeb ƒZÄG dÌdÍ„ dÍeÂeb ƒZÅG dÎdÏ„ dÏeÂeb ƒZÆG dÐdÑ„ dÑeÂeb ƒZÇG dÒdÓ„ dÓeÂeb ƒZÈG dÔdÕ„ dÕeÈƒZÉG dÖd×„ d×eÂeb ƒZÊG dØdÙ„ dÙeÂeb ƒZËG dÚdÛ„ dÛeÂeb ƒZÌG dÜdÝ„ dÝeÅƒZÍG dÞdß„ dßeÁee ƒZÎG dàdá„ dáeÎeb eÂeb ƒZÏG dâdã„ dãe¼e\eUeb ebf  eÎeb ƒ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íeiƒZÕG dîdï„ dïeiƒZÖG dðdñ„ dñe¼eWe\ebeÖf   ƒZ×e Ødòdódôg¡ZÙG dõdö„ döe¼eXec  ƒZÚG d÷dø„ døe½ƒZÛG dùdú„ dúeheYecebf eYerebf f ƒZÜG dûdü„ düeÜƒZÝG dýdþ„ dþeÜƒZÞG dÿ�d „ �d eheºebf ƒZßG �d�d„ �deheºebf ƒZàG �d�d„ �deiƒZáG �d�d„ �deáehe\ebeºf e\ebeºf f ƒZâG �d�d„ �deáe½ƒZãG �d	�d
„ �d
e�ƒZäG �d�d„ �deheerf ƒZåG �d�d„ �deåeÁe ƒZæG �d�d„ �deheWeb erf ƒZçG �d�d„ �deçƒZèG �d�d„ �deçƒZédS (  z>
Fields: basic data structures that make up parts of packets.
é    )Úabsolute_importN)Ú
MethodType)ÚUUID)Úconf)ÚDADict)ÚRandBinÚRandByteÚRandEnumKeysÚRandIntÚRandIPÚRandIP6ÚRandLongÚRandMACÚRandNumÚ	RandShortÚRandSIntÚ	RandSByteÚRandTermStringÚRandUUIDÚVolatileValueÚ
RandSShortÚ	RandSLongÚ	RandFloat)ÚEPOCH)Úlog_runtimeÚScapy_Exception)Ú	bytes_hexÚchbÚorbÚ	plain_strÚrawÚbytes_encode)Ú	inet_ntopÚ	inet_pton)Ú	inet_atonÚ	inet_ntoaÚlhexÚmac2strÚstr2macÚEDecimal)Úin6_6to4ExtractAddrÚin6_isaddr6to4Úin6_isaddrTeredoÚin6_ptopÚNet6ÚteredoAddrExtractInfo)ÚGenÚNetÚ
BasePacketÚField_metaclass)Úwarning)Úinteger_types)ÚEnum)ÚAnyÚAnyStrÚCallableÚDictÚListÚGenericÚOptionalÚSetÚTupleÚTypeÚTypeVarÚUnionÚcastÚTYPE_CHECKING)ÚPacketc                   @   s:   e Zd ZdZddd„Zdd„ Zdd„ Zd	d
„ Zdd„ ZdS )ÚRawVala  
    A raw value that will not be processed by the field and inserted
    as-is in the packet string.

    Example::

        >>> a = IP(len=RawVal("####"))
        >>> bytes(a)
        b'F\x00####\x00\x01\x00\x005\xb5\x00\x00\x7f\x00\x00\x01\x7f\x00\x00\x01\x00\x00'

    ó    c                 C   s   t |ƒ| _d S ©N)r!   Úval)ÚselfrI   © rK   úC/var/www/html/gsl.tools/lib/python3.9/site-packages/scapy/fields.pyÚ__init__W   s    zRawVal.__init__c                 C   s
   t | jƒS rH   )ÚstrrI   ©rJ   rK   rK   rL   Ú__str__[   s    zRawVal.__str__c                 C   s   | j S rH   ©rI   rO   rK   rK   rL   Ú	__bytes___   s    zRawVal.__bytes__c                 C   s
   t | jƒS rH   )ÚlenrI   rO   rK   rK   rL   Ú__len__c   s    zRawVal.__len__c                 C   s
   d| j  S )Nz<RawVal [%r]>rQ   rO   rK   rK   rL   Ú__repr__g   s    zRawVal.__repr__N)rG   )	Ú__name__Ú
__module__Ú__qualname__Ú__doc__rM   rP   rR   rT   rU   rK   rK   rK   rL   rF   J   s   
rF   c                       sH   e Zd ZdZ‡ fdd„Zdd„ Z‡ fdd„Z‡ fdd	„Zd
d„ Z‡  Z	S )ÚObservableDictzQ
    Helper class to specify a protocol extendable for runtime modifications
    c                    s    g | _ tt| ƒj|i |¤Ž d S rH   )Ú	observersÚsuperrZ   rM   )rJ   ÚargsÚkw©Ú	__class__rK   rL   rM   q   s    zObservableDict.__init__c                 C   s   | j  |¡ d S rH   )r[   Úappend)rJ   ZobserverrK   rK   rL   Úobservev   s    zObservableDict.observec                    s0   | j D ]}| | ||¡ qtt| ƒ ||¡ d S rH   )r[   Ú
notify_setr\   rZ   Ú__setitem__)rJ   ÚkeyÚvalueÚor_   rK   rL   rd   z   s    
zObservableDict.__setitem__c                    s,   | j D ]}| | |¡ qtt| ƒ |¡ d S rH   )r[   Ú
notify_delr\   rZ   Ú__delitem__)rJ   re   rg   r_   rK   rL   ri   €   s    
zObservableDict.__delitem__c                 C   s   |D ]}|| | |< qd S rH   rK   )rJ   ZanotherDictÚkrK   rK   rL   Úupdate†   s    zObservableDict.update)
rV   rW   rX   rY   rM   rb   rd   ri   rk   Ú__classcell__rK   rK   r_   rL   rZ   l   s   rZ   ÚIÚMc                   @   s¦   e Zd ZdZg d¢Zd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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 )(ÚFieldzÄ
    For more information on how this works, please refer to the
    'Adding new protocols' chapter in the online documentation:

    https://scapy.readthedocs.io/en/stable/build_dissect.html
    )ÚnameÚfmtÚdefaultÚszÚownersÚstructr   FÚHc                 C   sj   t |tƒstdƒ‚|| _|d dv r,|| _n
d| | _t | j¡| _|  d |¡| _t 	| j¡| _
g | _d S )Nzname should be a stringr   z@=<>!ú!)Ú
isinstancerN   Ú
ValueErrorrp   rq   ru   ÚStructÚany2irr   Úcalcsizers   rt   )rJ   rp   rr   rq   rK   rK   rL   rM   §   s    

zField.__init__c                 C   s   | j  |¡ d S rH   )rt   ra   )rJ   ÚclsrK   rK   rL   Úregister_ownerµ   s    zField.register_ownerc                 C   s   t |tƒrt|ƒS | jS )z<Convert internal value to a length usable by a FieldLenField)rx   rF   rS   rs   ©rJ   ÚpktÚxrK   rK   rL   Úi2len¹   s    
zField.i2lenc                 C   s   dS )zqConvert internal value to a number of elements usable by a FieldLenField.
        Always 1 except for list fieldsé   rK   r   rK   rK   rL   Úi2countÃ   s    zField.i2countc                 C   s
   t t|ƒS )z%Convert human value to internal value©rC   rm   r   rK   rK   rL   Úh2iÉ   s    z	Field.h2ic                 C   s   |S )z%Convert internal value to human valuerK   r   rK   rK   rL   Úi2hÎ   s    z	Field.i2hc                 C   s
   t t|ƒS )z'Convert machine value to internal valuer…   r   rK   rK   rL   Úm2iÓ   s    z	Field.m2ic                 C   s4   |du rt tdƒS t|tƒr*t tt|ƒƒS t t|ƒS )z'Convert internal value to machine valueNr   )rC   rn   rx   rN   r!   r   rK   rK   rL   Úi2mØ   s
    

z	Field.i2mc                 C   s   |   ||¡S )zUTry to understand the most input values possible and make an internal value from them©r†   r   rK   rK   rL   r{   á   s    zField.any2ic                 C   s   t |  ||¡ƒS )z/Convert internal value to a nice representation)Úreprr‡   r   rK   rK   rL   Úi2repræ   s    zField.i2reprc              
   C   sd   z|| j  |  ||¡¡ W S  t jy^ } z*td| j d|  d d ƒ‚W Y d}~n
d}~0 0 dS )zÅAdd an internal value to a string

        Copy the network representation of field `val` (belonging to layer
        `pkt`) to the raw string packet `s`, and return the new string packet.
        z&Incorrect type of value for field %s:
zstruct.error('%s')
z7To inject bytes into the field regardless of the type, zuse RawVal. See help(RawVal)N)ru   Úpackr‰   Úerrorry   rp   )rJ   r€   ÚsrI   ÚexrK   rK   rL   Úaddfieldë   s    ÿþýÿzField.addfieldc              	   C   s0   || j d… |  || j |d| j … ¡d ¡fS )aD  Extract an internal value from a string

        Extract from the raw packet `s` the field value belonging to layer
        `pkt`.

        Returns a two-element list,
        first the raw packet string after having removed the extracted field,
        second the extracted field itself in internal representation.
        Nr   ©rs   rˆ   ru   Úunpack©rJ   r€   r�   rK   rK   rL   Úgetfieldü   s    zField.getfieldc                 C   s`   t |tƒrJ|d d … }tt|ƒƒD ]"}t || tƒr"||  ¡ ||< q"|S t|dƒr\| ¡ S |S )NÚcopy)rx   ÚlistÚrangerS   r2   r–   Úhasattr)rJ   r�   ÚirK   rK   rL   Údo_copy	  s    

zField.do_copyc                 C   s&   d| j jd dd„ | jD ƒ¡| jf S )Nz<%s (%s).%s>ú,c                 s   s   | ]}|j V  qd S rH   )rV   ©Ú.0r�   rK   rK   rL   Ú	<genexpr>  rG   z!Field.__repr__.<locals>.<genexpr>)r`   rV   Újoinrt   rp   rO   rK   rK   rL   rU     s
    ýzField.__repr__c                 C   s
   t   | ¡S rH   )r–   rO   rK   rK   rL   r–     s    z
Field.copyc              	   C   sŠ   | j d }|dv r.ttttttttdœ| ƒ S |dkrr| j d dv rXt	| j dd… ƒ}nt	| j dd… ƒ}t
|ƒS td	| j| j f ƒ‚dS )
zOReturn a volatile object whose value is both random and suitable for this fieldéÿÿÿÿZBbHhIiQq)ÚBÚbrv   Úhrm   rš   ÚQÚqr�   r   Ú
0123456789Nrƒ   z"no random class for [%s] (fmt=%s).)rq   r   r   r   r   r
   r   r   r   Úintr   ry   rp   )rJ   Zfmttrf   rK   rK   rL   Úrandval!  s&    
ýýÿÿzField.randvalN)rv   )rV   rW   rX   rY   Ú	__slots__ÚislistÚ	ismutableÚholds_packetsrM   r~   r‚   r„   r†   r‡   rˆ   r‰   r{   rŒ   r‘   r•   r›   rU   r–   r©   rK   rK   rK   rL   ro   “   s*   

	ro   c                   @   s   e Zd ZdZdd„ ZdS )Ú_FieldContainerz<
    A field that acts as a container for another field
    c                 C   s   t | j|ƒS rH   ©ÚgetattrÚfld©rJ   ÚattrrK   rK   rL   Ú__getattr__=  s    z_FieldContainer.__getattr__N)rV   rW   rX   rY   r´   rK   rK   rK   rL   r®   8  s   r®   c                   @   s2   e Zd ZdZdgZdd„ Zdd„ Zdd„ Zd	Zd	S )
ÚEmphzEmpathize sub-layer for displayr±   c                 C   s
   || _ d S rH   ©r±   ©rJ   r±   rK   rK   rL   rM   I  s    zEmph.__init__c                 C   s   t | j|kƒS rH   )Úboolr±   ©rJ   ÚotherrK   rK   rL   Ú__eq__M  s    zEmph.__eq__c                 C   s
   | |k S rH   rK   r¹   rK   rK   rL   Ú__ne__Q  s    zEmph.__ne__N)	rV   rW   rX   rY   rª   rM   r»   r¼   Ú__hash__rK   rK   rK   rL   rµ   E  s   rµ   c                   @   s$   e Zd Zg d¢Zdd„ Zdd„ ZdS )ÚActionField©r±   Ú_action_methodÚ	_privdatac                 K   s   || _ || _|| _d S rH   r¿   )rJ   r±   Zaction_methodZkargsrK   rK   rL   rM   ]  s    zActionField.__init__c                 C   s0   t || jƒ|| jfi | j¤Ž t | jdƒ||ƒS )Nr{   )r°   rÀ   r±   rÁ   ©rJ   r€   rI   rK   rK   rL   r{   c  s    zActionField.any2iN)rV   rW   rX   rª   rM   r{   rK   rK   rK   rL   r¾   Z  s   r¾   c                   @   sL   e Zd ZddgZdd„ Zdd„ Zdd„ Zd	d
„ Zdd„ Zdd„ Z	dd„ Z
dS )ÚConditionalFieldr±   Úcondc                 C   s   || _ || _d S rH   )r±   rÄ   )rJ   r±   rÄ   rK   rK   rL   rM   l  s    zConditionalField.__init__c                 C   s   t |  |¡ƒS rH   )r¸   rÄ   ©rJ   r€   rK   rK   rL   Ú	_evalcondt  s    zConditionalField._evalcondc                 C   s    t | jƒtu r|S | j ||¡S rH   )Útyper±   ro   r{   r   rK   rK   rL   r{   x  s    zConditionalField.any2ic                 C   s    |r|   |¡sd S | j ||¡S rH   )rÆ   r±   r‡   rÂ   rK   rK   rL   r‡   ‡  s    zConditionalField.i2hc                 C   s$   |   |¡r| j ||¡S |d fS d S rH   )rÆ   r±   r•   r”   rK   rK   rL   r•   �  s    
zConditionalField.getfieldc                 C   s"   |   |¡r| j |||¡S |S d S rH   )rÆ   r±   r‘   ©rJ   r€   r�   rI   rK   rK   rL   r‘   ”  s    
zConditionalField.addfieldc                 C   s   t | j|ƒS rH   r¯   r²   rK   rK   rL   r´   ›  s    zConditionalField.__getattr__N)rV   rW   rX   rª   rM   rÆ   r{   r‡   r•   r‘   r´   rK   rK   rK   rL   rÃ   i  s   rÃ   c                   @   s”   e Zd ZdZg 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d„ Zdd„ Zdd„ Zdd„ Zdd„ Zedd „ ƒZd!S )"ÚMultipleTypeFielda¡  MultipleTypeField are used for fields that can be implemented by
various Field subclasses, depending on conditions on the packet.

It is initialized with `flds` and `dflt`.

`dflt` is the default field type, to be used when none of the
conditions matched the current packet.

`flds` is a list of tuples (`fld`, `cond`), where `fld` if a field
type, and `cond` a "condition" to determine if `fld` is the field type
that should be used.

`cond` is either:

  - a callable `cond_pkt` that accepts one argument (the packet) and
    returns True if `fld` should be used, False otherwise.

  - a tuple (`cond_pkt`, `cond_pkt_val`), where `cond_pkt` is the same
    as in the previous case and `cond_pkt_val` is a callable that
    accepts two arguments (the packet, and the value to be set) and
    returns True if `fld` should be used, False otherwise.

See scapy.layers.l2.ARP (type "help(ARP)" in Scapy) for an example of
use.

    )ÚfldsÚdfltrp   rr   c                    sJ   |ˆ _ |ˆ _d ˆ _ˆ jjˆ _t‡ fdd„ˆ j D ƒƒrFt dˆ j t¡ d S )Nc                 3   s   | ]}|d  j ˆ j kV  qdS )r   N©rp   r�   rO   rK   rL   rŸ   Ç  rG   z-MultipleTypeField.__init__.<locals>.<genexpr>z@All fields should have the same name in a MultipleTypeField (%s))rÊ   rË   rr   rp   ÚanyÚwarningsÚwarnÚSyntaxWarning)rJ   rÊ   rË   rK   rO   rL   rM   ¾  s    
ÿýzMultipleTypeField.__init__c                 C   sf   | j D ]X\}}t|tƒrN|rF|du r,| jj}|d ||ƒr|  S qn|d }||ƒr|  S q| jS )z;Internal function used by _find_fld_pkt & _find_fld_pkt_valNrƒ   r   )rÊ   rx   ÚtuplerË   rr   )rJ   r€   rI   Zuse_valr±   rÄ   rK   rK   rL   Ú_iterate_fields_condÎ  s    

z&MultipleTypeField._iterate_fields_condc                 C   s   |   |dd¡S )z©Given a Packet instance `pkt`, returns the Field subclass to be
used. If you know the value to be set (e.g., in .addfield()), use
._find_fld_pkt_val() instead.

        NF)rÒ   rÅ   rK   rK   rL   Ú_find_fld_pktà  s    zMultipleTypeField._find_fld_pktc                 C   s$   |   ||d¡}|du r|j}||fS )z‘Given a Packet instance `pkt` and the value `val` to be set,
returns the Field subclass to be used, and the updated `val` if necessary.

        TN)rÒ   rr   ©rJ   r€   rI   r±   rK   rK   rL   Ú_find_fld_pkt_valé  s    	z#MultipleTypeField._find_fld_pkt_valc                 C   sl   t  ¡ jj}|durfz|jd }W n ty4   Y n*0 t|t| jjƒƒr^|j	sT| jS |  
|¡S |j}q| jS )a½  Returns the Field subclass to be used, depending on the Packet
instance, or the default subclass.

DEV: since the Packet instance is not provided, we have to use a hack
to guess it. It should only be used if you cannot provide the current
Packet instance (for example, because of the current Scapy API).

If you have the current Packet instance, use ._find_fld_pkt_val() (if
the value to set is also known) of ._find_fld_pkt() instead.

        NrJ   )ÚinspectÚcurrentframeÚf_backÚf_localsÚKeyErrorrx   rÑ   rË   rt   Zdefault_fieldsrÓ   )rJ   Úframer€   rK   rK   rL   Ú	_find_fld÷  s    
zMultipleTypeField._find_fldc                 C   s   |   |¡ ||¡S rH   )rÓ   r•   r”   rK   rK   rL   r•     s    zMultipleTypeField.getfieldc                 C   s   |   ||¡\}}| |||¡S rH   )rÕ   r‘   )rJ   r€   r�   rI   r±   rK   rK   rL   r‘     s    zMultipleTypeField.addfieldc                 C   s   |   ||¡\}}| ||¡S rH   )rÕ   r{   rÔ   rK   rK   rL   r{   !  s    zMultipleTypeField.any2ic                 C   s   |   ||¡\}}| ||¡S rH   )rÕ   r†   rÔ   rK   rK   rL   r†   &  s    zMultipleTypeField.h2ic                 C   s   |   ||¡\}}| ||¡S rH   )rÕ   r‡   rÔ   rK   rK   rL   r‡   +  s    zMultipleTypeField.i2hc                 C   s   |   ||¡\}}| ||¡S rH   )rÕ   r‰   rÔ   rK   rK   rL   r‰   3  s    zMultipleTypeField.i2mc                 C   s   |   ||¡\}}| ||¡S rH   )rÕ   r‚   rÔ   rK   rK   rL   r‚   8  s    zMultipleTypeField.i2lenc                 C   s   |   ||¡\}}| ||¡S rH   )rÕ   rŒ   rÔ   rK   rK   rL   rŒ   =  s    zMultipleTypeField.i2reprc                 C   s.   | j D ]\}}|j |¡ q| jj |¡ d S rH   )rÊ   rt   ra   rË   )rJ   r}   r±   Ú_rK   rK   rL   r~   B  s    z MultipleTypeField.register_ownerc                 C   s   |   ¡ S rH   )rÜ   rO   rK   rK   rL   r±   H  s    zMultipleTypeField.fldN)rV   rW   rX   rY   rª   rM   rÒ   rÓ   rÕ   rÜ   r•   r‘   r{   r†   r‡   r‰   r‚   rŒ   r~   Úpropertyr±   rK   rK   rK   rL   rÉ      s$   	rÉ   c                   @   s:   e Zd ZdZg d¢Zddd„Zdd„ Zdd	„ Zd
d„ ZdS )ÚPadFieldzhAdd bytes after the proxified field so that it ends at the specified
       alignment from its beginning©r±   Ú_alignÚ_padwithNc                 C   s   || _ || _|pd| _d S ©Nó    rà   )rJ   r±   ÚalignZpadwithrK   rK   rL   rM   S  s    zPadField.__init__c                 C   s   | | j  S rH   )rá   )rJ   Zflenr€   rK   rK   rL   ÚpadlenY  s    zPadField.padlenc                 C   s:   | j  ||¡\}}|  t|ƒt|ƒ |¡}||d … |fS rH   )r±   r•   ræ   rS   )rJ   r€   r�   ÚremainrI   ræ   rK   rK   rL   r•   ]  s    zPadField.getfieldc                 C   s6   | j  |d|¡}|| t d|  t|ƒ|¡ | j¡ S ©NrG   ú%is©r±   r‘   ru   r�   ræ   rS   râ   ©rJ   r€   r�   rI   ZsvalrK   rK   rL   r‘   f  s    
ÿüzPadField.addfield)N)	rV   rW   rX   rY   rª   rM   ræ   r•   r‘   rK   rK   rK   rL   rß   N  s   
	rß   c                   @   s(   e Zd ZdZdd„ Zdd„ Zdd„ ZdS )	ÚReversePadFieldzkAdd bytes BEFORE the proxified field so that it starts at the specified
       alignment from its beginningc                 C   s
   t |jƒS rH   )rS   ÚoriginalrÅ   rK   rK   rL   Úoriginal_lengthy  s    zReversePadField.original_lengthc                 C   s0   |   |  |¡t|ƒ |¡}| j |||d … ¡S rH   )ræ   rî   rS   r±   r•   )rJ   r€   r�   ræ   rK   rK   rL   r•   }  s    zReversePadField.getfieldc                 C   s6   | j  |d|¡}|t d|  t|ƒ|¡ | j¡ | S rè   rê   rë   rK   rK   rL   r‘   †  s    ÿþþzReversePadField.addfieldN)rV   rW   rX   rY   rî   r•   r‘   rK   rK   rK   rL   rì   u  s   	rì   c                       s.   e Zd ZdZ‡ fdd„Zejr&dd„ Z‡  ZS )ÚTrailerByteszZ
    Reverses slice operations to take from the back of the packet,
    not the front
    c                    sˆ   t |tƒr.|dk rd| }qvt| ƒd | }nHt |tƒrv|j|j|j  }}}|rX| nd }|rf| nd }t|||ƒ}t| j| ƒ 	|¡S ©Nr   rƒ   )
rx   r¨   rS   ÚsliceÚstartÚstopÚstepr\   r`   Ú__getitem__)rJ   Úitemrò   ró   rô   Ú	new_startZnew_stopr_   rK   rL   rõ   ˜  s    


zTrailerBytes.__getitem__c                 C   s   |   t||ƒ¡S rH   )rõ   rñ   )rJ   rš   ÚjrK   rK   rL   Ú__getslice__§  s    zTrailerBytes.__getslice__)	rV   rW   rX   rY   rõ   ÚsixÚPY2rù   rl   rK   rK   r_   rL   rï   ’  s   rï   c                   @   s.   e Zd ZdZdgZdd„ Zdd„ Zdd„ Zd	S )
ÚTrailerFieldzSpecial Field that gets its value from the end of the *packet*
    (Note: not layer, but packet).

    Mostly used for FCS
    r±   c                 C   s
   || _ d S rH   r¶   r·   rK   rK   rL   rM   ´  s    zTrailerField.__init__c                    sD   |j ‰ ‡ fdd„}t||ƒ|_ t|ƒ}| j ||¡\}}t|ƒ|fS )Nc                    s   d | _ ˆ | _ˆ |ƒS rH   )Zraw_packet_cacheÚpost_dissect)rJ   r�   ©Zprevious_post_dissectrK   rL   Ú_post_dissectÀ  s    z,TrailerField.getfield.<locals>._post_dissect)rý   r   rï   r±   r•   Úbytes)rJ   r€   r�   rÿ   rI   rK   rþ   rL   r•   ¼  s    zTrailerField.getfieldc                    s4   |j ‰ | j |d|¡‰‡ ‡fdd„}t||ƒ|_ |S )NrG   c                    s   |ˆ7 }ˆ | _ ˆ ||ƒS rH   )Ú
post_build)rJ   ÚpZpay©Zprevious_post_buildrf   rK   rL   Ú_post_buildÐ  s    z*TrailerField.addfield.<locals>._post_build)r  r±   r‘   r   )rJ   r€   r�   rI   r  rK   r  rL   r‘   Ë  s
    zTrailerField.addfieldN)rV   rW   rX   rY   rª   rM   r•   r‘   rK   rK   rK   rL   rü   ¬  s
   rü   c                       s(   e Zd ZdZ‡ fdd„Zdd„ Z‡  ZS )ÚFCSFieldzP
    A FCS field that gets appended at the end of the *packet* (not layer).
    c                    s   t t| ƒ t|i |¤Ž¡ d S rH   )r\   r  rM   ro   )rJ   r]   Úkwargsr_   rK   rL   rM   Þ  s    zFCSField.__init__c                 C   s   t |  ||¡ƒS rH   ©r&   r‡   r   rK   rK   rL   rŒ   â  s    zFCSField.i2repr)rV   rW   rX   rY   rM   rŒ   rl   rK   rK   r_   rL   r  Ù  s   r  c                   @   s2   e Zd ZdgZi Zdd„ Zdd„ Zedd„ ƒZdS )	Ú	DestFieldÚ
defaultdstc                 C   s
   || _ d S rH   )r	  ©rJ   rp   rr   rK   rK   rL   rM   ì  s    zDestField.__init__c              	      s`   | j  ˆ jjg ¡D ]F\}}z*t‡ fdd„t |¡D ƒƒrB|W   S W q tyV   Y q0 q| jS )Nc                 3   s"   | ]\}}ˆ j  |¡|kV  qd S rH   )ÚpayloadZgetfieldval)rž   Úfieldrf   ©r€   rK   rL   rŸ   ô  s   ÿz)DestField.dst_from_pkt.<locals>.<genexpr>)	ÚbindingsÚgetr  r`   Úallrú   Ú	iteritemsÚAttributeErrorr	  )rJ   r€   ÚaddrÚ	conditionrK   r  rL   Údst_from_pktð  s    ÿzDestField.dst_from_pktc                 K   s   | j  |g ¡ ||f¡ d S rH   )r  Ú
setdefaultra   )r}   Úlayerr  r  rK   rK   rL   Ú	bind_addrû  s    ÿzDestField.bind_addrN)	rV   rW   rX   rª   r  rM   r  Úclassmethodr  rK   rK   rK   rL   r  ç  s   r  c                   @   s<   e Zd Zdd„ Zdd„ Zdd„ Zdd„ Zd	d
„ Zdd„ ZdS )ÚMACFieldc                 C   s   t  | ||d¡ d S )NZ6s©ro   rM   r
  rK   rK   rL   rM     s    zMACField.__init__c              	   C   s>   |d u rdS zt |ƒ}W n  tjtfy8   t|ƒ}Y n0 |S )Ns         )r'   ru   rŽ   ÚOverflowErrorr!   ©rJ   r€   r�   ÚyrK   rK   rL   r‰     s    zMACField.i2mc                 C   s   t |ƒS rH   )r(   r   rK   rK   rL   rˆ     s    zMACField.m2ic                 C   s,   t |tƒr"t|ƒdkr"|  ||¡S tt|ƒS )Né   )rx   r   rS   rˆ   rC   rN   r   rK   rK   rL   r{     s    zMACField.any2ic                 C   s6   |   ||¡}|d u rt|ƒS | tjv r2tj |¡}|S rH   )r‡   r‹   r   ÚresolveÚmanufdbZ_resolve_MACr   rK   rK   rL   rŒ     s    
zMACField.i2reprc                 C   s   t ƒ S rH   )r   rO   rK   rK   rL   r©   %  s    zMACField.randvalN©	rV   rW   rX   rM   r‰   rˆ   r{   rŒ   r©   rK   rK   rK   rL   r    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 )ÚIPFieldc                 C   s   t  | ||d¡ d S )NZ4sr  r
  rK   rK   rL   rM   +  s    zIPField.__init__c                    sj   t |tƒrt|ƒ}t |tƒrHzt|ƒ W qf tjyD   t|ƒ Y S 0 nt |tƒrf‡ ‡fdd„|D ƒS |S )Nc                    s   g | ]}ˆ  ˆ |¡‘qS rK   rŠ   ©rž   Ún©r€   rJ   rK   rL   Ú
<listcomp>9  rG   zIPField.h2i.<locals>.<listcomp>)	rx   r   r   rN   r$   ÚsocketrŽ   r1   r—   r   rK   r&  rL   r†   /  s    


zIPField.h2ic                 C   s
   t t|ƒS rH   ©rC   rN   r   rK   rK   rL   r‡   <  s    zIPField.i2hc                 C   s<   | t jv r8zt |¡d }W n ty.   Y n
0 |r8|S |S ©Nr   )r   r   r(  ÚgethostbyaddrÚ	Exception)rJ   r�   ÚretrK   rK   rL   r   @  s    
zIPField.resolvec                 C   s   |d u rdS t t|ƒƒS )Ns       )r$   r   r   rK   rK   rL   r‰   L  s    zIPField.i2mc                 C   s   t |ƒS rH   )r%   r   rK   rK   rL   rˆ   R  s    zIPField.m2ic                 C   s   |   ||¡S rH   rŠ   r   rK   rK   rL   r{   V  s    zIPField.any2ic                 C   s(   |   |  ||¡¡}t|tƒr |S t|ƒS rH   )r   r‡   rx   rN   r‹   )rJ   r€   r�   ÚrrK   rK   rL   rŒ   Z  s    zIPField.i2reprc                 C   s   t ƒ S rH   )r   rO   rK   rK   rL   r©   _  s    zIPField.randvalN)rV   rW   rX   rM   r†   r‡   r   r‰   rˆ   r{   rŒ   r©   rK   rK   rK   rL   r#  *  s   r#  c                       s>   e Zd ZdgZdd„ Zdd„ Z‡ fdd„Z‡ fdd	„Z‡  ZS )
ÚSourceIPFieldÚdstnamec                 C   s   t  | |d ¡ || _d S rH   )r#  rM   r0  ©rJ   rp   r0  rK   rK   rL   rM   g  s    zSourceIPField.__init__c                 C   s‚   t jd u rdd l}| jd u r dnt|| jƒp.d}t|ttfƒrrdd„ |D ƒ}t|ƒdkrft	d|f ƒ t
|ƒd S t j |¡d S )Nr   z0.0.0.0c                 S   s   h | ]}t j t|ƒ¡’qS rK   )r   ÚrouterN   ©rž   ZdaddrrK   rK   rL   Ú	<setcomp>t  s   ÿz+SourceIPField.__findaddr.<locals>.<setcomp>rƒ   ú#More than one possible route for %r)r   r2  Zscapy.router0  r°   rx   r0   r—   rS   r4   Úmin)rJ   r€   ÚscapyÚdstr.  rK   rK   rL   Z
__findaddrl  s    
ÿþzSourceIPField.__findaddrc                    s,   |d u r|d ur|   |¡}tt| ƒ ||¡S rH   )Ú_SourceIPField__findaddrr\   r/  r‰   r   r_   rK   rL   r‰   }  s    
zSourceIPField.i2mc                    s,   |d u r|d ur|   |¡}tt| ƒ ||¡S rH   )r9  r\   r/  r‡   r   r_   rK   rL   r‡   ƒ  s    
zSourceIPField.i2h)	rV   rW   rX   rª   rM   r9  r‰   r‡   rl   rK   rK   r_   rL   r/  d  s
   r/  c                   @   sL   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S )ÚIP6Fieldc                 C   s   t  | ||d¡ d S ©NÚ16sr  r
  rK   rK   rL   rM   ‹  s    zIP6Field.__init__c                    sj   t |tƒrt|ƒ}t |tƒrHzt|ƒ}W qf tjyD   t|ƒ Y S 0 nt |tƒrf‡ ‡fdd„|D ƒ}|S )Nc                    s   g | ]}ˆ  ˆ |¡‘qS rK   rŠ   r$  r&  rK   rL   r'  ™  rG   z IP6Field.h2i.<locals>.<listcomp>)	rx   r   r   rN   r-   r(  rŽ   r.   r—   r   rK   r&  rL   r†   �  s    


zIP6Field.h2ic                 C   s
   t t|ƒS rH   r)  r   rK   rK   rL   r‡   œ  s    zIP6Field.i2hc                 C   s   |d u rd}t tjt|ƒƒS ©Nú::)r#   r(  ÚAF_INET6r   r   rK   rK   rL   r‰      s    zIP6Field.i2mc                 C   s   t tj|ƒS rH   ©r"   r(  r?  r   rK   rK   rL   rˆ   ¦  s    zIP6Field.m2ic                 C   s   |   ||¡S rH   rŠ   r   rK   rK   rL   r{   ª  s    zIP6Field.any2ic           	      C   sž   |d u r|   ||¡S t|tƒs|t|tƒs|t|ƒrXt|ƒ\}}}}d|   ||¡|||f S t|ƒr|t|ƒ}d|   ||¡|f S |   ||¡}t|tƒr–|S t	|ƒS )Nz%s [Teredo srv: %s cli: %s:%s]z%s [6to4 GW: %s])
r‡   rx   r.   r—   r,   r/   r+   r*   rN   r‹   )	rJ   r€   r�   ÚserverrÝ   ZmaddrZmportZvaddrr.  rK   rK   rL   rŒ   ®  s    zIP6Field.i2reprc                 C   s   t ƒ S rH   )r   rO   rK   rK   rL   r©   ¼  s    zIP6Field.randvalN)rV   rW   rX   rM   r†   r‡   r‰   rˆ   r{   rŒ   r©   rK   rK   rK   rL   r:  Š  s   r:  c                       s6   e Zd ZdgZdd„ Z‡ fdd„Z‡ fdd„Z‡  ZS )ÚSourceIP6Fieldr0  c                 C   s   t  | |d ¡ || _d S rH   )r:  rM   r0  r1  rK   rK   rL   rM   Ä  s    zSourceIP6Field.__init__c                    sJ   |d u r8| j d u rdnt|| j ƒp$d}tj |¡\}}}tt| ƒ ||¡S r=  )r0  r°   r   Úroute6r2  r\   rB  r‰   )rJ   r€   r�   r8  ZiffZnhr_   rK   rL   r‰   É  s    ÿzSourceIP6Field.i2mc                    sš   |d u rˆt jd u rdd l}| jd u r(dn
t|| jƒ}t|ttfƒrxdd„ |D ƒ}t|ƒdkrjt	d|f ƒ t
|ƒd }nt j |¡d }tt| ƒ ||¡S )Nr   r>  c                 S   s   h | ]}t j t|ƒ¡’qS rK   )r   rC  r2  rN   r3  rK   rK   rL   r4  Ù  s   ÿz%SourceIP6Field.i2h.<locals>.<setcomp>rƒ   r5  )r   rC  Zscapy.route6r0  r°   rx   r0   r—   rS   r4   r6  r2  r\   rB  r‡   )rJ   r€   r�   r7  r8  r.  r_   rK   rL   r‡   Ñ  s    
ÿzSourceIP6Field.i2h)rV   rW   rX   rª   rM   r‰   r‡   rl   rK   rK   r_   rL   rB  Á  s   rB  c                       s0   e Zd Zi Zdd„ Zdd„ Z‡ fdd„Z‡  ZS )ÚDestIP6Fieldc                 C   s    t  | |d ¡ t | ||¡ d S rH   )r:  rM   r  r
  rK   rK   rL   rM   æ  s    zDestIP6Field.__init__c                 C   s(   |d u r|d ur|   |¡}t | ||¡S rH   )r  r:  r‰   r   rK   rK   rL   r‰   ë  s    
zDestIP6Field.i2mc                    s,   |d u r|d ur|   |¡}tt| ƒ ||¡S rH   )r  r\   rD  r‡   r   r_   rK   rL   r‡   ñ  s    
zDestIP6Field.i2h)rV   rW   rX   r  rM   r‰   r‡   rl   rK   rK   r_   rL   rD  ã  s   rD  c                   @   s   e Zd Zdd„ ZdS )Ú	ByteFieldc                 C   s   t  | ||d¡ d S ©Nr¢   r  r
  rK   rK   rL   rM   ù  s    zByteField.__init__N©rV   rW   rX   rM   rK   rK   rK   rL   rE  ø  s   rE  c                   @   s   e Zd Zdd„ ZdS )Ú
XByteFieldc                 C   s   t |  ||¡ƒS rH   r  r   rK   rK   rL   rŒ   ÿ  s    zXByteField.i2reprN©rV   rW   rX   rŒ   rK   rK   rK   rL   rH  þ  s   rH  c                   @   s   e Zd Zdd„ ZdS )Ú
OByteFieldc                 C   s   d|   ||¡ S )Nz%03o)r‡   r   rK   rK   rL   rŒ     s    zOByteField.i2reprNrI  rK   rK   rK   rL   rJ    s   rJ  c                   @   s$   e Zd Zdd„ Zdd„ Zdd„ ZdS )ÚThreeBytesFieldc                 C   s   t  | ||d¡ d S )Nú!Ir  r
  rK   rK   rL   rM     s    zThreeBytesField.__init__c                 C   s"   |t  | j|  ||¡¡dd…  S )Nrƒ   é   ©ru   r�   rq   r‰   rÈ   rK   rK   rL   r‘     s    zThreeBytesField.addfieldc                 C   s2   |dd … |   |t | jd|d d…  ¡d ¡fS ©Né   rä   r   ©rˆ   ru   r“   rq   r”   rK   rK   rL   r•     s    zThreeBytesField.getfieldN©rV   rW   rX   rM   r‘   r•   rK   rK   rK   rL   rK    s   rK  c                   @   s   e Zd Zdd„ ZdS )ÚX3BytesFieldc                 C   s   t  | ||¡S rH   ©rH  rŒ   r   rK   rK   rL   rŒ     s    zX3BytesField.i2reprNrI  rK   rK   rK   rL   rS    s   rS  c                   @   s$   e Zd Zdd„ Zdd„ Zdd„ ZdS )ÚLEThreeBytesFieldc                 C   s   t  | ||d¡ d S ©Nz<Ir  r
  rK   rK   rL   rM      s    zLEThreeBytesField.__init__c                 C   s"   |t  | j|  ||¡¡d d…  S )NrP  rN  rÈ   rK   rK   rL   r‘   $  s    zLEThreeBytesField.addfieldc              
   C   s2   |dd … |   |t | j|d d… d ¡d ¡fS rO  rQ  r”   rK   rK   rL   r•   (  s    zLEThreeBytesField.getfieldNrR  rK   rK   rK   rL   rU    s   rU  c                   @   s   e Zd Zdd„ ZdS )ÚLEX3BytesFieldc                 C   s   t  | ||¡S rH   rT  r   rK   rK   rL   rŒ   .  s    zLEX3BytesField.i2reprNrI  rK   rK   rK   rL   rW  -  s   rW  c                       sD   e Zd Zdd„ Zdd„ Zdd„ Z‡ fdd„Zd	d
„ Zdd„ Z‡  Z	S )ÚNBytesFieldc                 C   s   t  | ||dd|  ¡ d S )Nú<r¢   r  )rJ   rp   rr   rs   rK   rK   rL   rM   4  s    zNBytesField.__init__c                 C   sN   |d u rdg| j  S tƒ }t| j ƒD ]}| |d ¡ |d }q$|d d d… S )Nr   é   r¡   )rs   r—   r˜   ra   )rJ   r€   r�   Zx2mrÝ   rK   rK   rL   r‰   8  s    
zNBytesField.i2mc                 C   s6   t |tƒr|S t |ttfƒr2tdd„ t|ƒD ƒƒS dS )Nc                 s   s   | ]\}}|d |  V  qdS )rZ  NrK   )rž   rš   ÚdrK   rK   rL   rŸ   H  rG   z"NBytesField.m2i.<locals>.<genexpr>r   )rx   r¨   r—   rÑ   ÚsumÚ	enumerater   rK   rK   rL   rˆ   B  s
    
zNBytesField.m2ic                    s$   t |tƒrd| S tt| ƒ ||¡S )Nz%i)rx   r5   r\   rX  rŒ   r   r_   rK   rL   rŒ   K  s    
zNBytesField.i2reprc                 C   s   || j j|  ||¡Ž  S rH   )ru   r�   r‰   rÈ   rK   rK   rL   r‘   Q  s    zNBytesField.addfieldc              	   C   s,   || j d … |  || j |d | j … ¡¡fS rH   r’   r”   rK   rK   rL   r•   U  s    ÿzNBytesField.getfield)
rV   rW   rX   rM   r‰   rˆ   rŒ   r‘   r•   rl   rK   rK   r_   rL   rX  3  s   
	rX  c                       s   e Zd Z‡ fdd„Z‡  ZS )ÚXNBytesFieldc                    sJ   t |tƒrd| S t |ttfƒr8dd dd„ |D ƒ¡ S tt| ƒ ||¡S )Nú0x%xÚ0xÚ c                 s   s   | ]}d | V  qdS )z%02xNrK   ©rž   r£   rK   rK   rL   rŸ   b  rG   z&XNBytesField.i2repr.<locals>.<genexpr>)rx   r5   r—   rÑ   r    r\   r^  rŒ   r   r_   rK   rL   rŒ   \  s
    
zXNBytesField.i2repr©rV   rW   rX   rŒ   rl   rK   rK   r_   rL   r^  [  s   r^  c                   @   s   e Zd Zdd„ ZdS )ÚSignedByteFieldc                 C   s   t  | ||d¡ d S )Nr£   r  r
  rK   rK   rL   rM   g  s    zSignedByteField.__init__NrG  rK   rK   rK   rL   rd  f  s   rd  c                   @   s   e Zd ZdS )ÚFieldValueRangeExceptionN©rV   rW   rX   rK   rK   rK   rL   re  l  s   re  c                   @   s   e Zd ZdS )ÚFieldAttributeExceptionNrf  rK   rK   rK   rL   rg  p  s   rg  c                   @   s0   e Zd ZdZdgZdd„ Zd
dd„Zdd	„ ZdS )ÚYesNoByteFielda–  
    A byte based flag field that shows representation of its number
    based on a given association

    In its default configuration the following representation is generated:
        x == 0 : 'no'
        x != 0 : 'yes'

    In more sophisticated use-cases (e.g. yes/no/invalid) one can use the
    config attribute to configure.
    Key-value, key-range and key-value-set associations that will be used to
    generate the values representation.

    - A range is given by a tuple (<first-val>, <last-value>) including the
      last value.
    - A single-value tuple is treated as scalar.
    - A list defines a set of (probably non consecutive) values that should be
      associated to a given key.

    All values not associated with a key will be shown as number of type
    unsigned byte.

    **For instance**::

        config = {
            'no' : 0,
            'foo' : (1,22),
            'yes' : 23,
            'bar' : [24,25, 42, 48, 87, 253]
        }

    Generates the following representations::

        x == 0 : 'no'
        x == 15: 'foo'
        x == 23: 'yes'
        x == 42: 'bar'
        x == 43: 43

    Another example, using the config attribute one could also revert
    the stock-yes-no-behavior::

        config = {
                'yes' : 0,
                'no' : (1,255)
        }

    Will generate the following value representation::

        x == 0 : 'yes'
        x != 0 : 'no'

    Úeval_fnc           	         s2  t ƒ ‰ |D �]}|| }t|ƒ}|tu rP|dk s8|dkrFtd |¡ƒ‚|ˆ |< q
|tu rŠ|D ]*}|dk sp|dkr~td |¡ƒ‚|ˆ |< q\q
|tu r
t|ƒ}|dkr²td ||¡ƒ‚|d }|dk sÊ|dkrØtd |¡ƒ‚|d }|dk sò|dk�r td |¡ƒ‚t	||d ƒD ]}|ˆ |< �qq
‡ fdd„| _
d S )	Nr   éÿ   z8given field value {} invalid - must be in range [0..255]é   zWinvalid length {} of given config item tuple {} - must be (<start-range>, <end-range>).rƒ   c                    s   | ˆ v rˆ |  S | S rH   rK   ©r�   ©Zassoc_tablerK   rL   Ú<lambda>Õ  rG   z=YesNoByteField._build_config_representation.<locals>.<lambda>)ÚdictrÇ   r¨   re  Úformatr—   rÑ   rS   rg  r˜   ri  )	rJ   Úconfigre   Z
value_specZvalue_spec_typerf   Zvalue_spec_lenZvalue_range_startZvalue_range_endrK   rm  rL   Ú_build_config_representation¬  sH    
ÿ
ÿÿÿÿz+YesNoByteField._build_config_representationNc                 C   s,   |sdd„ | _ n
|  |¡ t | ||¡ d S )Nc                 S   s   | dkrdS dS )Nr   ÚnoÚyesrK   rl  rK   rK   rL   rn  Ü  rG   z)YesNoByteField.__init__.<locals>.<lambda>)ri  rr  rE  rM   )rJ   rp   rr   rq  rK   rK   rL   rM   ×  s    
zYesNoByteField.__init__c                 C   s
   |   |¡S rH   )ri  r   rK   rK   rL   rŒ   á  s    zYesNoByteField.i2repr)N)rV   rW   rX   rY   rª   rr  rM   rŒ   rK   rK   rK   rL   rh  t  s
   5+

rh  c                   @   s   e Zd Zdd„ ZdS )Ú
ShortFieldc                 C   s   t  | ||d¡ d S ©Nrv   r  r
  rK   rK   rL   rM   ç  s    zShortField.__init__NrG  rK   rK   rK   rL   ru  æ  s   ru  c                   @   s   e Zd Zdd„ ZdS )ÚSignedShortFieldc                 C   s   t  | ||d¡ d S )Nr¤   r  r
  rK   rK   rL   rM   í  s    zSignedShortField.__init__NrG  rK   rK   rK   rL   rw  ì  s   rw  c                   @   s   e Zd Zdd„ ZdS )ÚLEShortFieldc                 C   s   t  | ||d¡ d S ©Nú<Hr  r
  rK   rK   rL   rM   ó  s    zLEShortField.__init__NrG  rK   rK   rK   rL   rx  ò  s   rx  c                   @   s   e Zd Zdd„ ZdS )ÚLESignedShortFieldc                 C   s   t  | ||d¡ d S )Nz<hr  r
  rK   rK   rL   rM   ù  s    zLESignedShortField.__init__NrG  rK   rK   rK   rL   r{  ø  s   r{  c                   @   s   e Zd Zdd„ ZdS )ÚXShortFieldc                 C   s   t |  ||¡ƒS rH   r  r   rK   rK   rL   rŒ   ÿ  s    zXShortField.i2reprNrI  rK   rK   rK   rL   r|  þ  s   r|  c                   @   s   e Zd Zdd„ ZdS )ÚIntFieldc                 C   s   t  | ||d¡ d S ©Nrm   r  r
  rK   rK   rL   rM     s    zIntField.__init__NrG  rK   rK   rK   rL   r}    s   r}  c                   @   s   e Zd Zdd„ ZdS )ÚSignedIntFieldc                 C   s   t  | ||d¡ d S ©Nrš   r  r
  rK   rK   rL   rM     s    zSignedIntField.__init__NrG  rK   rK   rK   rL   r  
  s   r  c                   @   s   e Zd Zdd„ ZdS )Ú
LEIntFieldc                 C   s   t  | ||d¡ d S rV  r  r
  rK   rK   rL   rM     s    zLEIntField.__init__NrG  rK   rK   rK   rL   r�    s   r�  c                   @   s   e Zd Zdd„ ZdS )ÚLESignedIntFieldc                 C   s   t  | ||d¡ d S )Nz<ir  r
  rK   rK   rL   rM     s    zLESignedIntField.__init__NrG  rK   rK   rK   rL   r‚    s   r‚  c                   @   s   e Zd Zdd„ ZdS )Ú	XIntFieldc                 C   s   t |  ||¡ƒS rH   r  r   rK   rK   rL   rŒ     s    zXIntField.i2reprNrI  rK   rK   rK   rL   rƒ    s   rƒ  c                   @   s   e Zd Zdd„ ZdS )ÚXLEIntFieldc                 C   s   t  | ||¡S rH   )rƒ  rŒ   r   rK   rK   rL   rŒ   #  s    zXLEIntField.i2reprNrI  rK   rK   rK   rL   r„  "  s   r„  c                   @   s   e Zd Zdd„ ZdS )ÚXLEShortFieldc                 C   s   t  | ||¡S rH   )r|  rŒ   r   rK   rK   rL   rŒ   )  s    zXLEShortField.i2reprNrI  rK   rK   rK   rL   r…  (  s   r…  c                   @   s   e Zd Zdd„ ZdS )Ú	LongFieldc                 C   s   t  | ||d¡ d S )Nr¥   r  r
  rK   rK   rL   rM   /  s    zLongField.__init__NrG  rK   rK   rK   rL   r†  .  s   r†  c                   @   s   e Zd Zdd„ ZdS )ÚSignedLongFieldc                 C   s   t  | ||d¡ d S )Nr¦   r  r
  rK   rK   rL   rM   5  s    zSignedLongField.__init__NrG  rK   rK   rK   rL   r‡  4  s   r‡  c                   @   s   e Zd Zdd„ ZdS )ÚLELongFieldc                 C   s   t  | ||d¡ d S ©Nz<Qr  r
  rK   rK   rL   rM   ;  s    zLELongField.__init__NrG  rK   rK   rK   rL   rˆ  :  s   rˆ  c                   @   s   e Zd Zdd„ ZdS )ÚLESignedLongFieldc                 C   s   t  | ||d¡ d S )Nz<qr  r
  rK   rK   rL   rM   A  s    zLESignedLongField.__init__NrG  rK   rK   rK   rL   rŠ  @  s   rŠ  c                   @   s   e Zd Zdd„ ZdS )Ú
XLongFieldc                 C   s   t |  ||¡ƒS rH   r  r   rK   rK   rL   rŒ   G  s    zXLongField.i2reprNrI  rK   rK   rK   rL   r‹  F  s   r‹  c                   @   s   e Zd Zdd„ ZdS )ÚXLELongFieldc                 C   s   t  | ||¡S rH   )r‹  rŒ   r   rK   rK   rL   rŒ   M  s    zXLELongField.i2reprNrI  rK   rK   rK   rL   rŒ  L  s   rŒ  c                   @   s   e Zd Zdd„ ZdS )ÚIEEEFloatFieldc                 C   s   t  | ||d¡ d S )NÚfr  r
  rK   rK   rL   rM   S  s    zIEEEFloatField.__init__NrG  rK   rK   rK   rL   r�  R  s   r�  c                   @   s   e Zd Zdd„ ZdS )ÚIEEEDoubleFieldc                 C   s   t  | ||d¡ d S )Nr[  r  r
  rK   rK   rL   rM   Y  s    zIEEEDoubleField.__init__NrG  rK   rK   rK   rL   r�  X  s   r�  c                       s`   e Zd ZdgZddd„Zdd„ Z‡ fdd	„Z‡ fd
d„Zdd„ Zdd„ Z	dd„ Z
dd„ Z‡  ZS )Ú	_StrFieldrç   rv   r   c                 C   s   t  | |||¡ || _d S rH   )ro   rM   rç   )rJ   rp   rr   rq   rç   rK   rK   rL   rM   a  s    z_StrField.__init__c                 C   s   |d u rdS t |ƒS r*  )rS   r   rK   rK   rL   r‚   f  s    z_StrField.i2lenc                    s&   t |tjƒrt|ƒ}tt| ƒ ||¡S rH   )rx   rú   Ú	text_typer!   r\   r�  r{   r   r_   rK   rL   r{   l  s    z_StrField.any2ic                    s(   t |tƒrtt|ƒƒS tt| ƒ ||¡S rH   )rx   r   r‹   r   r\   r�  rŒ   r   r_   rK   rL   rŒ   r  s    
z_StrField.i2reprc                 C   s"   |d u rdS t |tƒst|ƒS |S ©NrG   )rx   r   r!   r   rK   rK   rL   r‰   x  s
    
z_StrField.i2mc                 C   s   ||   ||¡ S rH   ©r‰   rÈ   rK   rK   rL   r‘   €  s    z_StrField.addfieldc                 C   sF   | j dkrd|  ||¡fS || j  d … |  ||d | j  … ¡fS d S ©Nr   rG   )rç   rˆ   r”   rK   rK   rL   r•   „  s    
z_StrField.getfieldc                 C   s   t tddƒƒS ©Nr   i°  )r   r   rO   rK   rK   rL   r©   ‹  s    z_StrField.randval)rv   r   )rV   rW   rX   rª   rM   r‚   r{   rŒ   r‰   r‘   r•   r©   rl   rK   rK   r_   rL   r�  ^  s   
r�  c                   @   s   e Zd ZdS )ÚStrFieldNrf  rK   rK   rK   rL   r–  �  s   r–  c                       s4   e Zd Zdd„ Z‡ fdd„Zdd„ Zdd„ Z‡  ZS )	ÚStrFieldUtf16c                 C   s   t |ƒ d¡dd … S )Núutf-16rk  )r   Úencoder   rK   rK   rL   r†   •  s    zStrFieldUtf16.h2ic                    s*   t |tjƒr|  ||¡S tt| ƒ ||¡S rH   )rx   rú   r‘  r†   r\   r—  r{   r   r_   rK   rL   r{   ™  s    zStrFieldUtf16.any2ic                 C   s   t |  ||¡ƒS rH   )r   r‡   r   rK   rK   rL   rŒ   Ÿ  s    zStrFieldUtf16.i2reprc                 C   s   t |ƒjddd�S )Nr˜  Úreplace)Úerrors)r!   Údecoder   rK   rK   rL   r‡   £  s    zStrFieldUtf16.i2h)rV   rW   rX   r†   r{   rŒ   r‡   rl   rK   rK   r_   rL   r—  ”  s   r—  c                   @   s   e Zd Zdd„ Zdd„ ZdS )Ú_StrEnumFieldc                 K   s   |  di ¡| _d S )NÚenum)Úpoprž  )rJ   r  rK   rK   rL   rM   ©  s    z_StrEnumField.__init__c                 C   sV   |  d¡}t|ƒ}| jrR|| jv r6d|| j| f }n|| jv rRd|| j| f }|S )Nrä   ú%s (%s))Úrstripr‹   rž  )rJ   r€   Úvr.  ÚrrrK   rK   rL   rŒ   ­  s    


z_StrEnumField.i2reprN)rV   rW   rX   rM   rŒ   rK   rK   rK   rL   r�  ¨  s   r�  c                   @   s   e Zd ZdgZddd„ZdS )ÚStrEnumFieldrž  Nc                 K   s    t j| ||fi |¤Ž || _d S rH   )r–  rM   rž  )rJ   rp   rr   rž  r  rK   rK   rL   rM   ¼  s    zStrEnumField.__init__)N©rV   rW   rX   rª   rM   rK   rK   rK   rL   r¤  ¹  s    ür¤  ÚKc                       sF   e Zd ZdgZdZ‡ fdd„Zdd„ Zdd„ Zd	d
„ Zdd„ Z	‡  Z
S )Ú_PacketFieldr}   rƒ   c                    s   t t| ƒ ||¡ || _d S rH   )r\   r§  rM   r}   )rJ   rp   rr   Úpkt_clsr_   rK   rL   rM   Ï  s    z_PacketField.__init__c                 C   s   |d u rdS t |ƒS r’  )r    ©rJ   r€   rš   rK   rK   rL   r‰   Ø  s    z_PacketField.i2mc                 C   s2   z| j ||d�W S  ty,   |   |¡ Y S 0 d S )N©Ú_parent)r}   Ú	TypeError)rJ   r€   ÚmrK   rK   rL   rˆ   á  s    z_PacketField.m2ic                 C   s8   |   ||¡}d}tj|v r0|tj }|j`|j}||fS r’  )rˆ   r   Úpadding_layerÚ
underlayerr  Úload)rJ   r€   r�   rš   rç   r.  rK   rK   rL   r•   é  s    

z_PacketField.getfieldc                 C   s   ddl m} ||  ¡ ƒS )Nr   )Úfuzz)Úscapy.packetr±  r}   )rJ   r±  rK   rK   rL   r©   ö  s    z_PacketField.randval)rV   rW   rX   rª   r­   rM   r‰   rˆ   r•   r©   rl   rK   rK   r_   rL   r§  Ë  s   		r§  c                       s   e Zd Z‡ fdd„Z‡  ZS )ÚPacketFieldc                    s4   |r"|r"t |dƒr"td|ƒ |¡ tt| ƒ ||¡S )NÚ
add_parentrE   )r™   rC   r´  r\   r³  r{   r   r_   rK   rL   r{   ý  s    zPacketField.any2i)rV   rW   rX   r{   rl   rK   rK   r_   rL   r³  ü  s   r³  c                       s,   e Zd ZdgZd‡ fdd„	Zdd„ Z‡  ZS )ÚPacketLenFieldÚlength_fromNc                    s&   t t| ƒ |||¡ |pdd„ | _d S )Nc                 S   s   dS r*  rK   rl  rK   rK   rL   rn    rG   z)PacketLenField.__init__.<locals>.<lambda>)r\   rµ  rM   r¶  )rJ   rp   rr   r}   r¶  r_   rK   rL   rM     s    zPacketLenField.__init__c                 C   sj   |   |¡}d }|rZz|  ||d |… ¡}W n. tyX   tjr@‚ tj|d |… d�}Y n0 ||d … |fS )N©r°  )r¶  rˆ   r,  r   Údebug_dissectorÚ	raw_layer)rJ   r€   r�   Úlen_pktrš   rK   rK   rL   r•     s    
zPacketLenField.getfield)N)rV   rW   rX   rª   rM   r•   rl   rK   rK   r_   rL   rµ    s    ü
rµ  c                       s^   e Zd ZdZg d¢ZdZd‡ fdd„	Zdd„ Zd	d
„ Zdd„ Z	dd„ Z
dd„ Zdd„ Z‡  ZS )ÚPacketListFielda˜  PacketListField represents a list containing a series of Packet instances
    that might occur right in the middle of another Packet field.
    This field type may also be used to indicate that a series of Packet
    instances have a sibling semantic instead of a parent/child relationship
    (i.e. a stack of layers). All elements in PacketListField have current
    packet referenced in parent field.
    )Ú
count_fromr¶  Únext_cls_cbrƒ   Nc                    s6   |du rg }t t| ƒ |||¡ || _|| _|| _dS )aˆ  
        The number of Packet instances that are dissected by this field can
        be parametrized using one of three different mechanisms/parameters:

            * count_from: a callback that returns the number of Packet
              instances to dissect. The callback prototype is::

                count_from(pkt:Packet) -> int

            * length_from: a callback that returns the number of bytes that
              must be dissected by this field. The callback prototype is::

                length_from(pkt:Packet) -> int

            * next_cls_cb: a callback that enables a Scapy developer to
              dynamically discover if another Packet instance should be
              dissected or not. See below for this callback prototype.

        The bytes that are not consumed during the dissection of this field
        are passed to the next field of the current packet.

        For the serialization of such a field, the list of Packets that are
        contained in a PacketListField can be heterogeneous and is
        unrestricted.

        The type of the Packet instances that are dissected with this field is
        specified or discovered using one of the following mechanism:

            * the pkt_cls parameter may contain a callable that returns an
              instance of the dissected Packet. This may either be a
              reference of a Packet subclass (e.g. DNSRROPT in layers/dns.py)
              to generate an homogeneous PacketListField or a function
              deciding the type of the Packet instance
              (e.g. _CDPGuessAddrRecord in contrib/cdp.py)

            * the pkt_cls parameter may contain a class object with a defined
              ``dispatch_hook`` classmethod. That method must return a Packet
              instance. The ``dispatch_hook`` callmethod must implement the
                following prototype::

                dispatch_hook(cls,
                              _pkt:Optional[Packet],
                              *args, **kargs
                ) -> Type[Packet]

                The _pkt parameter may contain a reference to the packet
                instance containing the PacketListField that is being
                dissected.

            * the ``next_cls_cb`` parameter may contain a callable whose
              prototype is::

                cbk(pkt:Packet,
                    lst:List[Packet],
                    cur:Optional[Packet],
                    remain:str
                ) -> Optional[Type[Packet]]

              The pkt argument contains a reference to the Packet instance
              containing the PacketListField that is being dissected.
              The lst argument is the list of all Packet instances that were
              previously parsed during the current ``PacketListField``
              dissection, saved for the very last Packet instance.
              The cur argument contains a reference to that very last parsed
              ``Packet`` instance. The remain argument contains the bytes
              that may still be consumed by the current PacketListField
              dissection operation.

              This callback returns either the type of the next Packet to
              dissect or None to indicate that no more Packet are to be
              dissected.

              These four arguments allows a variety of dynamic discovery of
              the number of Packet to dissect and of the type of each one of
              these Packets, including: type determination based on current
              Packet instances or its underlayers, continuation based on the
              previously parsed Packet instances within that PacketListField,
              continuation based on a look-ahead on the bytes to be
              dissected...

        The pkt_cls and next_cls_cb parameters are semantically exclusive,
        although one could specify both. If both are specified, pkt_cls is
        silently ignored. The same is true for count_from and next_cls_cb.

        length_from and next_cls_cb are compatible and the dissection will
        end, whichever of the two stop conditions comes first.

        :param name: the name of the field
        :param default: the default value of this field; generally an empty
            Python list
        :param pkt_cls: either a callable returning a Packet instance or a
            class object defining a ``dispatch_hook`` class method
        :param count_from: a callback returning the number of Packet
            instances to dissect.
        :param length_from: a callback returning the number of bytes to dissect
        :param next_cls_cb: a callback returning either None or the type of
            the next Packet to dissect.
        N)r\   r»  rM   r¼  r¶  r½  )rJ   rp   rr   r¨  r¼  r¶  r½  r_   rK   rL   rM   -  s    l
ýzPacketListField.__init__c                 C   sX   t |tƒs,|r&|r&t|dƒr&| |¡ |gS |rT|D ]}|r4t|dƒsHq4| |¡ q4|S )Nr´  )rx   r—   r™   r´  )rJ   r€   r�   rš   rK   rK   rL   r{   ¤  s    

zPacketListField.any2ic                 C   s   t |tƒrt|ƒS dS ©Nrƒ   ©rx   r—   rS   rÂ   rK   rK   rL   r„   ±  s    
zPacketListField.i2countc                    s   t ‡ ‡fdd„|D ƒƒS )Nc                 3   s   | ]}t ˆ ˆ |¡ƒV  qd S rH   )rS   r‰   )rž   r  r&  rK   rL   rŸ   ¿  rG   z(PacketListField.i2len.<locals>.<genexpr>)r\  rÂ   rK   r&  rL   r‚   º  s    zPacketListField.i2lenc                 C   s¦  d  } }}| j d ur"|   |¡}n| jd ur6|  |¡}| jd ur`|  |g d |¡}d}|d u r`d}g }d}|}|d urŽ|d |… ||d …  }}|�rš|d ur°|dkr¨�qš|d8 }zF|d urèz|||d�}	W qô tyä   ||ƒ}	Y qô0 n|  ||¡}	W n. t�y$   tj�r‚ tj|d�}	d}Y nj0 tj	|	v �rŠ|	tj	 }
|
j
}|
j`| jd u�rŽ|  |||	|¡}|d u�rŽ|d u �r|dn|}|d7 }nd}| |	¡ qŽ|| |fS )Nrƒ   r   rG   rª  r·  )r¶  r¼  r½  r¬  rˆ   r,  r   r¸  r¹  r®  r°  r¯  r  ra   )rJ   r€   r�   Úcrº  r}   Úlstr-  rç   r  ÚpadrK   rK   rL   r•   Á  sX    







zPacketListField.getfieldc                 C   s   t |ƒS rH   )r!   r©  rK   rK   rL   r‰   õ  s    zPacketListField.i2mc                    s   |d  ‡ ‡fdd„|D ƒ¡ S )NrG   c                 3   s   | ]}ˆ  ˆ |¡V  qd S rH   r“  ©rž   r¢  r&  rK   rL   rŸ   þ  rG   z+PacketListField.addfield.<locals>.<genexpr>©r    rÈ   rK   r&  rL   r‘   ü  s    zPacketListField.addfield)NNNN)rV   rW   rX   rY   rª   r«   rM   r{   r„   r‚   r•   r‰   r‘   rl   rK   rK   r_   rL   r»  "  s       ùw	4r»  c                       sH   e Zd ZdgZd‡ fdd„	Z‡ fdd„Zdd„ Zd	d
„ Zdd„ Z‡  Z	S )ÚStrFixedLenFieldr¶  Nc                    s@   t t| ƒ ||¡ |pdd„ | _|d ur<|| _|fdd„| _d S )Nc                 S   s   dS r*  rK   rl  rK   rK   rL   rn    rG   z+StrFixedLenField.__init__.<locals>.<lambda>c                 S   s   |S rH   rK   )r�   ÚlengthrK   rK   rL   rn    rG   )r\   rÅ  rM   r¶  rs   )rJ   rp   rr   rÆ  r¶  r_   rK   rL   rM     s
    zStrFixedLenField.__init__c                    s&   t |tƒr| d¡}tt| ƒ ||¡S rã   )rx   r   r¡  r\   rÅ  rŒ   )rJ   r€   r¢  r_   rK   rL   rŒ     s    

zStrFixedLenField.i2reprc                 C   s*   |   |¡}||d … |  ||d |… ¡fS rH   )r¶  rˆ   ©rJ   r€   r�   rº  rK   rK   rL   r•     s    
zStrFixedLenField.getfieldc                 C   s>   |   |¡}|d u r"||  ||¡ S |t d| |  ||¡¡ S )Nré   )r¶  r‰   ru   r�   )rJ   r€   r�   rI   rº  rK   rK   rL   r‘      s    
zStrFixedLenField.addfieldc                 C   s6   zt |  d ¡ƒW S  ty0   t tddƒƒ Y S 0 d S )Nr   éÈ   )r   r¶  r,  r   rO   rK   rK   rL   r©   '  s    zStrFixedLenField.randval)NN)
rV   rW   rX   rª   rM   rŒ   r•   r‘   r©   rl   rK   rK   r_   rL   rÅ    s     û	rÅ  c                   @   s   e Zd ZdS )ÚStrFixedLenFieldUtf16Nrf  rK   rK   rK   rL   rÉ  /  s   rÉ  c                   @   s   e Zd ZdgZddd„ZdS )ÚStrFixedLenEnumFieldrž  Nc                 C   s   t j| ||||d� || _d S )N)rÆ  r¶  )rÅ  rM   rž  )rJ   rp   rr   rž  rÆ  r¶  rK   rK   rL   rM   6  s    	zStrFixedLenEnumField.__init__)NNNr¥  rK   rK   rK   rL   rÊ  3  s
      úrÊ  c                   @   s&   e Zd Zd	dd„Zdd„ Zdd„ ZdS )
ÚNetBIOSNameFieldé   c                 C   s   t  | |||¡ d S rH   )rÅ  rM   )rJ   rp   rr   rÆ  rK   rK   rL   rM   D  s    zNetBIOSNameField.__init__c                 C   sX   |r|   |¡d }nd}t|p dƒ}|d| 7 }|d |… }d dd„ |D ƒ¡}d| S )Nrk  r   rG   ó    c                 s   s6   | ].}t d t|ƒd?  ƒt d t|ƒd@  ƒ V  qdS )éA   rM  é   N©r   r   rb  rK   rK   rL   rŸ   Q  s   þÿz'NetBIOSNameField.i2m.<locals>.<genexpr>)r¶  r!   r    )rJ   r€   r  rº  r�   rK   rK   rL   r‰   H  s    
ýzNetBIOSNameField.i2mc              	   C   s:   |  d¡  d¡}d tdd„ |d d d… |dd d… ƒ¡S )Nrä   rÍ  rG   c                 S   s(   t t| ƒd d@ d> t|ƒd d@  ƒS )Nrƒ   rÏ  rM  rÐ  )r�   r  rK   rK   rL   rn  \  s   "ÿz&NetBIOSNameField.m2i.<locals>.<lambda>rk  rƒ   )Ústripr    Úmapr   rK   rK   rL   rˆ   X  s
    üzNetBIOSNameField.m2iN)rÌ  )rV   rW   rX   rM   r‰   rˆ   rK   rK   rK   rL   rË  C  s   
rË  c                       s>   e Zd ZdZddgZdZd‡ fdd„	Zdd	„ Zd
d„ Z‡  Z	S )ÚStrLenFieldzš
    StrField with a length

    :param length_from: a function that returns the size of the string
    :param max_length: max size to use as randval
    r¶  Ú
max_lengthTNc                    s"   t t| ƒ ||¡ || _|| _d S rH   )r\   rÓ  rM   r¶  rÔ  )rJ   rp   rr   r¶  rÔ  r_   rK   rL   rM   m  s    zStrLenField.__init__c                 C   s@   | j pdd„ |ƒ}| js |d9 }||d … |  ||d |… ¡fS )Nc                 S   s   dS r*  rK   rl  rK   rK   rL   rn  {  rG   z&StrLenField.getfield.<locals>.<lambda>rk  )r¶  ÚON_WIRE_SIZE_UTF16rˆ   rÇ  rK   rK   rL   r•   y  s    zStrLenField.getfieldc                 C   s   t td| jpdƒƒS r•  )r   r   rÔ  rO   rK   rK   rL   r©   €  s    zStrLenField.randval)NN)
rV   rW   rX   rY   rª   rÕ  rM   r•   r©   rl   rK   rK   r_   rL   rÓ  c  s     ûrÓ  c                       s   e Zd Z‡ fdd„Z‡  ZS )Ú
_XStrFieldc                    s(   t |tƒrt|ƒ ¡ S tt| ƒ ||¡S rH   )rx   r   r   rœ  r\   rÖ  rŒ   r   r_   rK   rL   rŒ   †  s    
z_XStrField.i2reprrc  rK   rK   r_   rL   rÖ  …  s   rÖ  c                   @   s   e Zd ZdZdS )Ú	XStrFieldz9
    StrField which value is printed as hexadecimal.
    N©rV   rW   rX   rY   rK   rK   rK   rL   r×  �  s   r×  c                   @   s   e Zd ZdZdS )ÚXStrLenFieldz<
    StrLenField which value is printed as hexadecimal.
    NrØ  rK   rK   rK   rL   rÙ  “  s   rÙ  c                   @   s   e Zd ZdZdS )ÚXStrFixedLenFieldzA
    StrFixedLenField which value is printed as hexadecimal.
    NrØ  rK   rK   rK   rL   rÚ  ™  s   rÚ  c                   @   s   e Zd Zdd„ Zdd„ ZdS )ÚXLEStrLenFieldc                 C   s   |sdS |d d d… S )NrG   r¡   rK   r   rK   rK   rL   r‰      s    zXLEStrLenField.i2mc                 C   s   |d d d… S )Nr¡   rK   r   rK   rK   rL   rˆ   ¦  s    zXLEStrLenField.m2iN©rV   rW   rX   r‰   rˆ   rK   rK   rK   rL   rÛ  Ÿ  s   rÛ  c                   @   s   e Zd ZdS )ÚStrLenFieldUtf16Nrf  rK   rK   rK   rL   rÝ  «  s   rÝ  c                   @   s&   e Zd ZddgZd
dd„Zdd	„ ZdS )ÚBoundStrLenFieldÚminlenÚmaxlenr   rj  Nc                 C   s"   t j| |||d� || _|| _d S )N)r¶  )rÓ  rM   rß  rà  )rJ   rp   rr   rß  rà  r¶  rK   rK   rL   rM   ²  s    	zBoundStrLenField.__init__c                 C   s   t t| j| jƒƒS rH   )r   r   rß  rà  rO   rK   rK   rL   r©   ¿  s    zBoundStrLenField.randval)r   rj  N)rV   rW   rX   rª   rM   r©   rK   rK   rK   rL   rÞ  ¯  s      ú
rÞ  c                   @   sR   e Zd Zg 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S )ÚFieldListField)r  r¼  r¶  rƒ   Nc                 C   s0   |d u rg }|| _ t | ||¡ || _|| _d S rH   )r  ro   rM   r¼  r¶  )rJ   rp   rr   r  r¶  r¼  rK   rK   rL   rM   È  s    	zFieldListField.__init__c                 C   s   t |tƒrt|ƒS dS r¾  r¿  rÂ   rK   rK   rL   r„   Ø  s    
zFieldListField.i2countc                    s   t t‡ ‡fdd„|D ƒƒƒS )Nc                 3   s   | ]}ˆj  ˆ |¡V  qd S rH   )r  r‚   rÃ  r&  rK   rL   rŸ   à  rG   z'FieldListField.i2len.<locals>.<genexpr>)r¨   r\  rÂ   rK   r&  rL   r‚   Þ  s    zFieldListField.i2lenc                    s2   t |tƒsˆj ˆ |¡gS ‡ ‡fdd„|D ƒS d S )Nc                    s   g | ]}ˆj  ˆ |¡‘qS rK   )r  r{   )rž   Úer&  rK   rL   r'  ç  rG   z(FieldListField.any2i.<locals>.<listcomp>)rx   r—   r  r{   r   rK   r&  rL   r{   â  s    
zFieldListField.any2ic                    s   dd  ‡ ‡fdd„|D ƒ¡ S )Nz[%s]z, c                 3   s   | ]}ˆj  ˆ |¡V  qd S rH   )r  rŒ   rÃ  r&  rK   rL   rŸ   î  rG   z(FieldListField.i2repr.<locals>.<genexpr>rÄ  r   rK   r&  rL   rŒ   é  s    zFieldListField.i2reprc                 C   s*   |   ||¡}|D ]}| j |||¡}q|S rH   )r‰   r  r‘   )rJ   r€   r�   rI   r¢  rK   rK   rL   r‘   ð  s    zFieldListField.addfieldc                 C   s¤   d  }}| j d ur|   |¡}n| jd ur2|  |¡}g }d}|d ur\|d |… ||d …  }}|r˜|d urz|dkrrq˜|d8 }| j ||¡\}}| |¡ q\|| |fS )NrG   r   rƒ   )r¶  r¼  r  r•   ra   )rJ   r€   r�   rÀ  rº  rI   r-  r¢  rK   rK   rL   r•   û  s"    


zFieldListField.getfield)NN)rV   rW   rX   rª   r«   rM   r„   r‚   r{   rŒ   r‘   r•   rK   rK   rK   rL   rá  Ä  s     ú
rá  c                   @   s2   e Zd Zg d¢Zddddd„ fdd„Zdd	„ ZdS )
ÚFieldLenField)Ú	length_ofÚcount_ofÚadjustNrv   c                 C   s   |S rH   rK   ©r€   r�   rK   rK   rL   rn    rG   zFieldLenField.<lambda>c                 C   s&   t  | |||¡ || _|| _|| _d S rH   )ro   rM   rä  rå  ræ  ©rJ   rp   rr   rä  rq   rå  ræ  rK   rK   rL   rM     s    
zFieldLenField.__init__c                 C   s†   |d u rv|d urv| j d ur8| | j ¡\}}| ||¡}n0| jd ur`| | j¡\}}| ||¡}ntdƒ‚|  ||¡}n|d u r‚d}|S )Nz.Field should have either length_of or count_ofr   )rä  Zgetfield_and_valr‚   rå  r„   ry   ræ  )rJ   r€   r�   r±   ZfvalrŽ  rK   rK   rL   r‰   '  s    

ÿzFieldLenField.i2m)rV   rW   rX   rª   rM   r‰   rK   rK   rK   rL   rã    s   ù
rã  c                       s<   e Zd ZdZdZdd„ Zdd„ Zdd„ Z‡ fd	d
„Z‡  Z	S )ÚStrNullFieldrä   rƒ   c                 C   s   ||   ||¡ | j S rH   )r‰   Ú	DELIMITERrÈ   rK   rK   rL   r‘   >  s    zStrNullField.addfieldc                 C   sd   d}|  | j|¡}|dk r"d|fS || j r:|d7 }qq:q||t| jƒ d … |  ||d |… ¡fS )Nr   rG   rƒ   )Úfindrê  Ú	ALIGNMENTrS   rˆ   ©rJ   r€   r�   Úlen_strrK   rK   rL   r•   B  s    

zStrNullField.getfieldc                 C   s   t tddƒ| jƒS r•  )r   r   rê  rO   rK   rK   rL   r©   S  s    zStrNullField.randvalc                    s   t t| ƒ ||¡d S r¾  )r\   ré  r‚   r   r_   rK   rL   r‚   W  s    zStrNullField.i2len)
rV   rW   rX   rê  rì  r‘   r•   r©   r‚   rl   rK   rK   r_   rL   ré  :  s   ré  c                   @   s   e Zd ZdZdZdS )ÚStrNullFieldUtf16s     rk  N)rV   rW   rX   rê  rì  rK   rK   rK   rL   rï  \  s   rï  c                   @   s.   e Zd ZddgZddd„Zdd„ Zdd	„ Zd
S )ÚStrStopFieldró   Ú
additionalr   c                 C   s   t  | ||¡ || _|| _d S rH   )ro   rM   ró   rñ  )rJ   rp   rr   ró   rñ  rK   rK   rL   rM   d  s    zStrStopField.__init__c                 C   sH   |  | j¡}|dk rd|fS |t| jƒ| j 7 }||d … |d |… fS r”  )rë  ró   rS   rñ  rí  rK   rK   rL   r•   j  s
    zStrStopField.getfieldc                 C   s   t tddƒ| jƒS r•  )r   r   ró   rO   rK   rK   rL   r©   r  s    zStrStopField.randvalN)r   )rV   rW   rX   rª   rM   r•   r©   rK   rK   rK   rL   rð  a  s   
rð  c                   @   s0   e Zd ZdZdgZddd„ fdd„Zdd	„ Zd
S )ÚLenFieldz>
    If None, will be filled with the size of the payload
    ræ  rv   c                 C   s   | S rH   rK   rl  rK   rK   rL   rn  }  rG   zLenField.<lambda>c                 C   s   t  | |||¡ || _d S rH   )ro   rM   ræ  )rJ   rp   rr   rq   ræ  rK   rK   rL   rM   }  s    zLenField.__init__c                 C   s(   |d u r$d}|d ur$|   t|jƒ¡}|S r*  )ræ  rS   r  r   rK   rK   rL   r‰   ‚  s
    zLenField.i2mN)rV   rW   rX   rY   rª   rM   r‰   rK   rK   rK   rL   rò  w  s   rò  c                   @   s   e Zd Zdd„ Zdd„ ZdS )ÚBCDFloatFieldc                 C   s   |d u rdS t d| ƒS )Nr   rZ  ©r¨   r   rK   rK   rL   r‰   �  s    zBCDFloatField.i2mc                 C   s   |d S )Ng      p@rK   r   rK   rK   rL   rˆ   •  s    zBCDFloatField.m2iNrÜ  rK   rK   rK   rL   ró  Ž  s   ró  c                   @   sB   e Zd ZdZg d¢Zddd„Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dS )Ú	_BitFieldaÌ  
    Field to handle bits.

    :param name: name of the field
    :param default: default value
    :param size: size (in bits). If negative, Low endian
    :param tot_size: size of the total group of bits (in bytes) the bitfield
                     is in. If negative, Low endian.
    :param end_tot_size: same but for the BitField ending a group.

    Example - normal usage::

         0                   1                   2                   3
         0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
        |             A             |               B               | C |
        +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

                                 Fig. TestPacket

        class TestPacket(Packet):
            fields_desc = [
                BitField("a", 0, 14),
                BitField("b", 0, 16),
                BitField("c", 0, 2),
            ]

    Example - Low endian stored as 16 bits on the network::

        x x x x x x x x x x x x x x x x
        a [b] [   c   ] [      a      ]

        Will first get reversed during dissecion:

        x x x x x x x x x x x x x x x x
        [      a        ] [b] [   c   ]

        class TestPacket(Packet):
            fields_desc = [
                BitField("a", 0, 9, tot_size=-2),
                BitField("b", 0, 2),
                BitField("c", 0, 5, end_tot_size=-2)
            ]

    )ÚrevÚsizeÚtot_sizeÚend_tot_sizer   c                 C   s‚   t  | ||¡ t|ƒr|| ƒ}|dk p4|dk p4|dk | _t|ƒ| _|sP| jd }t|ƒ| _|sh| jd }t|ƒ| _| jd | _d S )Nr   é   ç       @)	ro   rM   Úcallablerö  Úabsr÷  rø  rù  rs   )rJ   rp   rr   r÷  rø  rù  rK   rK   rL   rM   Ê  s    




z_BitField.__init__c                 C   sÚ   |   ||¡}t|tƒr"|\}}}nd}d}|| jK }||d| j> d @ O }|| j7 }|dkrŠ|d8 }|t d||? ¡ }|d|> d M }qT|r˜|||fS | jrÒ| jdkrÒ|d | j … || j d … d d d…  }|S d S )Nr   rƒ   rú  z!Br¡   )r‰   rx   rÑ   r÷  ru   r�   rö  rù  )rJ   r€   r�   ÚivalrI   Zbitsdoner¢  rK   rK   rL   r‘   Þ  s"    



*z_BitField.addfieldc           
      C   s,  t |tƒr|\}}n:d}| jrN| jdkrN|d | j… d d d… || jd …  }| j| d d d }|d |… }t d| |¡}d}t|ƒD ]$}|t|| ƒ|| d d > O }qŒ|d|d | > d M }||d | j | ? }|| j7 }||d d … }|d }|  	||¡}	|�r ||f|	fS ||	fS d S )Nr   rƒ   r¡   rú  z!%dB)
rx   rÑ   rö  rø  r÷  ru   r“   r˜   r¨   rˆ   )
rJ   r€   r�   ZbnZnb_bytesÚwZ_bytesr£   rÀ  Úb2rK   rK   rL   r•   ù  s(    

&"
z_BitField.getfieldc                 C   s   t dd| j d ƒS )Nr   rk  rƒ   )r   r÷  rO   rK   rK   rL   r©    	  s    z_BitField.randvalc                 C   s   t | jƒd S )Nrú  )Úfloatr÷  r   rK   rK   rL   r‚   $	  s    z_BitField.i2lenN)r   r   )
rV   rW   rX   rY   rª   rM   r‘   r•   r©   r‚   rK   rK   rK   rL   rõ  š  s   - ÿ
'rõ  c                   @   s   e Zd ZejZdS )ÚBitFieldN)rV   rW   rX   rõ  rY   rK   rK   rK   rL   r  )	  s   r  c                       s:   e Zd ZdgZ‡ fdd„Z‡ fdd„Z‡ fdd„Z‡  ZS )ÚBitFixedLenFieldr¶  c                    s   || _ tt| ƒ ||d¡ d S r*  )r¶  r\   r  rM   )rJ   rp   rr   r¶  r_   rK   rL   rM   0	  s    zBitFixedLenField.__init__c                    s   |   |¡| _tt| ƒ ||¡S rH   )r¶  r÷  r\   r  r•   r”   r_   rK   rL   r•   9	  s    zBitFixedLenField.getfieldc                    s    |   |¡| _tt| ƒ |||¡S rH   )r¶  r÷  r\   r  r‘   rÈ   r_   rK   rL   r‘   A	  s    zBitFixedLenField.addfield)rV   rW   rX   rª   rM   r•   r‘   rl   rK   rK   r_   rL   r  -	  s   	r  c                       s<   e Zd Zg d¢Zdddd„ ddf‡ fdd„	Zdd	„ Z‡  ZS )
ÚBitFieldLenField)rä  rå  ræ  rø  rù  Nc                 C   s   |S rH   rK   rç  rK   rK   rL   rn  T	  rG   zBitFieldLenField.<lambda>r   c	           	         s.   t t| ƒ |||||¡ || _|| _|| _d S rH   )r\   r  rM   rä  rå  ræ  )	rJ   rp   rr   r÷  rä  rå  ræ  rø  rù  r_   rK   rL   rM   N	  s    ÿzBitFieldLenField.__init__c                 C   s"   t jrtjj}ntj}|| ||ƒS rH   )rú   rû   rã  r‰   Ú__func__)rJ   r€   r�   ÚfuncrK   rK   rL   r‰   _	  s    
zBitFieldLenField.i2m)rV   rW   rX   rª   rM   r‰   rl   rK   rK   r_   rL   r  K	  s   ør  c                   @   s   e Zd Zdd„ ZdS )Ú	XBitFieldc                 C   s   t |  ||¡ƒS rH   r  r   rK   rK   rL   rŒ   i	  s    zXBitField.i2reprNrI  rK   rK   rK   rL   r  h	  s   r  c                   @   sF   e 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S )Ú
_EnumFieldrv   c                 C   sn  t |tƒrtt|ƒ | ¡ t |tƒrH|d | _|d | _d| _d| _�nt	r´t |t
ƒr´t|t	ƒr´i  }| _i  }| _d| _d| _dd„ |D ƒ}|D ]}|| j}	|||	< |	||< q’n¦i  }| _i  }| _d| _d| _g }
t |tƒrôttt|ƒƒƒ}
n<t |tƒ�r
| ¡ }
n&t|ƒ}
tdd„ |
D ƒƒ�r0|| }}|
D ]$}tt|| ƒ}	|	||< |||	< �q4t | |||¡ dS )au   Initializes enum fields.

        @param name:    name of this field
        @param default: default value of this field
        @param enum:    either an enum, a dict or a tuple of two callables.
                        Dict keys are the internal values, while the dict
                        values are the user-friendly representations. If the
                        tuple is provided, the first callable receives the
                        internal value as parameter and returns the
                        user-friendly representation and the second callable
                        does the converse. The first callable may return None
                        to default to a literal string (repr()) representation.
        @param fmt:     struct.pack format used to parse and serialize the
                        internal value from and to machine representation.
        r   rƒ   Nc                 S   s   g | ]
}|j ‘qS rK   rÌ   r�   rK   rK   rL   r'  “	  rG   z'_EnumField.__init__.<locals>.<listcomp>c                 s   s   | ]}t |tƒV  qd S rH   )rx   rN   r�   rK   rK   rL   rŸ   ¤	  rG   z&_EnumField.__init__.<locals>.<genexpr>)rx   rZ   rC   rb   rÑ   Úi2s_cbÚs2i_cbÚi2sÚs2ir6   rÇ   Ú
issubclassrf   r—   r˜   rS   r   ÚkeysrÍ   rN   ro   rM   )rJ   rp   rr   rž  rq   r  r  Únamesr%  rf   r  rj   rK   rK   rL   rM   o	  sD    












z_EnumField.__init__c                 C   sP   t rt|t ƒrtt|jƒS t|tƒrF| jr6| j| }n| jrF|  |¡}tt|ƒS rH   )r6   rx   rC   rm   rf   rN   r  r
  r   rK   rK   rL   Ú	any2i_one¬	  s    

z_EnumField.any2i_onec                 C   s`   | t jvrXt|tƒsX| jr<z| j| W S  ty8   Y qX0 n| jrX|  |¡}|d urX|S t|ƒS rH   )r   Únoenumrx   r   r  rÚ   r	  r‹   ©rJ   r€   r�   r-  rK   rK   rL   Ú
i2repr_one·	  s    
z_EnumField.i2repr_onec                    s.   t |tƒr‡ ‡fdd„|D ƒS ˆ ˆ |¡S d S )Nc                    s   g | ]}ˆ  ˆ |¡‘qS rK   )r  ©rž   Úzr&  rK   rL   r'  È	  rG   z$_EnumField.any2i.<locals>.<listcomp>)rx   r—   r  r   rK   r&  rL   r{   Å	  s    
z_EnumField.any2ic                    s.   t |tƒr‡ ‡fdd„|D ƒS ˆ ˆ |¡S d S )Nc                    s   g | ]}ˆ  ˆ |¡‘qS rK   )r  r  r&  rK   rL   r'  Ï	  rG   z%_EnumField.i2repr.<locals>.<listcomp>)rx   r—   r  r   rK   r&  rL   rŒ   Ì	  s    
z_EnumField.i2reprc                 C   sR   t |tƒrdnd}t d| | ||¡ | jd urN| jd urN|| j|< || j|< d S )Nr_  ú%szAt %s: Change to %s at ©rx   r¨   r   Údebugr  r  )rJ   rž  re   rf   ÚksrK   rK   rL   rc   Ó	  s    ÿ
z_EnumField.notify_setc                 C   sV   t |tƒrdnd}t d| | |¡ | jd urR| jd urR| j| }| j|= | j|= d S )Nr_  r  zAt %s: Delete value at r  )rJ   rž  re   r  rf   rK   rK   rL   rh   Ý	  s    
z_EnumField.notify_delN)rv   )
rV   rW   rX   rM   r  r  r{   rŒ   rc   rh   rK   rK   rK   rL   r  n	  s    ü
=
r  c                   @   s   e Zd Zg d¢ZdS )Ú	EnumField)r  r  r
  r	  N©rV   rW   rX   rª   rK   rK   rK   rL   r  ç	  s   r  c                   @   s   e Zd Zddd„Zdd„ ZdS )ÚCharEnumFieldÚ1sc                 C   sP   t  | ||||¡ | jd urLt| jƒ}|rLt|d ƒdkrL| j| j | _| _d S rð   )r  rM   r  r—   rS   r  )rJ   rp   rr   rž  rq   rj   rK   rK   rL   rM   ì	  s
    

zCharEnumField.__init__c                 C   s2   t |ƒdkr.| jr| j| }n| jr.|  |¡}|S r¾  )rS   r  r
  r   rK   rK   rL   r  ù	  s    
zCharEnumField.any2i_oneN)r  )rV   rW   rX   rM   r  rK   rK   rK   rL   r  ë	  s    ü
r  c                   @   s*   e Zd ZejZdd„ Zdd„ Zdd„ ZdS )ÚBitEnumFieldc                 K   s,   t  | |||¡ tj| |||fi |¤Ž d S rH   )r  rM   rõ  )rJ   rp   rr   r÷  rž  r  rK   rK   rL   rM   
  s    zBitEnumField.__init__c                 C   s   t  | ||¡S rH   ©r  r{   r   rK   rK   rL   r{   
  s    zBitEnumField.any2ic                 C   s   t  | ||¡S rH   ©r  rŒ   r   rK   rK   rL   rŒ   
  s    zBitEnumField.i2reprN©rV   rW   rX   r  rª   rM   r{   rŒ   rK   rK   rK   rL   r  
  s   r  c                   @   s   e Zd ZejZdd„ ZdS )ÚShortEnumFieldc                 C   s   t  | |||d¡ d S rv  ©r  rM   ©rJ   rp   rr   rž  rK   rK   rL   rM   
  s    zShortEnumField.__init__N)rV   rW   rX   r  rª   rM   rK   rK   rK   rL   r"  
  s   r"  c                   @   s   e Zd Zdd„ ZdS )ÚLEShortEnumFieldc                 C   s   t  | |||d¡ d S ry  r#  r$  rK   rK   rL   rM   $
  s    zLEShortEnumField.__init__NrG  rK   rK   rK   rL   r%  #
  s   r%  c                   @   s   e Zd Zdd„ ZdS )ÚLELongEnumFieldc                 C   s   t  | |||d¡ d S r‰  r#  r$  rK   rK   rL   rM   *
  s    zLELongEnumField.__init__NrG  rK   rK   rK   rL   r&  )
  s   r&  c                   @   s   e Zd Zdd„ ZdS )ÚByteEnumFieldc                 C   s   t  | |||d¡ d S rF  r#  r$  rK   rK   rL   rM   0
  s    zByteEnumField.__init__NrG  rK   rK   rK   rL   r'  /
  s   r'  c                   @   s   e Zd Zdd„ ZdS )ÚXByteEnumFieldc                 C   s`   | t jvrXt|tƒsX| jr<z| j| W S  ty8   Y qX0 n| jrX|  |¡}|d urX|S t|ƒS rH   ©r   r  rx   r   r  rÚ   r	  r&   r  rK   rK   rL   r  6
  s    
zXByteEnumField.i2repr_oneN©rV   rW   rX   r  rK   rK   rK   rL   r(  5
  s   r(  c                   @   s   e Zd Zdd„ ZdS )ÚIntEnumFieldc                 C   s   t  | |||d¡ d S r~  r#  r$  rK   rK   rL   rM   F
  s    zIntEnumField.__init__NrG  rK   rK   rK   rL   r+  E
  s   r+  c                   @   s   e Zd Zdd„ ZdS )ÚSignedIntEnumFieldc                 C   s   t  | |||d¡ d S r€  r#  r$  rK   rK   rL   rM   L
  s    zSignedIntEnumField.__init__NrG  rK   rK   rK   rL   r,  K
  s   r,  c                   @   s   e Zd Zdd„ ZdS )ÚLEIntEnumFieldc                 C   s   t  | |||d¡ d S rV  r#  r$  rK   rK   rL   rM   R
  s    zLEIntEnumField.__init__NrG  rK   rK   rK   rL   r-  Q
  s   r-  c                   @   s   e Zd Zdd„ ZdS )ÚXShortEnumFieldc                 C   sd   | t jvr\t|tƒs\| jd ur@z| j| W S  ty<   Y q\0 n| jr\|  |¡}|d ur\|S t|ƒS rH   r)  r  rK   rK   rL   r  X
  s    

zXShortEnumField.i2repr_oneNr*  rK   rK   rK   rL   r.  W
  s   r.  c                   @   s&   e Zd Zd	dd„Zdd„ Zdd„ ZdS )
Ú_MultiEnumFieldrv   c           
      C   sn   || _ || _i | _i | _|D ]<}i }|| j|< t || ¡D ]\}}	|||	< || j|	< q<qt | |||¡ d S rH   )Ú
depends_onÚ	i2s_multiÚ	s2i_multiÚs2i_allrú   r  ro   rM   )
rJ   rp   rr   rž  r0  rq   r­  r  rj   r¢  rK   rK   rL   rM   h
  s    	
z_MultiEnumField.__init__c                 C   sL   t |tƒrB|  |¡}|| jv r8| j| }||v r8|| S | j| S tt|ƒS rH   )rx   rN   r0  r2  r3  rC   rm   )rJ   r€   r�   r¢  r  rK   rK   rL   r  }
  s    




z_MultiEnumField.any2i_onec                 C   sD   |   |¡}t|tƒrt|ƒS || jv r<t| j|  ||¡ƒS t|ƒS rH   )r0  rx   r   r‹   r1  rN   r  )rJ   r€   r�   r¢  rK   rK   rL   r  ˆ
  s    


z_MultiEnumField.i2repr_oneN)rv   )rV   rW   rX   rM   r  r  rK   rK   rK   rL   r/  g
  s    û
r/  c                   @   s   e Zd Zg d¢ZdS )ÚMultiEnumField)r0  r1  r2  r3  Nr  rK   rK   rK   rL   r4  ’
  s   r4  c                   @   s0   e Zd Zejej Zdd„ Zdd„ Zdd„ ZdS )ÚBitMultiEnumFieldc                 C   s6   t  | ||||¡ |dk | _t|ƒ| _| jd | _d S )Nr   rû  )r/  rM   rö  rý  r÷  rs   )rJ   rp   rr   r÷  rž  r0  rK   rK   rL   rM   š
  s    	

zBitMultiEnumField.__init__c                 C   s   t  | ||¡S rH   )r/  r{   r   rK   rK   rL   r{   ¨
  s    zBitMultiEnumField.any2ic                 C   s   t  | ||¡S rH   )r/  rŒ   r   rK   rK   rL   rŒ   ¬
  s    zBitMultiEnumField.i2reprN)	rV   rW   rX   r  rª   r4  rM   r{   rŒ   rK   rK   rK   rL   r5  –
  s   r5  c                   @   s   e Zd ZdZdd„ ZdS )ÚByteEnumKeysFieldz3ByteEnumField that picks valid values when fuzzed. c                 C   s   t | jp
i ƒS rH   ©r	   r  rO   rK   rK   rL   r©   ¸
  s    zByteEnumKeysField.randvalN©rV   rW   rX   rY   r©   rK   rK   rK   rL   r6  µ
  s   r6  c                   @   s   e Zd ZdZdd„ ZdS )ÚShortEnumKeysFieldz4ShortEnumField that picks valid values when fuzzed. c                 C   s   t | jp
i ƒS rH   r7  rO   rK   rK   rL   r©   À
  s    zShortEnumKeysField.randvalNr8  rK   rK   rK   rL   r9  ½
  s   r9  c                   @   s   e Zd ZdZdd„ ZdS )ÚIntEnumKeysFieldz2IntEnumField that picks valid values when fuzzed. c                 C   s   t | jp
i ƒS rH   r7  rO   rK   rK   rL   r©   È
  s    zIntEnumKeysField.randvalNr8  rK   rK   rK   rL   r:  Å
  s   r:  c                   @   s"   e Zd Zddddd„ fdd„ZdS )ÚLEFieldLenFieldNrz  c                 C   s   |S rH   rK   rç  rK   rK   rL   rn  Ø
  rG   zLEFieldLenField.<lambda>c              	   C   s   t j| ||||||d� d S )N)rä  rq   rå  ræ  )rã  rM   rè  rK   rK   rL   rM   Ñ
  s    
ûzLEFieldLenField.__init__rG  rK   rK   rK   rL   r;  Ð
  s
   ùr;  c                   @   s0   e Zd ZddgZdd„ Zdd„ Zdd„ ZeZd	S )
ÚFlagValueIterÚ	flagvalueÚcursorc                 C   s   || _ d| _d S r*  )r=  r>  )rJ   r=  rK   rK   rL   rM   è
  s    zFlagValueIter.__init__c                 C   s   | S rH   rK   rO   rK   rK   rL   Ú__iter__í
  s    zFlagValueIter.__iter__c                 C   sR   t | jƒ}|| jL }|rJ|  jd7  _|d@ r@| jj| jd  S |dL }qt‚d S r¾  )r¨   r=  r>  r  ÚStopIteration©rJ   r�   rK   rK   rL   Ú__next__ñ
  s    


zFlagValueIter.__next__N)rV   rW   rX   rª   rM   r?  rB  ÚnextrK   rK   rK   rL   r<  ä
  s
   r<  c                       sø   e Zd Zg 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d„ Zdd„ ZeZdd„ ZeZeZdd„ Zdd„ Zdd„ Zd d!„ Zd"d#„ ZeZd$d%„ Zd&d'„ Zd(d)„ Zd*d+„ Zd,d-„ Z‡ fd.d/„Z‡ fd0d1„Zd2d3„ Z ‡  Z!S )4Ú	FlagValue)rf   r  Úmultic                 C   sd   |sdS t |tjƒr,| jr$| d¡nt|ƒ}t |tƒr\d}|D ]}|d| j |¡> O }q>|}t|ƒS )Nr   ú+rƒ   )	rx   rú   Ústring_typesrE  Úsplitr—   r  Úindexr¨   )rJ   rf   r  rš   rK   rK   rL   Ú	_fixvalue  s    
zFlagValue._fixvaluec                 C   s"   t |tƒ| _|| _|  |¡| _d S rH   )rx   r—   rE  r  rJ  rf   )rJ   rf   r  rK   rK   rL   rM     s    zFlagValue.__init__c                 C   s
   t | jƒS rH   )Úhashrf   rO   rK   rK   rL   r½     s    zFlagValue.__hash__c                 C   s   | j S rH   )rf   rO   rK   rK   rL   Ú__int__  s    zFlagValue.__int__c                 C   s   | j |  |¡kS rH   ©rf   rJ  r¹   rK   rK   rL   r»     s    zFlagValue.__eq__c                 C   s   | j |  |¡k S rH   rM  r¹   rK   rK   rL   Ú__lt__!  s    zFlagValue.__lt__c                 C   s   | j |  |¡kS rH   rM  r¹   rK   rK   rL   Ú__le__%  s    zFlagValue.__le__c                 C   s   | j |  |¡kS rH   rM  r¹   rK   rK   rL   Ú__gt__)  s    zFlagValue.__gt__c                 C   s   | j |  |¡kS rH   rM  r¹   rK   rK   rL   Ú__ge__-  s    zFlagValue.__ge__c                 C   s   | j |  |¡kS rH   rM  r¹   rK   rK   rL   r¼   1  s    zFlagValue.__ne__c                 C   s   |   | j|  |¡@ | j¡S rH   ©r`   rf   rJ  r  r¹   rK   rK   rL   Ú__and__5  s    zFlagValue.__and__c                 C   s   |   | j|  |¡B | j¡S rH   rR  r¹   rK   rK   rL   Ú__or__:  s    zFlagValue.__or__c                 C   s,   |   | jdt| jƒ d |  |¡ @ | j¡S ©Nrk  rƒ   )r`   rf   rS   r  rJ  r¹   rK   rK   rL   Ú__sub__@  s     þzFlagValue.__sub__c                 C   s   |   | j|  |¡A | j¡S rH   rR  r¹   rK   rK   rL   Ú__xor__G  s    zFlagValue.__xor__c                 C   s   | j |  |¡> S rH   rM  r¹   rK   rK   rL   Ú
__lshift__K  s    zFlagValue.__lshift__c                 C   s   | j |  |¡? S rH   rM  r¹   rK   rK   rL   Ú
__rshift__O  s    zFlagValue.__rshift__c                 C   s
   t | jƒS rH   )r¸   rf   rO   rK   rK   rL   Ú__nonzero__S  s    zFlagValue.__nonzero__c                 C   s   t  dt¡ t| ƒS )Nz1obj.flagrepr() is obsolete. Use str(obj) instead.)rÎ   rÏ   ÚDeprecationWarningrN   rO   rK   rK   rL   ÚflagreprX  s
    þzFlagValue.flagreprc                 C   sr   d}g }t | ƒ}|r^|d@ rLz| j| }W n ty@   d}Y n0 | |¡ |d7 }|dL }q| jrhdnd |¡S )Nr   rƒ   ú?rF  ra  )r¨   r  Ú
IndexErrorra   rE  r    )rJ   rš   r.  r�   rp   rK   rK   rL   rP   `  s    


zFlagValue.__str__c                 C   s   t | ƒS rH   )r<  rO   rK   rK   rL   r?  p  s    zFlagValue.__iter__c                 C   s   d| | f S )Nz<Flag %d (%s)>rK   rO   rK   rK   rL   rU   t  s    zFlagValue.__repr__c                 C   s   |   t| ƒ| j¡S rH   )r`   r¨   r  )rJ   ÚmemorK   rK   rL   Ú__deepcopy__x  s    zFlagValue.__deepcopy__c                    s²   |ˆ j v rttˆ ƒ |¡S z<ˆ jr@tdˆ j |¡ tˆ ƒ@ ƒW S t	‡ fdd„|D ƒƒW S  t
y¬   d|v r˜zˆ  | dd¡¡W  Y S  ty–   Y n0 ttˆ ƒ |¡ Y S 0 d S )Nrk  c                 3   s*   | ]"}t d ˆ j |¡ tˆ ƒ@ ƒV  qdS )rk  N)r¸   r  rI  r¨   )rž   ÚflagrO   rK   rL   rŸ   ƒ  s   ÿz(FlagValue.__getattr__.<locals>.<genexpr>rÝ   ú-)rª   r\   rD  Ú__getattribute__rE  r¸   r  rI  r¨   r  ry   r´   rš  r  r²   r_   rO   rL   r´   |  s    
ÿ
zFlagValue.__getattr__c                    s–   |dkrt |tjƒst|ƒ‚|| jv r8tt| ƒ ||¡S || jv r€|rb|  j	d| j 
|¡ O  _	q’|  j	d| j 
|¡  M  _	ntt| ƒ ||¡S d S )Nrf   rk  )rx   rú   r5   ry   rª   r\   rD  Ú__setattr__r  rf   rI  )rJ   r³   rf   r_   rK   rL   rd  �  s    

zFlagValue.__setattr__c                 C   s   |   | j| j¡S rH   )r`   rf   r  rO   rK   rK   rL   r–   ›  s    zFlagValue.copy)"rV   rW   rX   rª   rJ  rM   r½   rL  r»   rN  rO  rP  rQ  r¼   rS  Ú__rand__rT  Ú__ror__Ú__add__rV  rW  rX  rY  rZ  Ú__bool__r\  rP   r?  rU   r`  r´   rd  r–   rl   rK   rK   r_   rL   rD  ÿ
  s<   rD  c                       s^   e Zd ZdZdZdgZ‡ fdd„Zdd„ Z‡ fdd	„Z‡ fd
d„Z	‡ fdd„Z
dd„ Z‡  ZS )Ú
FlagsFielda9   Handle Flag type field

   Make sure all your flags have a label

   Example (list):
       >>> from scapy.packet import Packet
       >>> class FlagsTest(Packet):
               fields_desc = [FlagsField("flags", 0, 8, ["f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7"])]  # noqa: E501
       >>> FlagsTest(flags=9).show2()
       ###[ FlagsTest ]###
         flags     = f0+f3

    Example (str):
       >>> from scapy.packet import Packet
       >>> class TCPTest(Packet):
               fields_desc = [
                   BitField("reserved", 0, 7),
                   FlagsField("flags", 0x2, 9, "FSRPAUECN")
               ]
       >>> TCPTest(flags=3).show2()
       ###[ FlagsTest ]###
         reserved  = 0
         flags     = FS

    Example (dict):
       >>> from scapy.packet import Packet
       >>> class FlagsTest2(Packet):
               fields_desc = [
                   FlagsField("flags", 0x2, 16, {
                       0x0001: "A",
                       0x0008: "B",
                   })
               ]

   :param name: field's name
   :param default: default value for the field
   :param size: number of bits in the field (in bits). if negative, LE
   :param names: (list or str or dict) label for each flag
       If it's a str or a list, the least Significant Bit tag's name
       is written first.
   Tr  c              
      sp   t |tƒrRdd„ tt|ƒƒD ƒ}t |¡D ]"\}}||tt t 	|d¡¡ƒ< q*|}|| _
tt| ƒ |||¡ d S )Nc                 S   s   g | ]}d | ‘qS )zbit_%drK   )rž   rš   rK   rK   rL   r'  Ö  rG   z'FlagsField.__init__.<locals>.<listcomp>rk  )rx   ro  r˜   rý  rú   Ú	viewitemsr¨   ÚmathÚfloorÚlogr  r\   ri  rM   )rJ   rp   rr   r÷  r  Útmprš   r¢  r_   rK   rL   rM   Í  s    
zFlagsField.__init__c                 C   s*   t |ttfƒr|S |du rdS t|| jƒS )zkReturns a FlagValue instance when needed. Internal method, to be
used in *2i() and i2*() methods.

        N)rx   rD  r   r  rA  rK   rK   rL   Ú
_fixup_valÞ  s
    zFlagsField._fixup_valc                    s   |   tt| ƒ ||¡¡S rH   )ro  r\   ri  r{   r   r_   rK   rL   r{   ê  s    zFlagsField.any2ic                    s   |   tt| ƒ ||¡¡S rH   )ro  r\   ri  rˆ   r   r_   rK   rL   rˆ   î  s    zFlagsField.m2ic                    s   |   tt| ƒ ||¡¡S rH   )ro  r\   ri  r‡   r   r_   rK   rL   r‡   ò  s    zFlagsField.i2hc                    sF   t |ttfƒr,tt|ƒ‡ fdd„|D ƒƒƒS |d u r8dS tˆ  |¡ƒS )Nc                 3   s(   | ] }|d u rdnt ˆ  |¡ƒV  qd S )NÚNone)rN   ro  rÃ  rO   rK   rL   rŸ   ü  s   z$FlagsField.i2repr.<locals>.<genexpr>rp  )rx   r—   rÑ   r‹   rÇ   rN   ro  r   rK   rO   rL   rŒ   ö  s
    ÿ
zFlagsField.i2repr)rV   rW   rX   rY   r¬   rª   rM   ro  r{   rˆ   r‡   rŒ   rl   rK   rK   r_   rL   ri     s   )ri  ÚMultiFlagsEntryÚshortÚlongc                       sH   e Zd Zejdg Z‡ fdd„Zdd„ Zdd„ Zdd	„ Zd
d„ Z	‡  Z
S )ÚMultiFlagsFieldr0  c                    s$   || _ || _tt| ƒ |||¡ d S rH   )r  r0  r\   rt  rM   )rJ   rp   rr   r÷  r  r0  r_   rK   rL   rM     s    zMultiFlagsField.__init__c                 C   sÆ   t |ttfƒstdƒ‚|d ur²t |tƒr4|  ||¡S |  |¡}|d ur²|| jv sXJ dƒ‚| j| }tƒ }|D ]@}t |¡D ]}|j	|krz| 
|¡  qlqzdslJ d |¡ƒ‚qlql|S t |tƒrÂtƒ S |S )Nzset expectedzinvalid dependencyFz&Unknown flag "{}" with this dependency)rx   Úsetr¨   ry   rˆ   r0  r  rú   Ú
itervaluesrr  Úaddrp  )rJ   r€   r�   r¢  Úthese_namesr�   rš   rI   rK   rK   rL   r{     s*    





zMultiFlagsField.any2ic           	      C   s€   |   |¡}| j |i ¡}d}|d u r(|S |D ]N}t |¡D ]"\}}|j|kr:|d|> O } q,q:|dt|tdƒd … ƒ> O }q,|S )Nr   rƒ   zbit )r0  r  r  rú   r  rr  r¨   rS   )	rJ   r€   r�   r¢  rx  r.  Úflag_setrš   rI   rK   rK   rL   r‰   /  s    

zMultiFlagsField.i2mc                 C   sn   |   |¡}| j |i ¡}tƒ }d}|rj|d@ rX||v rH| || j¡ n| d |¡¡ |dL }|d7 }q"|S )Nr   rƒ   zbit {})r0  r  r  ru  rw  rr  rp  )rJ   r€   r�   r¢  rx  r.  rš   rK   rK   rL   rˆ   @  s    

zMultiFlagsField.m2ic                 C   sn   |   |¡}| j |i ¡}tƒ }|D ]B}t |¡D ](}|j|kr0| d |j	|j¡¡  q"q0| |¡ q"t
|ƒS )Nz{} ({}))r0  r  r  ru  rú   rv  rr  rw  rp  rs  r‹   )rJ   r€   r�   r¢  rx  r.  ry  rš   rK   rK   rL   rŒ   Q  s    

zMultiFlagsField.i2repr)rV   rW   rX   ri  rª   rM   r{   r‰   rˆ   rŒ   rl   rK   rK   r_   rL   rt    s   rt  c                       s<   e Zd ZdgZd‡ fdd„	Zdd„ Zdd„ Zd	d
„ Z‡  ZS )ÚFixedPointFieldÚ	frac_bitsé   c                    s   || _ tt| ƒ |||¡ d S rH   )r{  r\   rz  rM   )rJ   rp   rr   r÷  r{  r_   rK   rL   rM   d  s    zFixedPointField.__init__c                 C   s8   |d u r|S t |ƒ}t || d| j  ƒ}|| j> |B S )Nrk  )r¨   r{  )rJ   r€   rI   rþ  ZfractrK   rK   rL   r{   i  s
    zFixedPointField.any2ic                 C   sJ   || j ? }d| j  }t|d| j > d @ ƒ}|| }|| tt |¡ƒ¡ S )Ng       @rƒ   )r{  r)   Ú	normalizer¨   rk  Úlog10)rJ   r€   rI   Zint_partÚpwZ	frac_partrK   rK   rL   r‡   q  s
    

zFixedPointField.i2hc                 C   s   t |  ||¡ƒS rH   )rN   r‡   rÂ   rK   rK   rL   rŒ   z  s    zFixedPointField.i2repr)r|  )	rV   rW   rX   rª   rM   r{   r‡   rŒ   rl   rK   rK   r_   rL   rz  a  s
   	rz  c                   @   sf   e Zd Zg 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dd„ Zdd„ ZdS )Ú_IPPrefixFieldBase)Ú	wordbytesÚmaxbytesÚatonÚntoar¶  Nc                 C   sH   || _ || _|| _|| _t | ||d| j ¡ |d u r>dd„ }|| _d S )Nré   c                 S   s   dS r*  rK   rl  rK   rK   rL   rn  •  rG   z-_IPPrefixFieldBase.__init__.<locals>.<lambda>)r�  r‚  rƒ  r„  ro   rM   r¶  )rJ   rp   rr   r�  r‚  rƒ  r„  r¶  rK   rK   rL   rM   „  s    z_IPPrefixFieldBase.__init__c                 C   s    | j d }||d  | | j  S )Nrú  rƒ   )r�  )rJ   ÚpfxlenÚwbitsrK   rK   rL   Ú	_numbytes˜  s    
z_IPPrefixFieldBase._numbytesc                 C   s$   |  d¡\}}|  |¡ |t|ƒfS )Nú/)rH  rƒ  r¨   ©rJ   r€   r�   Úpfxr…  rK   rK   rL   r†   �  s    
z_IPPrefixFieldBase.h2ic                 C   s   |\}}d||f S )Nz%s/%irK   r‰  rK   rK   rL   r‡   ¤  s    z_IPPrefixFieldBase.i2hc                 C   s:   |d u rd\}}n|\}}|   |¡}|d |  |¡… |fS )N)ra  r   )rƒ  r‡  )rJ   r€   r�   rŠ  r…  r�   rK   rK   rL   r‰   ª  s
    

z_IPPrefixFieldBase.i2mc                 C   s:   |\}}t |ƒ| jk r,|d| jt |ƒ   }|  |¡|fS rã   )rS   r‚  r„  )rJ   r€   r�   r�   r…  rK   rK   rL   rˆ   ·  s    z_IPPrefixFieldBase.m2ic                 C   s(   |d u r|   d| j ¡dfS |  ||¡S )Nrä   rƒ   )r„  r‚  r†   r   rK   rK   rL   r{   À  s    z_IPPrefixFieldBase.any2ic                 C   s   |\}}|S rH   rK   )rJ   r€   r�   rÝ   r…  rK   rK   rL   r‚   Ç  s    z_IPPrefixFieldBase.i2lenc                 C   s.   |   ||¡\}}d|  |¡ }|t ||¡ S )Nú!%is)r‰   r‡  ru   r�   )rJ   r€   r�   rI   Zrawpfxr…  rq   rK   rK   rL   r‘   Ì  s    z_IPPrefixFieldBase.addfieldc              
   C   sL   |   |¡}|  |¡}d| }||d … |  |t ||d |… ¡d |f¡fS )Nr‹  r   )r¶  r‡  rˆ   ru   r“   )rJ   r€   r�   r…  Únumbytesrq   rK   rK   rL   r•   Ò  s    

z_IPPrefixFieldBase.getfield)N)rV   rW   rX   rª   rM   r‡  r†   r‡   r‰   rˆ   r{   r‚   r‘   r•   rK   rK   rK   rL   r€  �  s   
 ø
	r€  c                   @   s   e Zd Zddd„ZdS )ÚIPPrefixFieldrƒ   Nc              
   C   s   t  | |||dtt|¡ d S )NrM  )r€  rM   r$   r%   ©rJ   rp   rr   r�  r¶  rK   rK   rL   rM   Û  s    øzIPPrefixField.__init__)rƒ   NrG  rK   rK   rK   rL   r�  Ú  s     ûr�  c                   @   s   e Zd Zddd„ZdS )ÚIP6PrefixFieldrƒ   Nc              
   C   s$   t  | |||ddd„ dd„ |¡ d S )Nr|  c                 S   s   t tj| ƒS rH   )r#   r(  r?  )ÚarK   rK   rL   rn  ý  rG   z)IP6PrefixField.__init__.<locals>.<lambda>c                 S   s   t tj| ƒS rH   r@  )r%  rK   rK   rL   rn  þ  rG   )r€  rM   rŽ  rK   rK   rL   rM   ï  s    øzIP6PrefixField.__init__)rƒ   NrG  rK   rK   rK   rL   r�  î  s     ûr�  c                   @   s.   e Zd Zg d¢Zddd„Zdd	„ Zd
d„ ZdS )ÚUTCTimeField)ÚepochÚdeltaÚstrfÚuse_msecÚ	use_microÚuse_nanoÚcustom_scalingFNú%a, %d %b %Y %H:%M:%S %zrm   c
                 C   sZ   t j| |||	d� |d u rtnt |¡}
|
| _|
t | _|| _|| _|| _	|| _
|| _d S )N)rq   )ro   rM   r   ÚcalendarÚtimegmr’  r“  r”  r•  r–  r—  r˜  )rJ   rp   rr   r•  r–  r—  r’  r”  r˜  rq   Zmk_epochrK   rK   rL   rM   	  s    
zUTCTimeField.__init__c                 C   s†   |d u rt   ¡ | j }n@| jr(|d }n0| jr8|d }n | jrH|d }n| jrX|| j }t|ƒ| j }t  | jt  	|¡¡}d||f S )Nç     @�@ç    €„.Aç    eÍÍAz%s (%d))
Útimer“  r•  r–  r—  r˜  r¨   Ústrftimer”  Úgmtime)rJ   r€   r�   ÚtrK   rK   rL   rŒ     s    



zUTCTimeField.i2reprc                 C   sf   |d u r^t   ¡ | j }| jr&|d }n0| jr6|d }n | jrF|d }n| jrV|| j }t|ƒS t|ƒS )Nrœ  r�  rž  )rŸ  r“  r•  r–  r—  r˜  r¨   r   rK   rK   rL   r‰   /  s    



zUTCTimeField.i2m)FFFNr™  Nrm   )rV   rW   rX   rª   rM   rŒ   r‰   rK   rK   rK   rL   r‘    s          ÷
r‘  c                   @   s&   e Zd Zg d¢Zddd„Zdd„ ZdS )	ÚSecondsIntField©r•  r–  r—  Fc                 C   s&   t  | ||d¡ || _|| _|| _d S r~  )ro   rM   r•  r–  r—  )rJ   rp   rr   r•  r–  r—  rK   rK   rL   rM   D  s    zSecondsIntField.__init__c                 C   sJ   |d u rd}n4| j r|d }n$| jr.|d }n| jr>|d }n|}d| S )Nr   rœ  r�  rž  z%s secr¤  r  rK   rK   rL   rŒ   N  s    


zSecondsIntField.i2reprN)FFF)rV   rW   rX   rª   rM   rŒ   rK   rK   rK   rL   r£  ?  s      ý

r£  c                   @   s>   e Zd Zddd„Zdd	„ Zd
d„ Zdd„ Zdd„ Zdd„ ZdS )Ú_ScalingFieldrƒ   ra  r   rP  r¢   c                 C   s,   || _ || _|| _|| _t | |||¡ d S rH   )ÚscalingÚunitÚoffsetÚndigitsro   rM   )rJ   rp   rr   r¦  r§  r¨  r©  rq   rK   rK   rL   rM   ^  s
    
z_ScalingField.__init__c                 C   sD   |d u rd}|| j  | j }t|tƒr@| jd dkr@tt|ƒƒ}|S )Nr   r¡   rŽ  )r¨  r¦  rx   r  rq   r¨   Úroundr   rK   rK   rL   r‰   n  s    z_ScalingField.i2mc                 C   s8   || j  | j }t|tƒr4| jd dkr4t|| jƒ}|S )Nr¡   rŽ  )r¦  r¨  rx   r  rq   rª  r©  r   rK   rK   rL   rˆ   z  s    z_ScalingField.m2ic                 C   sJ   t |ttfƒr0t | jt|ƒ¡d }|  ||¡}t |tt	fƒsFt
dƒ‚|S )Nr   zUnknown type)rx   rN   r   ru   r“   rq   r!   rˆ   r¨   r  ry   r   rK   rK   rL   r{   �  s    z_ScalingField.any2ic                 C   s   d|   ||¡| jf S )Nz%s %s)r‡   r§  r   rK   rK   rL   rŒ   Š  s    
þz_ScalingField.i2reprc                 C   s`   t  | ¡}|d ur\t|j| j | j | jƒ}t|j| j | j | jƒ}tt||ƒt||ƒƒS d S rH   )	ro   r©   rª  r6  r¦  r¨  r©  Úmaxr   )rJ   rf   Zmin_valZmax_valrK   rK   rL   r©   ‘  s    
ÿÿz_ScalingField.randvalN)rƒ   ra  r   rP  r¢   r"  rK   rK   rK   rL   r¥  ]  s        ù
	r¥  c                   @   s   e Zd ZdZdS )ÚScalingFielda   Handle physical values which are scaled and/or offset for communication

       Example:
           >>> from scapy.packet import Packet
           >>> class ScalingFieldTest(Packet):
                   fields_desc = [ScalingField('data', 0, scaling=0.1, offset=-1, unit='mV')]  # noqa: E501
           >>> ScalingFieldTest(data=10).show2()
           ###[ ScalingFieldTest ]###
             data= 10.0 mV
           >>> hexdump(ScalingFieldTest(data=10))
           0000  6E                                               n
           >>> hexdump(ScalingFieldTest(data=b"m"))
           0000  6D                                               m
           >>> ScalingFieldTest(data=b"m").show2()
           ###[ ScalingFieldTest ]###
             data= 9.9 mV

        bytes(ScalingFieldTest(...)) will produce 0x6E in this example.
        0x6E is 110 (decimal). This is calculated through the scaling factor
        and the offset. "data" was set to 10, which means, we want to transfer
        the physical value 10 mV. To calculate the value, which has to be
        sent on the bus, the offset has to subtracted and the scaling has to be
        applied by division through the scaling factor.
        bytes = (data - offset) / scaling
        bytes = ( 10  -  (-1) ) /    0.1
        bytes =  110 = 0x6E

        If you want to force a certain internal value, you can assign a byte-
        string to the field (data=b"m"). If a string of a bytes object is
        given to the field, no internal value conversion will be applied

       :param name: field's name
       :param default: default value for the field
       :param scaling: scaling factor for the internal value conversion
       :param unit: string for the unit representation of the internal value
       :param offset: value to offset the internal value during conversion
       :param ndigits: number of fractional digits for the internal conversion
       :param fmt: struct.pack format used to parse and serialize the internal value from and to machine representation # noqa: E501
       NrØ  rK   rK   rK   rL   r¬  �  s   r¬  c                   @   s   e Zd ZdZdd„ ZdS )ÚBitScalingFieldz+
    A ScalingField that is a BitField
    c                 O   s0   t j| ||g|¢R i |¤Ž t | |||¡ d S rH   )r¥  rM   r  )rJ   rp   rr   r÷  r]   r  rK   rK   rL   rM   Í  s    zBitScalingField.__init__N)rV   rW   rX   rY   rM   rK   rK   rK   rL   r­  È  s   r­  c                   @   s   e Zd ZdZdd„ ZdS )ÚOUIFieldz3
    A field designed to carry a OUI (3 bytes)
    c                 C   sV   t  d|pd¡dd … }t|d ƒd d… }tjrRtj |¡}||krRd||f S |S )NrL  r   rƒ   s      rú  r   )ru   r�   r(   r   r!  Z
_get_manuf)rJ   r€   rI   Zby_valZouiÚfancyrK   rK   rL   rŒ   Ø  s    zOUIField.i2reprN)rV   rW   rX   rY   rŒ   rK   rK   rK   rL   r®  Ó  s   r®  c                   @   sd   e Zd ZdZdgZdZdZdZeeefZefdd„Z	dd	„ Z
d
d„ Zdd„ Zdd„ Zedd„ ƒZdS )Ú	UUIDFielda±  Field for UUID storage, wrapping Python's uuid.UUID type.

    The internal storage format of this field is ``uuid.UUID`` from the Python
    standard library.

    There are three formats (``uuid_fmt``) for this field type:

    * ``FORMAT_BE`` (default): the UUID is six fields in big-endian byte order,
      per RFC 4122.

      This format is used by DHCPv6 (RFC 6355) and most network protocols.

    * ``FORMAT_LE``: the UUID is six fields, with ``time_low``, ``time_mid``
      and ``time_high_version`` in little-endian byte order. This *doesn't*
      change the arrangement of the fields from RFC 4122.

      This format is used by Microsoft's COM/OLE libraries.

    * ``FORMAT_REV``: the UUID is a single 128-bit integer in little-endian
      byte order. This *changes the arrangement* of the fields.

      This format is used by Bluetooth Low Energy.

    Note: You should use the constants here.

    The "human encoding" of this field supports a number of different input
    formats, and wraps Python's ``uuid.UUID`` library appropriately:

    * Given a bytearray, bytes or str of 16 bytes, this class decodes UUIDs in
      wire format.

    * Given a bytearray, bytes or str of other lengths, this delegates to
      ``uuid.UUID`` the Python standard library. This supports a number of
      different encoding options -- see the Python standard library
      documentation for more details.

    * Given an int or long, presumed to be a 128-bit integer to pass to
      ``uuid.UUID``.

    * Given a tuple:

      * Tuples of 11 integers are treated as having the last 6 integers forming
        the ``node`` field, and are merged before being passed as a tuple of 6
        integers to ``uuid.UUID``.

      * Otherwise, the tuple is passed as the ``fields`` parameter to
        ``uuid.UUID`` directly without modification.

        ``uuid.UUID`` expects a tuple of 6 integers.

    Other types (such as ``uuid.UUID``) are passed through.
    Úuuid_fmtr   rƒ   rk  c                 C   s"   || _ |  ¡  t | ||d¡ d S r;  )r±  Ú_check_uuid_fmtro   rM   )rJ   rp   rr   r±  rK   rK   rL   rM   "  s    zUUIDField.__init__c                 C   s    | j tjvrtd | j ¡ƒ‚dS )z=Checks .uuid_fmt, and raises an exception if it is not valid.zUnsupported uuid_fmt ({})N)r±  r°  ÚFORMATSre  rp  rO   rK   rK   rL   r²  (  s    
ÿzUUIDField._check_uuid_fmtc                 C   s`   |   ¡  |d u rdS | jtjkr&|jS | jtjkr8|jS | jtjkrT|jd d d… S tdƒ‚d S )Ns                   r¡   úUnknown fmt)	r²  r±  r°  Ú	FORMAT_BEr   Ú	FORMAT_LEÚbytes_leÚ
FORMAT_REVrg  r   rK   rK   rL   r‰   /  s    zUUIDField.i2mc                 C   s`   |   ¡  | jtjkrt|d�S | jtjkr4t|d�S | jtjkrTt|d d d… d�S tdƒ‚d S )N)r   )r·  r¡   r´  )r²  r±  r°  rµ  r   r¶  r¸  rg  r   rK   rK   rL   rˆ   =  s    

zUUIDField.m2ic                 C   sì   t |tƒrt|ƒ}t |tƒr(t|d�}nÀt |tƒr�t|ƒdkr„d}|dd … D ]}|d> |B }qN|d |d |d |d |d	 |f}t|d
�}nXt |ttfƒrÊt|ƒdkr¼|  	|t|ƒ¡}qètt
|ƒƒ}nt |ttfƒrätt|ƒ}nd S |S )Nrô  é   r   é   rú  rƒ   rk  rP  rM  )Úfieldsr|  )rx   Ú	bytearrayr!   r¨   r   rÑ   rS   rN   r   rˆ   r   r   rC   )rJ   r€   r�   ÚuÚnoderš   rK   rK   rL   r{   L  s&    


$zUUIDField.any2ic                   C   s   t ƒ S rH   )r   rK   rK   rK   rL   r©   o  s    zUUIDField.randvalN)rV   rW   rX   rY   rª   rµ  r¶  r¸  r³  rM   r²  r‰   rˆ   r{   Ústaticmethodr©   rK   rK   rK   rL   r°  ã  s   5
#r°  c                   @   s,   e Zd ZejZd	dd„Zdd„ Zdd„ ZdS )
ÚUUIDEnumFieldr   c                 C   s(   t  | |||d¡ tj| |||d� d S )Nr<  )r±  )r  rM   r°  )rJ   rp   rr   rž  r±  rK   rK   rL   rM   x  s    zUUIDEnumField.__init__c                 C   s   t  | ||¡S rH   r  r   rK   rK   rL   r{   }  s    zUUIDEnumField.any2ic                 C   s   t  | ||¡S rH   r   r   rK   rK   rL   rŒ   �  s    zUUIDEnumField.i2reprN)r   r!  rK   rK   rK   rL   rÀ  u  s   
rÀ  c                   @   sX   e Zd ZdZdgZd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S )ÚBitExtendedFielda³  
    Bit Extended Field

    This type of field has a variable number of bytes. Each byte is defined
    as follows:
    - 7 bits of data
    - 1 bit an an extension bit:

      + 0 means it is last byte of the field ("stopping bit")
      + 1 means there is another byte after this one ("forwarding bit")

    To get the actual data, it is necessary to hop the binary data byte per
    byte and to check the extension bit until 0
    Úextension_bitc                 C   sZ   t |ƒ}|d| j @ | j? }|d| j d @ }|| jd ? }|| jd > |d>  | }|S rU  )r¨   rÂ  )rJ   r�   Zfx_bitZlsb_bitsZmsb_bitsrK   rK   rL   Úprepare_byte›  s    zBitExtendedField.prepare_byterG   c                 C   sx   d}d }d}t |ƒD ]J}|  |¡}|d> t|ƒd? B }t|ƒd@ sV||d d … } q`|d }q|d u rldS ||fS d S )Nr   é   rƒ   )rG   N)r¼  rÃ  r¨   )rJ   r�   ÚbitsÚendrš   rÀ  rK   rK   rL   Ústr2extended¥  s    

zBitExtendedField.str2extendedc                 C   sæ   |d u rdS t |ƒ}g }d}d}d}d}|dks4|r¬|dkrTd}| |¡ d}d}q(|d | jkrŠ|rx|d|> B }d}n|d|> B }d}n||d@ |> B }|d? }|d }q(| |¡ d ¡ }|d d d… D ]}|t d	|¡ }qÌ|S )
NrG   Tr   rú  Frƒ   ra  r¡   z>B)r¨   ra   rÂ  r™  ru   r�   )rJ   r�   r�   ZLSByteZ
FX_MissingrÅ  rš   ÚresultrK   rK   rL   Úextended2strÀ  s8    


zBitExtendedField.extended2strc                 C   s   t  | ||d¡ || _d S rF  )ro   rM   rÂ  )rJ   rp   rr   rÂ  rK   rK   rL   rM   æ  s    zBitExtendedField.__init__c                 C   s
   |   |¡S rH   )rÉ  r   rK   rK   rL   r‰   ë  s    zBitExtendedField.i2mc                 C   s   |   |¡d S r¾  ©rÇ  r   rK   rK   rL   rˆ   ï  s    zBitExtendedField.m2ic                 C   s   ||   ||¡ S rH   r“  rÈ   rK   rK   rL   r‘   ó  s    zBitExtendedField.addfieldc                 C   s
   |   |¡S rH   rÊ  r”   rK   rK   rL   r•   ÷  s    zBitExtendedField.getfieldN)rG   )rV   rW   rX   rY   rª   rÃ  rÇ  rÉ  rM   r‰   rˆ   r‘   r•   rK   rK   rK   rL   rÁ  ‰  s   

&rÁ  c                   @   s   e Zd Zdd„ ZdS )ÚLSBExtendedFieldc                 C   s   t j| ||dd� d S )Nr   ©rÂ  ©rÁ  rM   r
  rK   rK   rL   rM   þ  s    zLSBExtendedField.__init__NrG  rK   rK   rK   rL   rË  ü  s   rË  c                   @   s   e Zd Zdd„ ZdS )ÚMSBExtendedFieldc                 C   s   t j| ||dd� d S )NrÄ  rÌ  rÍ  r
  rK   rK   rL   rM     s    zMSBExtendedField.__init__NrG  rK   rK   rK   rL   rÎ    s   rÎ  )êrY   Ú
__future__r   rš  Úcollectionsr–   rÖ   rk  r(  ru   rŸ  rÎ   Útypesr   Úuuidr   Zscapy.configr   Zscapy.dadictr   Zscapy.volatiler   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Z
scapy.datar   Zscapy.errorr   r   Zscapy.compatr   r   r   r   r    r!   Zscapy.pton_ntopr"   r#   Zscapy.utilsr$   r%   r&   r'   r(   r)   Zscapy.utils6r*   r+   r,   r-   r.   r/   Zscapy.base_classesr0   r1   r2   r3   r4   Zscapy.libs.sixZlibsrú   r5   rž  r6   ÚImportErrorr7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   r²  rE   rF   r¨   rN   rZ   rm   rn   Úadd_metaclassro   Úobjectr®   ZAnyFieldrµ   r¾   rÃ   rÉ   rß   rì   r   rï   rü   r  r  r  r#  r/  r:  rB  rD  rE  rH  rJ  rK  rS  rU  rW  rX  r^  rd  re  rg  rh  ru  rw  rx  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Ó  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-  r.  r/  r4  r5  r6  r9  r:  r;  r<  rD  ri  Ú
namedtuplerq  rt  rz  r€  r�  r�  r‘  r£  r¥  r¬  r­  r®  r°  rÀ  rÁ  rË  rÎ  rK   rK   rK   rL   Ú<module>   sZ  P   
@"# %
7 /'-' :&$7"(r21 `. " Q%" $y&+ÿ " b\ (Y<@ÿ+ "s