class x_mailslot_invalid_use(x_mailslot):
pass
class x_mailslot_empty(x_mailslot):
pass
class x_mailslot_message_too_big(x_mailslot):
pass
class x_mailslot_message_too_complex(x_mailslot):
pass
WINERROR_MAP = {
winerror.ERROR_FILE_NOT_FOUND : exc.x_not_found,
}
wrapped = exc.wrapper(WINERROR_MAP, x_ipc)
def _unserialised(data):
return data
class Mailslot(core._WinSysObject):
"""A mailslot is a mechanism for passing small datasets (up to about
400 bytes) between machines in the same network. For transport and
name resolution it uses NetBIOS so you can't, for example, use a
machine's IP address when specifying the location of a mailslot.
You can, however, use "*" in order to broadcast your message to
all listening machines.
A mailslot is either read-only or write-only. The typical case
is that one machine starts up a reading mailslot, say for trace
output, and all other machines write to that mailslot either by
PROPERTIES = {
FMTID.SummaryInformation: PIDSI,
FMTID.DocSummaryInformation: PIDDSI,
FMTID.MediaFileSummaryInformation: PIDMSI,
FMTID.AudioSummaryInformation: PIDASI,
FMTID.Volume: PID_VOLUME,
}
class x_shell(exc.x_winsys):
pass
WINERROR_MAP = {}
wrapped = exc.wrapper(WINERROR_MAP, x_shell)
#
# Although this can be done in one call, Win9x didn't
# support it, so I added this workaround.
#
def get_path(folder_id):
return shell.SHGetPathFromIDList(
shell.SHGetSpecialFolderLocation(0, folder_id))
def desktop(common=0):
u"What folder is equivalent to the current desktop?"
return get_path((shellcon.CSIDL_DESKTOP,
shellcon.CSIDL_COMMON_DESKTOPDIRECTORY)[common])
class x_mailslot_empty(x_mailslot):
pass
class x_mailslot_message_too_big(x_mailslot):
pass
class x_mailslot_message_too_complex(x_mailslot):
pass
WINERROR_MAP = {winerror.ERROR_FILE_NOT_FOUND: exc.x_not_found}
wrapped = exc.wrapper(WINERROR_MAP, x_ipc)
class Mailslot(core._WinSysObject):
ur"""A mailslot is a mechanism for passing small datasets (up to about
400 bytes) between machines in the same network. For transport and
name resolution it uses NetBIOS so you can't, for example, use a
machine's IP address when specifying the location of a mailslot.
You can, however, use "*" in order to broadcast your message to
all listening machines.
A mailslot is either read-only or write-only. The typical case
is that one machine starts up a reading mailslot, say for trace
output, and all other machines write to that mailslot either by
specifying the machine name directly or by broadcasting. This is
particularly convenient as the writing machines have no need to
import win32security
from winsys import accounts, constants, core, exc, utils
__all__ = ['LogonSession', 'LSA', 'x_lsa']
class x_lsa (exc.x_winsys):
"Base for all LSA-related exceptions"
WINERROR_MAP = {
}
wrapped = exc.wrapper (WINERROR_MAP, x_lsa)
def principal (account):
try:
return accounts.principal (account)
except exc.x_not_found:
return "<unknown>"
class LogonSession (core._WinSysObject):
_MAP = {
u"UserName" : principal,
u"Sid" : principal,
u"LogonTime" : utils.from_pytime
}
def __init__ (self, session_id):
core._WinSysObject.__init__ (self)
self._session_id = session_id
self._session_info = dict (session_id = self._session_id)
dict(EVENTLOG_SUCCESS=0,
AUDIT_FAILURE=win32evtlog.EVENTLOG_AUDIT_FAILURE,
AUDIT_SUCCESS=win32evtlog.EVENTLOG_AUDIT_SUCCESS))
EVENTLOG_TYPE.doc("Types of records in event logs")
PyHANDLE = pywintypes.HANDLEType
DEFAULT_LOG_NAME = "Application"
class x_event_logs(exc.x_winsys):
"Base exception for eventlog-specific exceptions"
WINERROR_MAP = {winerror.ERROR_ACCESS_DENIED: exc.x_access_denied}
wrapped = exc.wrapper(WINERROR_MAP)
class _EventLogEntry(core._WinSysObject):
"""Internal class for convenient access to attributes of an event log
record. Attributes are available as lowercase_with_underscore equivalents
of their TitleCase counterparts and are converted to Python data types
where appropriate, eg time_written is a datetime value and sid is
an :class:`accounts.Principal` instance.
Two _EventLogEntry instances compare equal if they have the same
record number on the same event log on the same computer.
"""
def __init__(self, event_log_name, event_log_entry):
self._event_log_name = event_log_name
self._event_log_entry = event_log_entry
import win32api
import win32profile
import win32gui
import win32con
import winerror
from winsys._compat import *
from winsys import core, exc, utils, registry
class x_environment(exc.x_winsys):
"Base exception for all env exceptions"
WINERROR_MAP = {winerror.ERROR_ENVVAR_NOT_FOUND: exc.x_not_found}
wrapped = exc.wrapper(WINERROR_MAP, x_environment)
class _DelimitedText(list):
"""Helper class for values such as PATH and PATHEXT which are
consistently semicolon-delimited text but which can helpfully
be treated as a list of individual values. Subclasseed from
list, it keeps track of the delimited list while exposing
the more familiar Pythonesque list interface.
"""
def __init__(self, env, key, delimiter=";", initialiser=None):
super(_DelimitedText, self).__init__(env[key].split(delimiter) if initialiser is None else initialiser)
self.env = env
self.key = key
self.delimiter = unicode(delimiter)
CREDUI_FLAGS = constants.Constants.from_pattern("CREDUI_FLAGS_*",
namespace=win32cred)
CREDUI_FLAGS.doc("Options for username prompt UI")
CRED_FLAGS = constants.Constants.from_pattern("CRED_FLAGS_*",
namespace=win32cred)
CRED_TYPE = constants.Constants.from_pattern("CRED_TYPE_*",
namespace=win32cred)
CRED_TI = constants.Constants.from_pattern("CRED_TI_*", namespace=win32cred)
class x_dialogs(exc.x_winsys):
"Base for dialog-related exceptions"
WINERROR_MAP = {}
wrapped = exc.wrapper(WINERROR_MAP, x_dialogs)
DESKTOP = wrapped(win32gui.GetDesktopWindow)
ENCODING = "UTF-8"
class _DropTarget(win32com.server.policy.DesignatedWrapPolicy):
"""Helper class to implement the IDropTarget interface so that
files can be drag-dropped onto a text field in a dialog.
"""
_reg_clsid_ = '{72AA1C07-73BA-4CA8-88B9-7F03FEA173E8}'
_reg_progid_ = "WinSysDialogs.DropTarget"
_reg_desc_ = "Drop target handler for WinSys Dialogs"
_public_methods_ = ['DragEnter', 'DragOver', 'DragLeave', 'Drop']
_com_interfaces_ = [pythoncom.IID_IDropTarget]
__all__ = ['PRIVILEGE_ATTRIBUTE', 'PRIVILEGE', 'Privilege', 'privilege', 'x_privilege', 'x_privilege_no_token']
PRIVILEGE_ATTRIBUTE = constants.Constants.from_pattern("SE_PRIVILEGE_*", namespace=win32security)
PRIVILEGE = constants.Constants.from_pattern("SE_*_NAME", namespace=win32security)
PRIVILEGE.doc("Privileges granted through a user's token")
class x_privilege(exc.x_winsys):
"Base for all privilege-related exceptions"
class x_privilege_no_token(x_privilege):
"Raised when a token cannot be found"
WINERROR_MAP = {
winerror.ERROR_NO_TOKEN : x_privilege_no_token
}
wrapped = exc.wrapper(WINERROR_MAP, x_privilege)
#
# Convenience implementation functions
#
def _get_token():
try:
return wrapped(
win32security.OpenThreadToken,
wrapped(win32api.GetCurrentThread),
constants.GENERAL.MAXIMUM_ALLOWED,
True
)
except x_privilege_no_token:
return wrapped(
win32security.OpenProcessToken,
__all__ = ['Token', 'token', 'x_token', 'x_no_token']
class x_token (exc.x_winsys):
"Base for all token-related exceptions"
class x_no_token (x_token):
"Raised when a token cannot be retrieved"
PyHANDLE = pywintypes.HANDLEType
WINERROR_MAP = {
winerror.ERROR_ACCESS_DENIED : exc.x_access_denied,
winerror.ERROR_NO_TOKEN : x_no_token
}
wrapped = exc.wrapper (WINERROR_MAP, x_token)
def _from_sid_and_attribute (data):
sid, attributes = data
#
# SDK says that no attributes are defined at present,
# so ignore them!
#
return accounts.principal (sid)
def _from_sid_and_attributes (data):
return [_from_sid_and_attribute (d) for d in data]
def _from_privileges (data):
return [_privileges.Privilege (*d) for d in data]
UF = constants.Constants.from_pattern (u"UF_*", namespace=win32netcon)
UF.doc ("Flags for creating new users")
SID_NAME_USE = constants.Constants.from_pattern (u"SidType*", namespace=ntsecuritycon)
SID_NAME_USE.doc ("Types of accounts for which SIDs exist")
FILTER = constants.Constants.from_pattern (u"FILTER_*", namespace=win32netcon)
FILTER.doc ("Filters when enumerating users")
PySID = pywintypes.SIDType
class x_accounts (exc.x_winsys):
"Base for all accounts-related exceptions"
WINERROR_MAP = {
winerror.ERROR_NONE_MAPPED : exc.x_not_found
}
wrapped = exc.wrapper (WINERROR_MAP, x_accounts)
def _win32net_enum (win32_fn, system_or_domain):
resume = 0
while True:
items, total, resume = wrapped (win32_fn, system_or_domain, 0, resume)
for item in items:
yield item
if resume == 0: break
def principal (principal, cls=core.UNSET):
ur"""Factory function for the :class:`Principal` class. This is the most
common way to create a :class:`Principal` object::
from winsys import accounts
service_account = accounts.principal (accounts.WELL_KNOWN_SID.Service)
"""
class x_active_directory(exc.x_winsys):
"Base for all AD-related exceptions"
SEARCHPREF = constants.Constants.from_pattern("ADS_SEARCHPREF_*", namespace=adsicon)
SEARCHPREF.doc("Preferences for searching AD")
SCOPE = constants.Constants.from_pattern("ADS_SCOPE_*", namespace=adsicon)
SCOPE.doc("Scope for searching AD trees")
WINERROR_MAP = {
adsicon.E_ADS_COLUMN_NOT_SET : exc.x_not_found,
0x8000500D : AttributeError
}
wrapped = exc.wrapper(WINERROR_MAP, x_active_directory)
SEARCH_PREFERENCES = {
SEARCHPREF.PAGESIZE : 1000,
SEARCHPREF.SEARCH_SCOPE : SCOPE.SUBTREE,
}
class Result(dict):
def __getattr__(self, attr):
return self[attr]
ESCAPED_CHARACTERS = dict((special, r"\%02x" % ord(special)) for special in "*()\x00/")
def escaped(s):
for original, escape in ESCAPED_CHARACTERS.items():
s = s.replace(original, escape)
return s
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import win32api
import win32con
import win32process
import pywintypes
from winsys import constants, core, exc, ipc, utils
class x_processes(exc.x_winsys):
pass
WINERROR_MAP = {
}
wrapped = exc.wrapper(WINERROR_MAP, x_processes)
class Process(core._WinSysObject):
def __init__(self, command, inherit_handles=True, flags=0, environment=None, current_directory=None, startupinfo=None):
core._WinSysObject.__init__(self)
process_info = wrapped(
win32process.CreateProcess,
None,
command,
None,
None,
inherit_handles,
flags,
environment,
current_directory,
], pattern=u"SE_*", namespace=win32security)
SD_CONTROL.doc (u"Information held with a security descriptor header")
PyHANDLE = pywintypes.HANDLEType
PySECURITY_ATTRIBUTES = pywintypes.SECURITY_ATTRIBUTESType
PySECURITY_DESCRIPTOR = type (pywintypes.SECURITY_DESCRIPTOR ())
class x_security (exc.x_winsys):
u"Base for security-related exceptions"
class x_value_not_set (x_security):
u"Raised if an attempt is made to read a security value which hasn't been set"
WINERROR_MAP = {
}
wrapped = exc.wrapper (WINERROR_MAP, x_security)
class Security (core._WinSysObject):
ur"""The heart of the :mod:`security` module, this class represents the security
descriptor of a file, kernel object or any other securable object. It's most
commonly instantiated from an object's security method (eg `fs.File.security`)
or by means of the :func:`security` function which can take the name or handle
of an object and return a corresponding :class:`Security` object.
Key attributes are:
* owner - a :class:`Principal` object representing the object owner
* group - a :class:`Principal` object representing the object group
* dacl - a :class:`security.DACL` object representing the DACL
* sacl - an :class:`security.SACL` object representing the SACL
from winsys._security.core import REVISION
from winsys._security import _aces
__all__ = ['x_acl', 'ACL', 'DACL', 'SACL', 'acl', 'dacl', 'sacl']
PyACL = pywintypes.ACLType
class x_acl (exc.x_winsys):
"Base for all ACL-related exceptions"
class x_value_not_set (x_acl):
"Raised when iterating over an ACL which has not been set"
WINERROR_MAP = {
}
wrapped = exc.wrapper (WINERROR_MAP, x_acl)
class ACL (core._WinSysObject):
"""An ACL maps the Windows security ACL concept, but behaves like
a Python list. You can append to it, iterate over it, delete from
it, check its length and test it for membership. A special case is
made for the so-called NULL ACL. This is different from an empty
ACL (which is effectively completely restrictive). A NULL ACL is
completely unrestrictive. This is mapped by holding None and treating
this specially where needed.
DACL & SACL subclasses are defined to cope with the slightly different
ways in which the structures are manipulated, but the core functionality
is in this base class. This class need rarely be instantiated directly;
normally it will be invoked by the Security class which is accessor
properties for this purpose.
# -*- coding: iso-8859-1 -*-
import win32api
import win32con
import win32file
import pywintypes
from winsys import constants, core, exc, utils
class x_handles (exc.x_winsys):
pass
WINERROR_MAP = {
}
wrapped = exc.wrapper (WINERROR_MAP, x_handles)
class Handle (core._WinSysObject):
def __init__ (self, handle):
core._WinSysObject.__init__ (self)
self._handle = handle
self.name = str (int (self._handle))
def __int__ (self):
return int (self._handle)
def pyobject (self):
return self._handle
def duplicate (self, process=None, inheritable=True):
target_process = processes.process (process).hProcess
this_process = wrapped (win32api.GetCurrentProcess)
SHGDN = constants.Constants.from_pattern ("SHGDN_*", namespace=shellcon)
PROPERTIES = {
FMTID.SummaryInformation : PIDSI,
FMTID.DocSummaryInformation : PIDDSI,
FMTID.MediaFileSummaryInformation : PIDMSI,
FMTID.AudioSummaryInformation : PIDASI,
FMTID.Volume : PID_VOLUME,
}
class x_shell (exc.x_winsys):
pass
WINERROR_MAP = {
}
wrapped = exc.wrapper (WINERROR_MAP, x_shell)
#
# Although this can be done in one call, Win9x didn't
# support it, so I added this workaround.
#
def get_path (folder_id):
return shell.SHGetPathFromIDList (shell.SHGetSpecialFolderLocation (0, folder_id))
def desktop (common=0):
u"What folder is equivalent to the current desktop?"
return get_path ((shellcon.CSIDL_DESKTOP, shellcon.CSIDL_COMMON_DESKTOPDIRECTORY)[common])
def common_desktop ():
#
# Only here because already used in code
import os, sys
import win32api
import win32profile
import win32gui
import win32con
import winerror
from winsys import core, exc, utils, registry
class x_environment(exc.x_winsys):
"Base exception for all env exceptions"
WINERROR_MAP = {
winerror.ERROR_ENVVAR_NOT_FOUND : exc.x_not_found,
}
wrapped = exc.wrapper(WINERROR_MAP, x_environment)
class _DelimitedText(list):
"""Helper class for values such as PATH and PATHEXT which are
consistently semicolon-delimited text but which can helpfully
be treated as a list of individual values. Subclasseed from
list, it keeps track of the delimited list while exposing
the more familiar Pythonesque list interface.
"""
def __init__(self, env, key, delimiter=";", initialiser=None):
super(_DelimitedText, self).__init__(env[key].split(delimiter) if initialiser is None else initialiser)
self.env = env
self.key = key
self.delimiter = unicode(delimiter)
AUDIT_FAILURE = win32evtlog.EVENTLOG_AUDIT_FAILURE,
AUDIT_SUCCESS = win32evtlog.EVENTLOG_AUDIT_SUCCESS
))
EVENTLOG_TYPE.doc("Types of records in event logs")
PyHANDLE = pywintypes.HANDLEType
DEFAULT_LOG_NAME = "Application"
class x_event_logs(exc.x_winsys):
"Base exception for eventlog-specific exceptions"
WINERROR_MAP = {
winerror.ERROR_ACCESS_DENIED : exc.x_access_denied
}
wrapped = exc.wrapper(WINERROR_MAP)
class _EventLogEntry(core._WinSysObject):
"""Internal class for convenient access to attributes of an event log
record. Attributes are available as lowercase_with_underscore equivalents
of their TitleCase counterparts and are converted to Python data types
where appropriate, eg time_written is a datetime value and sid is
an :class:`accounts.Principal` instance.
Two _EventLogEntry instances compare equal if they have the same
record number on the same event log on the same computer.
"""
def __init__(self, event_log_name, event_log_entry):
self._event_log_name = event_log_name
self._event_log_entry = event_log_entry
], pattern=u"SE_*", namespace=win32security)
SD_CONTROL.doc (u"Information held with a security descriptor header")
PyHANDLE = pywintypes.HANDLEType
PySECURITY_ATTRIBUTES = pywintypes.SECURITY_ATTRIBUTESType
PySECURITY_DESCRIPTOR = type (pywintypes.SECURITY_DESCRIPTOR ())
class x_security (exc.x_winsys):
u"Base for security-related exceptions"
class x_value_not_set (x_security):
u"Raised if an attempt is made to read a security value which hasn't been set"
WINERROR_MAP = {
}
wrapped = exc.wrapper (WINERROR_MAP, x_security)
class Security (core._WinSysObject):
ur"""The heart of the :mod:`security` module, this class represents the security
descriptor of a file, kernel object or any other securable object. It's most
commonly instantiated from an object's security method (eg `fs.File.security`)
or by means of the :func:`security` function which can take the name or handle
of an object and return a corresponding :class:`Security` object.
Key attributes are:
* owner - a :class:`Principal` object representing the object owner
* group - a :class:`Principal` object representing the object group
* dacl - a :class:`security.DACL` object representing the DACL
* sacl - an :class:`security.SACL` object representing the SACL
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import win32security
from winsys import accounts, constants, core, exc, utils
__all__ = ['LogonSession', 'LSA', 'x_lsa']
class x_lsa(exc.x_winsys):
"Base for all LSA-related exceptions"
WINERROR_MAP = {}
wrapped = exc.wrapper(WINERROR_MAP, x_lsa)
def principal(account):
try:
return accounts.principal(account)
except exc.x_not_found:
return "<unknown>"
class LogonSession(core._WinSysObject):
_MAP = {
"UserName": principal,
"Sid": principal,
"LogonTime": utils.from_pytime
class x_moniker_no_root(x_moniker):
"Raised when a moniker has no Hive in the first or second position"
sep = "\\"
WINERROR_MAP = {
winerror.ERROR_PATH_NOT_FOUND: exc.x_not_found,
winerror.ERROR_FILE_NOT_FOUND: exc.x_not_found,
winerror.ERROR_NO_MORE_ITEMS: StopIteration,
winerror.ERROR_ACCESS_DENIED: exc.x_access_denied,
winerror.ERROR_INVALID_HANDLE: exc.x_invalid_handle,
}
wrapped = exc.wrapper(WINERROR_MAP, x_registry)
def _parse_moniker(moniker, accept_value=True):
r"""Take a registry moniker and return the computer, root key, subkey path and value label.
NB: neither the computer nor the registry key need exist; they
need simply to be of the right format. The slashes must be backslashes (since
registry key names can contain forward slashes). accept_value is mostly used
internally to indicate that a key search is going on, where a colon is to be
considered part of the key name; if it is True, then the colon is to be
considered a value separator.
The moniker must be of the form:
[\\computer\]HKEY[\subkey path][:value]
class x_active_directory(exc.x_winsys):
"Base for all AD-related exceptions"
SEARCHPREF = constants.Constants.from_pattern(u"ADS_SEARCHPREF_*",
namespace=adsicon)
SEARCHPREF.doc("Preferences for searching AD")
SCOPE = constants.Constants.from_pattern(u"ADS_SCOPE_*", namespace=adsicon)
SCOPE.doc("Scope for searching AD trees")
WINERROR_MAP = {
adsicon.E_ADS_COLUMN_NOT_SET: exc.x_not_found,
0x8000500D: AttributeError
}
wrapped = exc.wrapper(WINERROR_MAP, x_active_directory)
SEARCH_PREFERENCES = {
SEARCHPREF.PAGESIZE: 1000,
SEARCHPREF.SEARCH_SCOPE: SCOPE.SUBTREE,
}
class Result(dict):
def __getattr__(self, attr):
return self[attr]
ESCAPED_CHARACTERS = dict(
(special, r"\%02x" % ord(special)) for special in "*()\x00/")
__all__ = ['Token', 'token', 'x_token', 'x_no_token']
class x_token(exc.x_winsys):
"Base for all token-related exceptions"
class x_no_token(x_token):
"Raised when a token cannot be retrieved"
PyHANDLE = pywintypes.HANDLEType
WINERROR_MAP = {
winerror.ERROR_ACCESS_DENIED : exc.x_access_denied,
winerror.ERROR_NO_TOKEN : x_no_token
}
wrapped = exc.wrapper(WINERROR_MAP, x_token)
def _from_sid_and_attribute(data):
sid, attributes = data
#
# SDK says that no attributes are defined at present,
# so ignore them!
#
return accounts.principal(sid)
def _from_sid_and_attributes(data):
return [_from_sid_and_attribute(d) for d in data]
def _from_privileges(data):
return [_privileges.Privilege(*d) for d in data]
# -*- coding: iso-8859-1 -*-
import win32api
import win32con
import win32file
import pywintypes
from winsys import constants, core, exc, utils
class x_handles(exc.x_winsys):
pass
WINERROR_MAP = {}
wrapped = exc.wrapper(WINERROR_MAP, x_handles)
class Handle(core._WinSysObject):
def __init__(self, handle):
core._WinSysObject.__init__(self)
self._handle = handle
self.name = str(int(self._handle))
def __int__(self):
return int(self._handle)
def pyobject(self):
return self._handle
def duplicate(self, process=None, inheritable=True):
target_process = processes.process(process).hProcess
# -*- coding: iso-8859-1 -*-
import win32api
import win32con
import win32process
import pywintypes
from winsys import constants, core, exc, ipc, utils
class x_processes (exc.x_winsys):
pass
WINERROR_MAP = {
}
wrapped = exc.wrapper (WINERROR_MAP, x_processes)
class Process (core._WinSysObject):
def __init__ (self, command, inherit_handles=True, flags=0, environment=None, current_directory=None, startupinfo=None):
core._WinSysObject.__init__ (self)
process_info = wrapped (
win32process.CreateProcess,
None,
command,
None,
None,
inherit_handles,
flags,
environment,
current_directory,
startupinfo
)
UF.doc("Flags for creating new users")
SID_NAME_USE = constants.Constants.from_pattern("SidType*",
namespace=ntsecuritycon)
SID_NAME_USE.doc("Types of accounts for which SIDs exist")
FILTER = constants.Constants.from_pattern("FILTER_*", namespace=win32netcon)
FILTER.doc("Filters when enumerating users")
PySID = pywintypes.SIDType
class x_accounts(exc.x_winsys):
"Base for all accounts-related exceptions"
WINERROR_MAP = {winerror.ERROR_NONE_MAPPED: exc.x_not_found}
wrapped = exc.wrapper(WINERROR_MAP, x_accounts)
def _win32net_enum(win32_fn, system_or_domain):
resume = 0
while True:
items, total, resume = wrapped(win32_fn, system_or_domain, 0, resume)
for item in items:
yield item
if resume == 0: break
def principal(principal, cls=core.UNSET):
"""Factory function for the :class:`Principal` class. This is the most
common way to create a :class:`Principal` object::
class x_moniker_ill_formed(x_moniker):
"Raised when a moniker does not match the correct format"
class x_moniker_no_root(x_moniker):
"Raised when a moniker has no Hive in the first or second position"
sep = "\\"
WINERROR_MAP = {
winerror.ERROR_PATH_NOT_FOUND : exc.x_not_found,
winerror.ERROR_FILE_NOT_FOUND : exc.x_not_found,
winerror.ERROR_NO_MORE_ITEMS : StopIteration,
winerror.ERROR_ACCESS_DENIED : exc.x_access_denied,
winerror.ERROR_INVALID_HANDLE : exc.x_invalid_handle,
}
wrapped = exc.wrapper(WINERROR_MAP, x_registry)
def _parse_moniker(moniker, accept_value=True):
r"""Take a registry moniker and return the computer, root key, subkey path and value label.
NB: neither the computer nor the registry key need exist; they
need simply to be of the right format. The slashes must be backslashes (since
registry key names can contain forward slashes). accept_value is mostly used
internally to indicate that a key search is going on, where a colon is to be
considered part of the key name; if it is True, then the colon is to be
considered a value separator.
The moniker must be of the form:
[\\computer\]HKEY[\subkey path][:value]
__all__ = ['PRIVILEGE_ATTRIBUTE', 'PRIVILEGE', 'Privilege', 'privilege', 'x_privilege', 'x_privilege_no_token']
PRIVILEGE_ATTRIBUTE = constants.Constants.from_pattern("SE_PRIVILEGE_*", namespace=win32security)
PRIVILEGE = constants.Constants.from_pattern("SE_*_NAME", namespace=win32security)
PRIVILEGE.doc("Privileges granted through a user's token")
class x_privilege(exc.x_winsys):
"Base for all privilege-related exceptions"
class x_privilege_no_token(x_privilege):
"Raised when a token cannot be found"
WINERROR_MAP = {
winerror.ERROR_NO_TOKEN : x_privilege_no_token
}
wrapped = exc.wrapper(WINERROR_MAP, x_privilege)
#
# Convenience implementation functions
#
def _get_token():
try:
return wrapped(
win32security.OpenThreadToken,
wrapped(win32api.GetCurrentThread),
constants.GENERAL.MAXIMUM_ALLOWED,
True
)
except x_privilege_no_token:
return wrapped(
win32security.OpenProcessToken,
BIF.doc ("Styles for browsing for a folder")
BFFM = constants.Constants.from_pattern (u"BFFM_*", namespace=shellcon)
BFFM.doc ("Part of the browse-for-folder shell mechanism")
CREDUI_FLAGS = constants.Constants.from_pattern (u"CREDUI_FLAGS_*", namespace=win32cred)
CREDUI_FLAGS.doc ("Options for username prompt UI")
CRED_FLAGS = constants.Constants.from_pattern (u"CRED_FLAGS_*", namespace=win32cred)
CRED_TYPE = constants.Constants.from_pattern (u"CRED_TYPE_*", namespace=win32cred)
CRED_TI = constants.Constants.from_pattern (u"CRED_TI_*", namespace=win32cred)
class x_dialogs (exc.x_winsys):
"Base for dialog-related exceptions"
WINERROR_MAP = {
}
wrapped = exc.wrapper (WINERROR_MAP, x_dialogs)
DESKTOP = wrapped (win32gui.GetDesktopWindow)
ENCODING = "UTF-8"
class _DropTarget (win32com.server.policy.DesignatedWrapPolicy):
ur"""Helper class to implement the IDropTarget interface so that
files can be drag-dropped onto a text field in a dialog.
"""
_reg_clsid_ = '{72AA1C07-73BA-4CA8-88B9-7F03FEA173E8}'
_reg_progid_ = "WinSysDialogs.DropTarget"
_reg_desc_ = "Drop target handler for WinSys Dialogs"
_public_methods_ = ['DragEnter', 'DragOver', 'DragLeave', 'Drop']
_com_interfaces_ = [pythoncom.IID_IDropTarget]
"""
from __future__ import unicode_literals
import pywintypes
import winerror
import win32event
import win32file
from winsys import constants, core, exc, ipc, utils
class x_asyncio(exc.x_winsys):
pass
WINERROR_MAP = {
}
wrapped = exc.wrapper(WINERROR_MAP, x_asyncio)
class AsyncIO(core._WinSysObject):
def __init__(self):
core._WinSysObject.__init__(self)
self.event = ipc.event(needs_manual_reset=True)
self.overlapped = wrapped(win32file.OVERLAPPED)
self.overlapped.hEvent = self.event.pyobject()
def pyobject(self):
"""Return the pyobject of the underlying event so that this object can
be waited on by the :func:`ipc.all` or :func:`ipc.any` functions
"""
return self.event.pyobject()
__all__ = ['x_acl', 'ACL', 'DACL', 'SACL', 'acl', 'dacl', 'sacl']
PyACL = pywintypes.ACLType
class x_acl(exc.x_winsys):
"Base for all ACL-related exceptions"
class x_value_not_set(x_acl):
"Raised when iterating over an ACL which has not been set"
WINERROR_MAP = {}
wrapped = exc.wrapper(WINERROR_MAP, x_acl)
class ACL(core._WinSysObject):
"""An ACL maps the Windows security ACL concept, but behaves like
a Python list. You can append to it, iterate over it, delete from
it, check its length and test it for membership. A special case is
made for the so-called NULL ACL. This is different from an empty
ACL (which is effectively completely restrictive). A NULL ACL is
completely unrestrictive. This is mapped by holding None and treating
this specially where needed.
DACL & SACL subclasses are defined to cope with the slightly different
ways in which the structures are manipulated, but the core functionality
is in this base class. This class need rarely be instantiated directly;
normally it will be invoked by the Security class which is accessor
