
    *1f6                        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mZmZm	Z	m
Z
mZmZmZmZ d dlmZmZmZmZ  ej(                  e      Z edej&                  j.                  ej0                  j2                  eeef         Z G d dej8                        Z G d dej0                  j<                        Zd	ej@                  jB                  d
ede"fdZ#y)    N)	AnyCallableDictIterableIteratorOptionalTupleTypeVarList)	constants
exceptions
interfacesobjectsSymbolSpaceReturnTypec                       e Zd ZdZdZdZy)
SymbolType         N)__name__
__module____qualname__TYPESYMBOLENUM     X/home/panchajanya/Development/work/volatility3/volatility3/framework/symbols/__init__.pyr   r   "   s    DFDr   r   c            
           e Zd ZdZd, fdZd-deddfdZd.dedefdZd	edee   fd
Z		 d/de
de
dedee   fdZde
fdZdedefdZdee   fdZdej$                  j&                  ddfdZdeddfdZ	 d-dedeee   eej2                     gef   dee   defdZ G d dej<                  j>                        Z de!dede"fdZ#d Z$d	edej:                  jJ                  fd Z&d!edej$                  jN                  fd"Z(d#ej:                  jJ                  dej:                  jJ                  fd$Z)d%edej:                  jJ                  fd&Z*d'e!dedefd(Z+dedefd)Z,dedefd*Z-dedefd+Z. xZ/S )0SymbolSpacezHandles an ordered collection of SymbolTables.

    This collection is ordered so that resolution of symbols can proceed
    down through the ranks if a namespace isn't specified.
    returnNc                 p    t         |           t        j                         | _        i | _        i | _        y N)super__init__collectionsOrderedDict_dict	_resolved_resolved_symbols)self	__class__s    r   r%   zSymbolSpace.__init__/   s4    ##% 	
 BDIKr   
table_namec                     t               }|$t        | j                  j                               }n|j                  | j                  |          |D ]  }|j	                           y)zClears the symbol cache for the specified table name. If no table
        name is specified, the caches of all symbol tables are cleared.N)listr(   valuesappendclear_symbol_cache)r+   r-   
table_listtables       r   r2   zSymbolSpace.clear_symbol_cache8   s\     IM
djj//12Jdjj45 	'E$$&	'r   prefixc                 n    d}|t        |      z   | v r|dz  }|t        |      z   | v r|t        |      z   S )zaReturns an unused table name to ensure no collision occurs when
        inserting a symbol table.r   )str)r+   r5   counts      r   free_table_namezSymbolSpace.free_table_nameC   sE     s5z!T)QJE s5z!T)E
""r   	type_namec              #      K   | j                   D ]=  }| j                   |   j                  |      D ]  }|t        j                  z   |z     ? yw)z4Returns all symbols based on the type of the symbol.N)r(   get_symbols_by_typer   BANG)r+   r:   r4   symbol_names       r   r<   zSymbolSpace.get_symbols_by_typeM   sP     ZZ 	;E#zz%0DDYO ;inn,{::;	;s   AAoffsetsizec              #     K   | j                   j                         }|!|| j                   v r| j                   |   g}ng }|D ]<  }|j                  ||      D ]$  }|j                  t        j
                  z   |z    & > yw)z>Returns all symbols that exist at a specific relative address.N)r?   r@   )r(   r0   get_symbols_by_locationnamer   r=   )r+   r?   r@   r-   r3   r4   r>   s          r   rB   z#SymbolSpace.get_symbols_by_locationS   s     
 JJ 	 !TZZ'"jj45

 	@E$<<FQU<V @jj9>>1K??@	@s   B Bc                 ,    t        | j                        S )z.Returns the number of tables within the space.)lenr(   r+   s    r   __len__zSymbolSpace.__len__e   s    4::r   ic                      | j                   |   S )z(Returns a specific table from the space.)r(   )r+   rH   s     r   __getitem__zSymbolSpace.__getitem__i   s    zz!}r   c                 ,    t        | j                        S )z:Iterates through all available tables in the symbol space.)iterr(   rF   s    r   __iter__zSymbolSpace.__iter__m   s    DJJr   valuec                     t        |t        j                  j                        st	        |      |j
                  | j                  v r| j                  |j
                         || j                  |j
                  <   y)z+Adds a symbol_list to the end of the space.N)
isinstancer   symbolsBaseSymbolTableInterface	TypeErrorrC   r(   remove)r+   rN   s     r   r1   zSymbolSpace.appendq   sU    %!3!3!L!LME""::#KK

#!&

