Current File : //usr/lib/python2.7/site-packages/salt/utils/win_reg.pyo
�
���^c @@ s� d Z d d l m Z m Z m Z d d l Z d d l Z d d l m Z y: d d l Z d d l
Z
d d l Z d d l Z e
Z Wn e k
r� e Z n Xd d l Z d d l Z d d l m Z d d l m Z e j d d k Z e j e � Z d Z d � Z d
� Z d � Z d e! f d
� � YZ" e d � Z# e d � Z$ d � Z% d e d � Z' d e e
d � Z( d e d � Z) d d d e e d � Z* d d d � Z+ e d � Z, d e d � Z- d S( uP
Manage the Windows registry
-----
Hives
-----
Hives are the main sections of the registry and all begin with the word HKEY.
- HKEY_LOCAL_MACHINE
- HKEY_CURRENT_USER
- HKEY_USER
----
Keys
----
Keys are the folders in the registry. Keys can have many nested subkeys. Keys
can have a value assigned to them under the (Default) value name
-----------------
Values or Entries
-----------------
Values/Entries are name/data pairs. There can be many values in a key. The
(Default) value corresponds to the Key itself, the rest are their own name/value
pairs.
:depends: - PyWin32
i ( t absolute_importt print_functiont unicode_literalsN( t range( t CommandExecutionError( t sixi u regc C@ s0 t j j j � s t d f St s, t d f St S( u8
Only works on Windows systems with the PyWin32
uP reg execution module failed to load: The module will only run on Windows systemsun reg execution module failed to load: One of the following libraries did not load: win32gui, win32con, win32api( t saltt utilst platformt
is_windowst Falset HAS_WINDOWS_MODULESt __virtualname__( ( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt __virtual__< s
c C@ s t j j j | d � S( ut
Converts unicode to to current users character encoding. Use this for values
returned by reg functions
u mbcs( R R t stringutilst
to_unicode( t vdata( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt _to_mbcsL s c C@ s& | d k r d St j j j | d � S( u|
Converts from current users character encoding to unicode. Use this for
parameters being pass to reg functions
u utf-8N( t NoneR R R R ( R ( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt _to_unicodeT s t Registryc B@ s e Z d Z d � Z d � Z RS( u�
This was put in a class to delay usage until this module is actually used
This class contains all the lookup dicts for working with the registry
c C@ s� i
t j d 6t j d 6t j d 6t j d 6t j d 6t j d 6t j d 6t j d 6t j d 6t j d
6| _ i t j d 6t j d 6t j d
6t j
d 6t j d 6t j d 6| _
i d d 6d d 6| _ i d t j 6d t j 6d
t j 6d t j
6d t j 6d t j 6| _ i d d 6d d 6| _ i d t j 6d t j 6d t j 6d t j 6d t j 6| _ i t j t j Bt 6t j t 6| _ d S( Nu HKEY_CURRENT_CONFIGu HKEY_CLASSES_ROOTu HKEY_CURRENT_USERu HKEY_LOCAL_MACHINEu
HKEY_USERSu HKCCu HKCRu HKCUu HKLMu HKUu
REG_BINARYu REG_DWORDu
REG_EXPAND_SZu REG_MULTI_SZu REG_SZu REG_QWORDi u REG_OPTION_NON_VOLATILEi u REG_OPTION_VOLATILE( t win32cont HKEY_CURRENT_CONFIGt HKEY_CLASSES_ROOTt HKEY_CURRENT_USERt HKEY_LOCAL_MACHINEt
HKEY_USERSt hkeyst
REG_BINARYt REG_DWORDt
REG_EXPAND_SZt REG_MULTI_SZt REG_SZt REG_QWORDt vtypet opttypet
vtype_reverset opttype_reverset subkey_slash_checkt KEY_READt KEY_WOW64_32KEYt TrueR
t registry_32( t self( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt __init__d sP
c C@ sW y | j | SWnA t k
rR d } d j | j � } t | j | | � � � n Xd S( Nu# No hkey named '{0}. Try one of {1}'u , ( R t KeyErrort joinR t format( R+ t kt msgR ( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt __getattr__� s
( t __name__t
__module__t __doc__R, R2 ( ( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyR _ s 5c
C@ s� t | � } t | � } t � } y | j | } Wn& t k
rZ t d j | � � � n X| j | } d } zS y t j | | d | � } t
SWn, t j k
r� } | j
d k r� t S� n XWd | r� t j | � n Xd S( u
Check that the key is found in the registry. This refers to keys and not
value/data pairs. To check value/data pairs, use ``value_exists``
Args:
hive (str): The hive to connect to
key (str): The key to check
use_32bit_registry (bool): Look in the 32bit portion of the registry
Returns:
bool: True if exists, otherwise False
Usage:
.. code-block:: python
import salt.utils.win_reg
winreg.key_exists(hive='HKLM', key='SOFTWARE\Microsoft')
u Invalid Hive: {0}i i N( R R R R- R R/ R* R t win32apit RegOpenKeyExR) t
pywintypest errort winerrorR
t RegCloseKey(
t hivet keyt use_32bit_registryt
local_hivet local_keyt registryt hkeyt access_maskt handlet exc( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt
key_exists� s&
c
C@ s4 t | � } t | � } t | � } t � } y | j | } Wn& t k
rf t d j | � � � n X| j | } y t j | | d | � }
Wn, t j
k
r� } | j d k r� t S� n Xz` y t j
|
| � \ } } t SWn9 t j
k
r } | j d k r| d k rt St Sn XWd t j |
� Xd S( u*
Check that the value/data pair is found in the registry.
.. version-added:: 2018.3.4
Args:
hive (str): The hive to connect to
key (str): The key to check in
vname (str): The name of the value/data pair you're checking
use_32bit_registry (bool): Look in the 32bit portion of the registry
Returns:
bool: True if exists, otherwise False
Usage:
.. code-block:: python
import salt.utils.win_reg
winreg.key_exists(hive='HKLM', key='SOFTWARE\Microsoft')
u Invalid Hive: {0}i i N( R R R R- R R/ R* R6 R7 R8 R9 R: R
t RegQueryValueExR) R R; (
R< R= t vnameR> R? R@ t local_vnameRA RB RC RD RE t _( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt value_exists� s0
c C@ s8 t j t j t j d d t j d � \ } } t | � S( uo
Refresh the windows environment.
.. note::
This will only effect new processes and windows. Services will not see
the change until the system restarts.
Returns:
bool: True if successful, otherwise False
Usage:
.. code-block:: python
import salt.utils.win_reg
winreg.broadcast_change()
i i� ( t win32guit SendMessageTimeoutR t HWND_BROADCASTt WM_SETTINGCHANGEt SMTO_ABORTIFHUNGt bool( RJ t res( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt broadcast_change
s c C@ sN t | � } t | � } t � } y | j | } Wn& t k
rZ t d j | � � � n X| j | } g } d } z� y{ t j | | d | � } x\ t
t j | � d � D]A }
t j | |
� } t
r� | j t | � � q� | j | � q� WWn= t k
r1t j d | | d t �t d j | | � f SXWd | rI| j � n X| S( u�
Enumerates the subkeys in a registry key or hive.
Args:
hive (str):
The name of the hive. Can be one of the following:
- HKEY_LOCAL_MACHINE or HKLM
- HKEY_CURRENT_USER or HKCU
- HKEY_USERS or HKU
- HKEY_CLASSES_ROOT or HKCR
- HKEY_CURRENT_CONFIG or HKCC
key (str):
The key (looks like a path) to the value name. If a key is not
passed, the keys under the hive will be returned.
use_32bit_registry (bool):
Accesses the 32bit portion of the registry on 64 bit installations.
On 32bit machines this is ignored.
Returns:
list: A list of keys/subkeys under the hive or key.
Usage:
.. code-block:: python
import salt.utils.win_reg
winreg.list_keys(hive='HKLM', key='SOFTWARE\Microsoft')
u Invalid Hive: {0}i u Cannot find key: %s\%st exc_infou Cannot find key: {0}\{1}N( R R R R- R R/ R* R R6 R7 R t RegQueryInfoKeyt
RegEnumKeyt PY2t appendR t Exceptiont logt debugR) R
t Close( R< R= R> R? R@ RA RB RC t subkeysRD t it subkey( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt list_keys& s0 "
c C@ s� t | � } t | � } t � } y | j | } Wn& t k
rZ t d j | � � � n X| j | } d } t � }
z]yt j
| | d | � } x� t t j | � d � D]� } t j
| | � \ } }
} | s� d } n i | d 6| d 6t | � d 6| j | d 6t d 6} | t j k rJg |
D] } t | � ^ q+| d
<n5 | t j t j g k rut |
� | d
<n
|
| d
<|
j | � q� WWn? t k
r�} t j d | | d t �t d
j | | � f SXWd | r�| j � n X|
S( u
Enumerates the values in a registry key or hive.
Args:
hive (str):
The name of the hive. Can be one of the following:
- HKEY_LOCAL_MACHINE or HKLM
- HKEY_CURRENT_USER or HKCU
- HKEY_USER or HKU
- HKEY_CLASSES_ROOT or HKCR
- HKEY_CURRENT_CONFIG or HKCC
key (str):
The key (looks like a path) to the value name. If a key is not
passed, the values under the hive will be returned.
use_32bit_registry (bool):
Accesses the 32bit portion of the registry on 64 bit installations.
On 32bit machines this is ignored.
include_default (bool):
Toggle whether to include the '(Default)' value.
Returns:
list: A list of values under the hive or key.
Usage:
.. code-block:: python
import salt.utils.win_reg
winreg.list_values(hive='HKLM', key='SYSTEM\CurrentControlSet\Services\Tcpip')
u Invalid Hive: {0}i i u (Default)u hiveu keyu vnameu vtypeu successu vdatau Cannot find key: %s\%sRT u Cannot find key: {0}\{1}N( R R R R- R R/ R* R t listR6 R7 R RU t RegEnumValueR R$ R) R R R R RX RY RZ R[ R
R\ ( R< R= R> t include_defaultR? R@ RA RB RC RD t valuesR^ RH R R" t valueRE ( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt list_valuesh sD $
&
c C@ sg t | � } t | � } t | � } i | d 6| d 6| d 6d d 6t d 6} | s` d | d <n t � } y | j | } Wn& t k
r� t d j | � � � n X| j | }
y]t j
| | d |
� } y� t j | | � \ } }
| s� | d k rv| j |
| d
<|
t
j k r>g | D] } t | � ^ q | d <q�|
t
j t
j g k rit | � | d <q�| | d <n
d | d <Wn� t k
r } | j d
k r�| d k r�d | d <d | d
<q d j | | | � } t j | � t j | � | | d <t | d <n XWnS t k
rb} d j | | � } t j | � t j | � | | d <t | d <n X| S( u�
Reads a registry value entry or the default value for a key. To read the
default value, don't pass ``vname``
Args:
hive (str): The name of the hive. Can be one of the following:
- HKEY_LOCAL_MACHINE or HKLM
- HKEY_CURRENT_USER or HKCU
- HKEY_USER or HKU
- HKEY_CLASSES_ROOT or HKCR
- HKEY_CURRENT_CONFIG or HKCC
key (str):
The key (looks like a path) to the value name.
vname (str):
The value name. These are the individual name/data pairs under the
key. If not passed, the key (Default) value will be returned.
use_32bit_registry (bool):
Accesses the 32bit portion of the registry on 64bit installations.
On 32bit machines this is ignored.
Returns:
dict: A dictionary containing the passed settings as well as the
value_data if successful. If unsuccessful, sets success to False.
bool: Returns False if the key is not found
If vname is not passed:
- Returns the first unnamed value (Default) as a string.
- Returns none if first unnamed value is empty.
Usage:
The following will get the value of the ``version`` value name in the
``HKEY_LOCAL_MACHINE\\SOFTWARE\\Salt`` key
.. code-block:: python
import salt.utils.win_reg
winreg.read_value(hive='HKLM', key='SOFTWARE\\Salt', vname='version')
Usage:
The following will get the default value of the
``HKEY_LOCAL_MACHINE\\SOFTWARE\\Salt`` key
.. code-block:: python
import salt.utils.win_reg
winreg.read_value(hive='HKLM', key='SOFTWARE\\Salt')
u hiveu keyu vnameu vdatau successu (Default)u Invalid Hive: {0}i u u vtypeu Empty Valueu commenti u (value not set)u REG_SZu Cannot find {0} in {1}\{2}u Cannot find key: {0}\{1}N( i u ( R R R) R R R- R R/ R* R6 R7 RG R$ R R R R R RY R: RZ t traceR
( R< R= RH R> R? R@ RI t retRA RB RC RD R R" R^ RE R1 ( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt
read_value� sZ =
&
u REG_SZc C@ s{ t | � } t | � } t | � } t | � }
t � } y | j | } Wn& t k
rr t d j | � � � n X| j |
}
| j | t j B} t
d | d |
� } | r� | j d } n
| j d } d } z� yV t
j | | | d | �\ } } t
j | | d |
| � t
j | � t � t SWn. t
j t t t f k
r[t j d � t SXWd | rvt
j | � n Xd S(
u
Sets a value in the registry. If ``vname`` is passed, it will be the value
for that value name, otherwise it will be the default value for the
specified key
Args:
hive (str):
The name of the hive. Can be one of the following
- HKEY_LOCAL_MACHINE or HKLM
- HKEY_CURRENT_USER or HKCU
- HKEY_USER or HKU
- HKEY_CLASSES_ROOT or HKCR
- HKEY_CURRENT_CONFIG or HKCC
key (str):
The key (looks like a path) to the value name.
vname (str):
The value name. These are the individual name/data pairs under the
key. If not passed, the key (Default) value will be set.
vdata (str, int, list, bytes):
The value you'd like to set. If a value name (vname) is passed, this
will be the data for that value name. If not, this will be the
(Default) value for the key.
The type of data this parameter expects is determined by the value
type specified in ``vtype``. The correspondence is as follows:
- REG_BINARY: Binary data (str in Py2, bytes in Py3)
- REG_DWORD: int
- REG_EXPAND_SZ: str
- REG_MULTI_SZ: list of str
- REG_QWORD: int
- REG_SZ: str
.. note::
When setting REG_BINARY, string data will be converted to
binary. You can pass base64 encoded using the ``binascii``
built-in module. Use ``binascii.b2a_base64('your data')``
.. note::
The type for the (Default) value is always REG_SZ and cannot be
changed.
.. note::
This parameter is optional. If not passed, the Key will be
created with no associated item/value pairs.
vtype (str):
The value type. The possible values of the vtype parameter are
indicated above in the description of the vdata parameter.
use_32bit_registry (bool):
Sets the 32bit portion of the registry on 64bit installations. On
32bit machines this is ignored.
volatile (bool):
When this parameter has a value of True, the registry key will be
made volatile (i.e. it will not persist beyond a system reset or
shutdown). This parameter only has an effect when a key is being
created and at no other time.
Returns:
bool: True if successful, otherwise False
Usage:
This will set the version value to 2015.5.2 in the SOFTWARE\Salt key in
the HKEY_LOCAL_MACHINE hive
.. code-block:: python
import salt.utils.win_reg
winreg.set_value(hive='HKLM', key='SOFTWARE\Salt', vname='version', vdata='2015.5.2')
Usage:
This function is strict about the type of vdata. For instance this
example will fail because vtype has a value of REG_SZ and vdata has a
type of int (as opposed to str as expected).
.. code-block:: python
import salt.utils.win_reg
winreg.set_value(hive='HKLM', key='SOFTWARE\Salt', vname='str_data', vdata=1.2)
Usage:
In this next example vdata is properly quoted and should succeed.
.. code-block:: python
import salt.utils.win_reg
winreg.set_value(hive='HKLM', key='SOFTWARE\Salt', vname='str_data', vdata='1.2')
Usage:
This is an example of using vtype REG_BINARY. Both ``set_value``
commands will set the same value ``Salty Test``
.. code-block:: python
import salt.utils.win_reg
winreg.set_value(hive='HKLM', key='SOFTWARE\Salt', vname='bin_data', vdata='Salty Test', vtype='REG_BINARY')
import binascii
bin_data = binascii.b2a_base64('Salty Test')
winreg.set_value(hive='HKLM', key='SOFTWARE\Salt', vname='bin_data_encoded', vdata=bin_data, vtype='REG_BINARY')
Usage:
An example using vtype REG_MULTI_SZ is as follows:
.. code-block:: python
import salt.utils.win_reg
winreg.set_value(hive='HKLM', key='SOFTWARE\Salt', vname='list_data', vdata=['Salt', 'is', 'great'], vtype='REG_MULTI_SZ')
u Invalid Hive: {0}R R" u REG_OPTION_VOLATILEu REG_OPTION_NON_VOLATILEt Optionsi u( Encountered error setting registry valueN( R R R R- R R/ R" R* R t KEY_ALL_ACCESSt
cast_vdataR# R R6 t RegCreateKeyExt
RegSetValueExt RegFlushKeyRS R) R9 t SystemErrort
ValueErrort TypeErrorRZ t exceptionR
R; ( R< R= RH R R" R> t volatileR? R@ RI t local_vtypeRA RB t vtype_valueRC t local_vdatat create_optionsRD RJ ( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt set_value, s: �
c C@ s� t � } | j | } | t j t j g k r8 t | � S| t j k rj t | t j � rf | j
d � S| S| t j k r� g | D] } t | � ^ q� S| t j k r� t j
r� | St | � St | � Sd S( u
Cast the ``vdata` value to the appropriate data type for the registry type
specified in ``vtype``
Args:
vdata (str, int, list, bytes): The data to cast
vtype (str):
The type of data to be written to the registry. Must be one of the
following:
- REG_BINARY
- REG_DWORD
- REG_EXPAND_SZ
- REG_MULTI_SZ
- REG_QWORD
- REG_SZ
Returns:
The vdata cast to the appropriate type. Will be unicode string, binary,
list of unicode strings, or int
Usage:
.. code-block:: python
import salt.utils.win_reg
winreg.cast_vdata(vdata='This is the string', vtype='REG_SZ')
u utf-8N( R R" R R R R R t
isinstanceR t text_typet encodeR R! t PY3t longt int( R R" RA Rv R^ ( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyRl � s #
c
@ s� t | � } t | � } t � } y | j | } Wn& t k
rZ t d j | � � � n X| } | j | t j B� t | | | � s� t
St | � d k r� | j d d � | j
| k r� t j d | | � t
Sd � � � � � f d � � g } � | | | � � } | j | � i g d 6g d 6} x� | D]� }
yI t j | |
d � � } t j | d
� | d j d j | |
� � Wq4t k
r�} t j | d t �| d j d
j | |
| � � q4Xq4Wt � | S( uJ
.. versionadded:: 2015.5.4
Delete a registry key to include all subkeys and value/data pairs.
Args:
hive (str):
The name of the hive. Can be one of the following
- HKEY_LOCAL_MACHINE or HKLM
- HKEY_CURRENT_USER or HKCU
- HKEY_USER or HKU
- HKEY_CLASSES_ROOT or HKCR
- HKEY_CURRENT_CONFIG or HKCC
key (str):
The key to remove (looks like a path)
use_32bit_registry (bool):
Deletes the 32bit portion of the registry on 64bit
installations. On 32bit machines this is ignored.
Returns:
dict: A dictionary listing the keys that deleted successfully as well as
those that failed to delete.
Usage:
The following example will remove ``salt`` and all its subkeys from the
``SOFTWARE`` key in ``HKEY_LOCAL_MACHINE``:
.. code-block:: python
import salt.utils.win_reg
winreg.delete_key_recursive(hive='HKLM', key='SOFTWARE\DeleteMe')
u Invalid Hive: {0}i u \u< Hive:%s Key:%s; key is too close to root, not safe to removec s@ sW d } xJ t rR y+ t j | | � } t | � V| d 7} Wq t k
rN Pq Xq Wd S( u
Enumerate keys
i i N( R) R6 RV R RY ( t _keyR^ R_ ( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt _subkeysH s
c @ sg t j | | d | � } xH � | � D]: } d j | | � } � | | | � � } | j | � q% W| S( uD
Traverse the registry tree i.e. dive into the tree
i u {0}\{1}( R6 R7 R/ RX ( t _hkeyt _keypatht _rett _access_maskR� t
subkeynamet
subkeypath( R� t _traverse_registry_treeRC ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyR� U s u Deletedu Failedi u u {0}\{1}RT u {0}\{1} {2}( R R R R- R R/ R* R Rk RF R
t lent countR& RZ R9 RX R6 R7 t RegDeleteKeyt WindowsErrorR) RS (
R< R= R> R? R@ RA RB t key_patht key_listRh t sub_key_patht
key_handleRE ( ( R� R� RC s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt delete_key_recursive
sB '
1
!(c C@ sZ t | � } t | � } t | � } t � } y | j | } Wn& t k
rf t d j | � � � n X| j | t j B} d }
z� y7 t
j | | d | � }
t
j |
| � t
� t SWn} t k
r:} | j d k r� d St j | d t �t j d | � t j d | � t j d | � t j d | � t Sn XWd |
rUt
j |
� n Xd S(
u
Delete a registry value entry or the default value for a key.
Args:
hive (str):
The name of the hive. Can be one of the following
- HKEY_LOCAL_MACHINE or HKLM
- HKEY_CURRENT_USER or HKCU
- HKEY_USER or HKU
- HKEY_CLASSES_ROOT or HKCR
- HKEY_CURRENT_CONFIG or HKCC
key (str):
The key (looks like a path) to the value name.
vname (str):
The value name. These are the individual name/data pairs under the
key. If not passed, the key (Default) value will be deleted.
use_32bit_registry (bool):
Deletes the 32bit portion of the registry on 64bit installations. On
32bit machines this is ignored.
Return:
bool: True if successful, otherwise False
Usage:
.. code-block:: python
import salt.utils.win_reg
winreg.delete_value(hive='HKLM', key='SOFTWARE\SaltTest', vname='version')
u Invalid Hive: {0}i i RT u Hive: %su Key: %su
ValueName: %su
32bit Reg: %sN( R R R R- R R/ R* R Rk R R6 R7 t RegDeleteValueRS R) RY R: RZ R9 R
R; ( R< R= RH R> R? R@ RI RA RB RC RD RE ( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt delete_valuex s6 $
(. R5 t
__future__R R R t syst loggingt salt.ext.six.movesR RL R6 R R8 R) R t ImportErrorR
t salt.utils.platformR t salt.utils.stringutilst salt.exceptionsR t salt.extR t version_infoRW t getLoggerR3 RZ R R
R R t objectR RF RK RS R R` Rf Ri Ry Rl R� R� ( ( ( s6 /usr/lib/python2.7/site-packages/salt/utils/win_reg.pyt <module> sJ
C . = BOw �: n
Mini Shell