5::r   keyc                 ,    i | _         | j                  |= y)z+Removes a named symbol_list from the space.N)r)   r(   )r+   rU   s     r   rT   zSymbolSpace.removey   s     JJsOr   producer	validatortablesc                    || j                   j                         }|D ]  }| j                   |   }|j                  st        j	                  d| d       8|j                  j
                  |k(  rM ||j                  j                  |j                  j                        rt        j	                  d| d        y y)a  Verifies the producer metadata and version of tables

        Args:
            producer: String name of a table producer to have validation performed
            validator: callable that takes an optional version and an optional datetime that returns False if table is invalid

        Returns:
            False if an invalid table was found or True if no invalid table was found
        zSymbol table z> could not be validated because no producer metadata was foundz does not pass validatorFT)r(   keysrW   vollogdebugrC   versiondatetime)r+   rW   rX   rY   r-   r4   s         r   verify_table_versionsz!SymbolSpace.verify_table_versions   s     >ZZ__&F  	JJJz*E>>#J</mn ~~""h. NN**NN++ LL=<T!UV !	" r   c                   ,     e Zd ZdZdeddf fdZ xZS )SymbolSpace.UnresolvedTemplatea  Class to highlight when missing symbols are present.

        This class is identical to a reference template, but differentiable by its classname.
        It will output a debug log to indicate when it has been instantiated and with what name.

        This class is designed to be output ONLY as part of the SymbolSpace resolution system.
        Individual SymbolTables that cannot resolve a symbol should still return a SymbolError to
        indicate this failure in resolution.
        r:   r!   Nc                 X    t         j                  d|        t        |   dd|i| y )NzUnresolved reference: r:   r   )r\   r]   r$   r%   )r+   r:   kwargsr,   s      r   r%   z'SymbolSpace.UnresolvedTemplate.__init__   s,    LL1)=>G;y;F;r   )r   r   r   __doc__r7   r%   __classcell__r,   s   @r   UnresolvedTemplaterb      s     		<c 	< 	< 	<r   rh   resolve_typerC   c           	         |t         j                  k(  rd}n7|t         j                  k(  rd}n!|t         j                  k(  rd}nt	        d      |j                  t        j                        }t        |      dk(  r*|d   }|d   }	  t        | j                  |   |      |      S t        j                  |d
d|       # t        $ r"}t        j                  ||d| d	|       d
}~ww xY w)z>Takes a symbol name and resolves it with ReferentialTemplates.get_type
get_symbolget_enumerationz/Weak_resolve called without a proper SymbolTyper   r   r   zType z& references missing Type/Symbol/Enum: NzMalformed name: )r   r   r   r   rS   splitr   r=   rE   getattrr(   KeyErrorr   SymbolError)r+   ri   rC   get_function
name_arrayr-   component_namees           r   _weak_resolvezSymbolSpace._weak_resolve   s     :??*%LZ...'LZ__,,LMNNZZ	/
z?a#AJ']NDwtzz*5|D^TT $$T43CD61JKK   ,,"D6!GsK s   B? ?	C*C%%C*c                    t               }|r1| j                  |d      g|dd }}|r|d   |dd }}|j                  D ]  }t        |t        j
                  j                        r|j                  j                  | j                  vr{|j                  |j                  j                         	 | j                  t        j                  |j                  j                        | j                  |j                  j                  <   |j!                  ||f       |j                  s|j                  |        |r|r1|D ]8  \  }}|j#                  || j                  |j                  j                            : y# t        j                  $ rI | j                  |j                  j                        | j                  |j                  j                  <   Y w xY w)zzIteratively resolves a type, populating linked child
        ReferenceTemplates with their properly resolved counterparts.r   r   N)setr)   childrenrP   r   	templatesReferenceTemplatevolr:   r1   rv   r   r   r   rq   rh   addreplace_child)r+   traverse_listreplacementstemplate_traverse_list	traverserchildparents          r   _iterative_resolvezSymbolSpace._iterative_resolve   s    u}Q/05QR  %2" )*1-*12. 2	 '// =E!%):):)L)LM !99..dnnD)001D1DE	"$($6$6(29L9L%& !%uyy/B/B C %(()U);<.55e<'= ) < * 	MMFE  uyy7J7J(KL	M $.#9#9 "$($;$;EII<O<O$P !%uyy/B/B C"s   .AE==AGGc                    || j                   vr?| j                  t        j                  |      | j                   |<   | j	                  |g       t        | j                   |   t        j                  j                        rMd}|j                  t        j                        }|dkD  r|d| ||dz   d }}t        j                  ||d|       | j                   |   S )zTakes a symbol name and resolves it.

        This method ensures that all referenced templates (including
        self-referential templates) are satisfied as ObjectTemplates
        Nr   r   zUnresolvable symbol requested: )r)   rv   r   r   r   rP   r   rz   r{   findr   r=   r   rq   )r+   r:   r-   indexs       r   rk   zSymbolSpace.get_type   s     DNN*(,(:(::??I(VDNN9%##YK0dnnY/1B1B1T1TUJNN9>>2Eqy(1&5(99UQY[;QI
((:)H'T  ~~i((r   r>   c                    | j                  t        j                  |      }|| j                  vr4|j                  (| j                  |j                        | j                  |<   t        |t        j                  j                        sMd}|j                  t        j                        }|dkD  r|d| ||dz   d }}t        j                  ||d|       |S )z=Look-up a symbol name across all the contained symbol spaces.Nr   r   zUnresolvable Symbol: )rv   r   r   r*   type_subresolverP   r   rQ   SymbolInterfacer   r   r=   r   rq   )r+   r>   retvalr-   r   s        r   rl   zSymbolSpace.get_symbol	  s    ##J$5$5{Cd4449P262B2B6;;2OD"";/&*"4"4"D"DEJ$$Y^^4Eqy*5fu*={5ST9;?WK
((Z+@)N  r   object_templatec                    |j                   D ]p  }t        |t        j                  j                        r&| j                  |j                  j                        }n| j                  |      }|j                  ||       r |S )z?Ensure an ObjectTemplate doesn't contain any ReferenceTemplates)	old_child	new_child)
ry   rP   r   rz   r{   rk   r|   r:   r   r~   )r+   r   r   r   s       r   r   zSymbolSpace._subresolve  st     %-- 	PE%!2!2!D!DE MM%))*=*=>	 ,,U3	))EY)O	P r   	enum_namec                 (   | j                  t        j                  |      }t        |t        j
                  j                        sMd}|j                  t        j                        }|dkD  r|d| ||dz   d }}t        j                  ||d|       |S )zJLook-up a set of enumeration choices from a specific symbol
        table.Nr   r   zUnresolvable Enumeration: )rv   r   r   rP   r   r   Templater   r   r=   r   rq   )r+   r   r   r-   r   s        r   rm   zSymbolSpace.get_enumeration$  s     ##JOOY?&*"4"4"="=>JNN9>>2Eqy(1&5(99UQY[;QI
((:)CI;'O  r   member_typec                 P   |j                  t        j                        }t        |      dk(  r|d   }|d   }ny|| vry| |   }|t        j
                  k(  r||j                  v S |t        j                  k(  r||j                  v S |t        j                  k(  r||j                  v S y)z2Test for membership of a component within a table.r   r   r   F)rn   r   r=   rE   r   r   typesr   rQ   r   enumerations)r+   r   rC   rs   r-   rt   r4   s          r   _membershipzSymbolSpace._membership2  s     ZZ	/
z?a#AJ']NT!Z *//)!U[[00J---!U]]22JOO+!U%7%777r   c                 B    | j                  t        j                  |      S r#   )r   r   r   r+   rC   s     r   has_typezSymbolSpace.has_typeH      
66r   c                 B    | j                  t        j                  |      S r#   )r   r   r   r   s     r   
has_symbolzSymbolSpace.has_symbolK  s    
 1 1488r   c                 B    | j                  t        j                  |      S r#   )r   r   r   r   s     r   has_enumerationzSymbolSpace.has_enumerationN  r   r   )r!   Nr#   )layer)r   N)0r   r   r   re   r%   r7   r2   r9   r   r<   intrB   rG   r   rJ   r   rM   r   rQ   rR   r1   rT   r   r   r	   r_   boolr   r`   r   rz   r{   rh   r   r   rv   r   r   rk   r   rl   r   rm   r   r   r   r   rf   rg   s   @r   r    r    (   sP   L	'S 	'D 	'#c # #;S ;Xc] ; =A@@!$@69@	#@$ S S  (3-  'J..GG 'D '# $  !	"" Xe_hx7H7H.IJDPQ" S		"
 
"L<W..@@ <L&L.1L	L6$ML)# )**<*<*E*E )(c j.@.@.P.P 
)11::
				$	$
 1C1C1L1L z   ,7S 7T 79s 9t 97C 7D 7r   r    contextsymbol_table_namer!   c                 z    | j                   j                  |t        j                  z   dz         j                  dk(  S )z`Returns a boolean as to whether a particular symbol table within a
    context is 64-bit or not.pointer   )symbol_spacerk   r   r=   r@   )r   r   s     r   symbol_table_is_64bitr   R  s;     	%%	.:	

$	r   )$r&   collections.abcr_   enumloggingtypingr   r   r   r   r   r   r	   r
   r   volatility3.frameworkr   r   r   r   	getLoggerr   r\   r   rQ   r   r7   r   Enumr   SymbolSpaceInterfacer    r   ContextInterfacer   r   r   r   r   <module>r      s   
     
 
 
 M L			8	$&&cN	  g7*$$99 g7T	
00
EH
	
r   