Forgot a file.. This is the real v0.4

.gitignore

@@ -1,2 +1,4 @@
 *.pyc
-doc/build
+doctrees
+*.inv
+*.pickle

CHANGELOG

@@ -0,0 +1,42 @@
+Since 0.2:
+
+    * NtStatusException is now a WindowsError
+    * Add shr/shl RM32(64)/Imm8
+    * Small fix simple_x64 Imm8 encoding
+    * `execute_64bits_code_from_syswow` able to return ULONG64
+    * utils.get_short_path / utils.get_long_path
+    * Object returned by `windows.native_exec.create_function` has an attribute `code_addr` with the address of the executable code
+    * add `windows.winproxy.is_implemented` Ex: windows.winproxy.is_implemented(windows.winproxy.QueryWorkingSetEx)
+    * registry.py handle REG_QWORD manually (_winreg does not)
+    * CurrentProcessReadSyswow doest not use ``current_process.handle`` anymore but ``OpenProcess(current_process.pid)`` (Compat windows10 where method 1 doest not work)
+    * Add: system.handles (winobject\handle.py)
+    * You can have multiple execute_python_unsafe at the same time in the same process (didn't know: consequence of new injection code)
+    * WinProcess.execute_python does not regenerate/reinject the python_exec_shellcode for each execution
+    * generate.py cleaned with class and stuff / usable for extern project (cc lkd)
+    * Added COMImplementation to com interface
+    * fix x86.assemble + add x64.assemble | fix some encoding problem in x64
+    * Add test_code.py sample
+    * Remove OptionExport from winproxy
+    * MemoryBP + single_step for windows.debug.Debugger
+    * Possibility to delete breakpoints in windows.debug.Debugger
+    * Add Context.func_result as abstract register for EAX/RAX
+    * Can retrieve 64b context of syswow thread via context_syswow/set_syswow_context
+    * Debugger handle breakpoint in 64b part of syswow process
+    * ReadSyswow64Process is now a Process (allows to parse exports of remote PEB64 of syswow process)
+    * Added Debugger.detach
+
+
+Since 0.3:
+
+    * Rewrote pe_parse to minimize closure (allowing the refcount to del all ref to WinProcess when the debugger detach it)
+    * Fix debugger.detach / handling on exit_process
+
+
+Since 0.35:
+
+    * WinProcess.get_mapped_filename can now raise on non-standard error (like: ERROR_TRANSACTION_NOT_ACTIVE)
+    * WinProcess.get_mapped_filename now use GetMappedFilenameW (returning an unicode string)
+    * CertificateContext is replace by Certificate
+        * CertificateContext was a PPCERT_CONTEXT. Certificate is a CERT_CONTEXT (not a pointer anymore)
+    * EHCERTSTORE renamed to CertificateStore
+    * added windows.pipe

README.md

@@ -14,6 +14,9 @@ You can find some examples of code in the [samples directory][SAMPLE_DIR] or [on
 
 Parts of PythonForWindows are used in the [LKD project][LKD_GITHUB].
 
+If you have any issue, question, suggestion do not hesitate to contact me.
+I am always glad to have feedbacks from people using this project.
+
 ## Overview
 
 ### Processes / Threads
@@ -31,6 +34,67 @@ All those operations are also available for the `current_process`.
 
 You can also make some operation on threads (suspend/resume/wait/get(or set) context/ kill)
 
+```python
+>>> import windows
+>>> windows.current_process.bitness
+32
+>>> windows.current_process.token.integrity
+SECURITY_MANDATORY_MEDIUM_RID(0x2000L)
+>>> calc = [p for p in windows.system.processes if p.name == "calc.exe"][0]
+>>> calc
+<WinProcess "calc.exe" pid 6960 at 0x37391f0>
+>>> calc.bitness
+64
+>>> calc.peb.modules[:3]
+[<RemoteLoadedModule64 "calc.exe" at 0x3671e90>, <RemoteLoadedModule64 "ntdll.dll" at 0x3671030>, <RemoteLoadedModule64 "kernel32.dll" at 0x3671080>]
+>>> k32 = calc.peb.modules[2]
+>>> hex(k32.pe.exports["CreateFileW"])
+'0x7ffee6761550L'
+>>> calc.threads[0]
+<WinThread 3932 owner "calc.exe" at 0x3646350>
+>>> hex(calc.threads[0].context.Rip)
+'0x7ffee68b54b0L'
+>>> calc.execute_python("import os")
+True
+>>> calc.execute_python("exit(os.getpid() + 1)")
+# execute_python raise if process died
+Traceback (most recent call last):
+...
+WindowsError: <WinProcess "calc.exe" pid 6960 (DEAD) at 0x37391f0> died during execution of python command
+>>> calc
+<WinProcess "calc.exe" pid 6960 (DEAD) at 0x37391f0>
+>>> calc.exit_code
+6961L
+```
+
+### System information
+
+Information about the Windows computer running the script are available through the `windows.system` object.
+
+```python
+>>> windows.system
+<windows.winobject.system.System object at 0x03FEED10>
+>>> windows.system.bitness
+64
+>>> windows.system.computer_name
+'DESKTOP-VKUGISR'
+>>> windows.system.product_type
+VER_NT_WORKSTATION(0x1L)
+>>> windows.system.version
+(10, 0)
+>>> windows.system.version_name
+'Windows 10'
+>>> windows.system.build_number
+'10.0.15063.608'
+
+# windows.system also contains dynamic lists about processes / threads / handles / ...
+>>> windows.system.handles[-2:]
+[<Handle value=<0x5cc> in process pid=14360>, <Handle value=<0x28e4> in process pid=14360>]
+>>> windows.system.processes[:2]
+[<WinProcess "[System Process]" pid 0 at 0x433f7d0>, <WinProcess "System" pid 4 at 0x433fd30>]
+>>> windows.system.logicaldrives[0]
+<LogicalDrive "C:\" (DRIVE_FIXED)>
+```
 
 ### IAT Hook
 
@@ -41,28 +105,300 @@ So the features is present (See [online documentation][ONLINE_IATHOOK] about IAT
 ### Winproxy
 
 A wrapper around some Windows functions. Arguments name and order are the same,
-but some have default values and the functions raise exception on call error (I don't like 'if' around all my call).
+but some have default values and the functions raise exception on call error (I don't like `if` around all my call).
+
+```python
+>>> import windows
+>>> help(windows.winproxy.VirtualAlloc)
+# Help on function VirtualAlloc in module windows.winproxy:
+# VirtualAlloc(lpAddress=0, dwSize=NeededParameter, flAllocationType=MEM_COMMIT(0x1000L), flProtect=PAGE_EXECUTE_READWRITE(0x40L))
+#     Errcheck:
+#     raise Kernel32Error if result is 0
+
+# Positional arguments
+>>> windows.winproxy.VirtualAlloc(0, 0x1000)
+34537472
+
+# Keyword arguments
+>>> windows.winproxy.VirtualAlloc(dwSize=0x1000)
+34603008
+
+# NeededParameter must be provided
+>>> windows.winproxy.VirtualAlloc()
+"""
+Traceback (most recent call last):
+File "<stdin>", line 1, in <module>
+File "windows\winproxy.py", line 264, in VirtualAlloc
+    return VirtualAlloc.ctypes_function(lpAddress, dwSize, flAllocationType, flProtect)
+File "windows\winproxy.py", line 130, in perform_call
+    raise TypeError("{0}: Missing Mandatory parameter <{1}>".format(self.func_name, param_name))
+TypeError: VirtualAlloc: Missing Mandatory parameter <dwSize>
+"""
+
+# Error raises exception
+>>> windows.winproxy.VirtualAlloc(dwSize=0xffffffff)
+"""
+Traceback (most recent call last):
+File "<stdin>", line 1, in <module>
+File "windows\winproxy.py", line 264, in VirtualAlloc
+    return VirtualAlloc.ctypes_function(lpAddress, dwSize, flAllocationType, flProtect)
+File "windows\winproxy.py", line 133, in perform_call
+    return self._cprototyped(*args)
+File "windows\winproxy.py", line 59, in kernel32_error_check
+    raise Kernel32Error(func_name)
+windows.winproxy.Kernel32Error: VirtualAlloc: [Error 8] Not enough storage is available to process this command.
+"""
+```
 
 
 ### Native execution
 
-To make the barrier between `native` and `Python` code,
-PythonForWindows allows you to create native function callable from Python (thanks `ctypes`) and also embed
+To make the barrier between `native` and `Python` code thinner,
+PythonForWindows allows you to create native function callable from Python (thanks to `ctypes`) and also embed
 a simple x86/x64 assembler.
 
+```python
+>>> import windows.native_exec.simple_x86 as x86
+>>> code = x86.MultipleInstr()
+>>> code += x86.Mov("EAX", 41)
+>>> code += x86.Inc("EAX")
+>>> code += x86.Ret()
+>>> code.get_code()
+'\xc7\xc0)\x00\x00\x00@\xc3'
+# Create a function that takes no parameters and return an uint
+>>> f = windows.native_exec.create_function(code.get_code(), [ctypes.c_uint])
+>>> f()
+42L
+# Assemblers can also be used in a more standard way
+>>> x86.assemble("cmp edi, 0; jnz :end; mov eax, 1; label :end; ret")
+'\x81\xff\x00\x00\x00\x00u\x06\xc7\xc0\x01\x00\x00\x00\xc3'
+```
 
-## Other stuff
+### Wintrust
 
-Some code are just explorations and need improvements like:
+To easily script some signature check script, PythonForWindows implements some wrapper functions around ``wintrust.dll``
 
-- Wintrust
-- WMI
-- Exception
+```python
+>>> import windows.wintrust
+>>> windows.wintrust.is_signed(r"C:\Windows\system32\ntdll.dll")
+True
+>>> windows.wintrust.is_signed(r"C:\Windows\system32\python27.dll")
+False
+>>> windows.wintrust.full_signature_information(r"C:\Windows\system32\ntdll.dll")
+SignatureData(signed=True,
+    catalog=u'C:\\Windows\\system32\\CatRoot\\{F750E6C3-38EE-11D1-85E5-00C04FC295EE}\\Package_35_for_KB3128650~31bf3856ad364e35~amd64~~6.3.1.2.cat',
+    catalogsigned=True, additionalinfo=0L)
+>>> windows.wintrust.full_signature_information(r"C:\Windows\system32\python27.dll")
+SignatureData(signed=False, catalog=None, catalogsigned=False, additionalinfo=TRUST_E_NOSIGNATURE(0x800b0100L))
+```
+
+### WMI
+
+To extract/play with even more information about the system, PythonForWindows is able to perform WMI request.
+
+```python
+>>> import windows
+>>> windows.system.wmi.select
+<bound method WmiRequester.select of <windows.winobject.wmi.WmiRequester object at 0x036BA590>>
+>>> windows.system.wmi.select("Win32_Process", ["Name", "Handle"])[:4]
+[{'Handle': u'0', 'Name': u'System Idle Process'}, {'Handle': u'4', 'Name': u'System'}, {'Handle': u'412', 'Name': u'smss.exe'}, {'Handle': u'528', 'Name': u'csrss.exe'}]
+# Get WMI data for current process
+>>> wmi_cp = [p for p in windows.system.wmi.select("Win32_Process") if int(p["Handle"]) == windows.current_process.pid][0]
+>>> wmi_cp["CommandLine"], wmi_cp["HandleCount"]
+(u'"C:\\Python27\\python.exe"', 227)
+```
+
+### Registry
+
+The project also contains some wrapping classes around `_winreg` for simpler use.
+
+```python
+>>> import windows
+>>> from windows.generated_def import KEY_WRITE, KEY_READ, REG_QWORD
+>>> registry = windows.system.registry
+>>> cuuser_software = registry(r'HKEY_CURRENT_USER\Software')
+>>> cuuser_software
+<PyHKey "HKEY_CURRENT_USER\Software">
+>>> cuuser_software.sam
+KEY_READ(0x20019L)
+# Explore subkeys
+>>> cuuser_software.subkeys[:3]
+[<PyHKey "HKEY_CURRENT_USER\Software\7-Zip">, <PyHKey "HKEY_CURRENT_USER\Software\AppDataLow">, <PyHKey "HKEY_CURRENT_USER\Software\Audacity">]
+>>> tstkey = registry('HKEY_CURRENT_USER\TestKey',  KEY_WRITE | KEY_READ)
+# Get / Set individual value
+>>> tstkey["VALUE"] = 'a_value_for_my_key'
+>>> tstkey["VALUE"]
+KeyValue(name='VALUE', value=u'a_value_for_my_key', type=1)
+>>> tstkey["MYQWORD"] = (123456789987654321, REG_QWORD)  # Default is REG_DWORD for int/long
+>>> tstkey["MYQWORD"]
+KeyValue(name='MYQWORD', value=123456789987654321L, type=11)
+# Explore Values
+>>> tstkey.values
+[KeyValue(name='MYQWORD', value=123456789987654321L, type=11), KeyValue(name='VALUE', value=u'a_value_for_my_key', type=1)]
+```
+
+### ALPC-RPC
+
+#### ALPC
+
+Classes around **A**dvanced **L**ocal **P**rocedure **C**all (**ALPC**) syscalls allows to simply
+write client and server able to send **ALPC** messages.
+
+```python
+>>> import windows.alpc
+# Test server juste reply to each message with "REQUEST '{msg_data}' RECEIVED"
+>>> client = windows.alpc.AlpcClient(r"\RPC Control\PythonForWindowsTESTPORT")
+>>> response = client.send_receive("Hello world !")
+>>> response
+<windows.alpc.AlpcMessage object at 0x04C0D5D0>
+>>> response.data
+"REQUEST 'Hello world !' RECEIVED"
+```
+
+Full client/server code for this example is available is the [ALPC samples][ONLINE_SAMPLE_ALPC] along with a more complex example.
+
+
+#### RPC
+
+An RPC-Client based using **ALPC** communication is also integred
+
+```python
+# Server (port ALPC '\RPC Control\HelloRpc') offers:
+# Interface '41414141-4242-4343-4444-45464748494a' version 1.0
+#   Method 1 -> int Add(int a, int b) -> return a + b
+# This Test server is a real RPC Server using rpcrt4.dll and compiled with VS2015.
+
+>>> import windows.rpc
+>>> from windows.rpc import ndr
+>>> client = windows.rpc.RPCClient(r"\RPC Control\HelloRpc")
+>>> client
+<windows.rpc.client.RPCClient object at 0x0411E130>
+>>> iid = client.bind("41414141-4242-4343-4444-45464748494a")
+>>> ndr_params = ndr.make_parameters([ndr.NdrLong] * 2)
+# NDR pack + Make RPC call to method 1.
+>>> resp = client.call(iid, 1, ndr_params.pack([41414141, 1010101]))
+# Unpack the NDR response
+>>> result = ndr.NdrLong.unpack(ndr.NdrStream(resp))
+>>> result
+42424242
+```
+
+A sample with the **U**ser **A**ccount **C**ontrol (**UAC**) and one with `lsasrv.dll` are available in the [RPC samples][ONLINE_SAMPLE_RPC].
+
+
+### Debugger
+
+PythonForWindows provides a standard debugger to debug other processes.
+
+```python
+import windows
+import windows.debug
+import windows.test
+import windows.native_exec.simple_x86 as x86
+
+from windows.test import pop_calc_32
+from windows.generated_def import EXCEPTION_ACCESS_VIOLATION
+
+class MyDebugger(windows.debug.Debugger):
+    def on_exception(self, exception):
+        code = exception.ExceptionRecord.ExceptionCode
+        addr = exception.ExceptionRecord.ExceptionAddress
+        print("Got exception {0} at 0x{1:x}".format(code, addr))
+        if code == EXCEPTION_ACCESS_VIOLATION:
+            print("Access Violation: kill target process")
+            self.current_process.exit()
+
+calc = windows.test.pop_calc_32(dwCreationFlags=DEBUG_PROCESS)
+d = MyDebugger(calc)
+calc.execute(x86.assemble("int3; mov [0x42424242], EAX; ret"))
+d.loop()
+
+## Ouput ##
+Got exception EXCEPTION_BREAKPOINT(0x80000003L) at 0x77e13c7d
+Got exception EXCEPTION_BREAKPOINT(0x80000003L) at 0x230000
+Got exception EXCEPTION_ACCESS_VIOLATION(0xc0000005L) at 0x230001
+Access Violation: kill target process
+```
+
+The debugger handles
+
+* Standard breakpoint ``int3``
+* Hardware Execution breakpoint ``DrX``
+* Memory breakpoint ``virtual protect``
+
+
+#### LocalDebugger
+
+You can also debug your own process (or debug a process by injection) via the LocalDebugger.
+
+The LocalDebugger is an abstraction around Vectored Exception Handler (VEH)
+
+```python
+import windows
+from windows.generated_def.winstructs import *
+import windows.native_exec.simple_x86 as x86
+
+class SingleSteppingDebugger(windows.debug.LocalDebugger):
+    SINGLE_STEP_COUNT = 4
+    def on_exception(self, exc):
+        code = self.get_exception_code()
+        context = self.get_exception_context()
+        print("EXCEPTION !!!! Got a {0} at 0x{1:x}".format(code, context.pc))
+        self.SINGLE_STEP_COUNT -= 1
+        if self.SINGLE_STEP_COUNT:
+            return self.single_step()
+        return EXCEPTION_CONTINUE_EXECUTION
+
+class RewriteBreakpoint(windows.debug.HXBreakpoint):
+    def trigger(self, dbg, exc):
+        context = dbg.get_exception_context()
+        print("GOT AN HXBP at 0x{0:x}".format(context.pc))
+        # Rewrite the infinite loop with 2 nop
+        windows.current_process.write_memory(self.addr, "\x90\x90")
+        # Ask for a single stepping
+        return dbg.single_step()
+
+
+d = SingleSteppingDebugger()
+# Infinite loop + nop + ret
+code = x86.assemble("label :begin; jmp :begin; nop; ret")
+func = windows.native_exec.create_function(code, [PVOID])
+print("Code addr = 0x{0:x}".format(func.code_addr))
+# Create a thread that will infinite loop
+t = windows.current_process.create_thread(func.code_addr, 0)
+# Add a breakpoint on the infinite loop
+d.add_bp(RewriteBreakpoint(func.code_addr))
+t.wait()
+print("Done!")
+
+## Output ##
+
+Code addr = 0x6a0002
+GOT AN HXBP at 0x6a0002
+EXCEPTION !!!! Got a EXCEPTION_SINGLE_STEP(0x80000004L) at 0x6a0003
+EXCEPTION !!!! Got a EXCEPTION_SINGLE_STEP(0x80000004L) at 0x6a0004
+EXCEPTION !!!! Got a EXCEPTION_SINGLE_STEP(0x80000004L) at 0x6a0005
+EXCEPTION !!!! Got a EXCEPTION_SINGLE_STEP(0x80000004L) at 0x770c7c04
+Done!
+
+```
+
+The local debugger handles
+
+* Standard breakpoint ``int3``
+* Hardware Execution breakpoint ``DrX``
+
+### Other stuff (see doc / samples)
+
+- Network
+- Services
 - COM
 
 
 [LKD_GITHUB]: https://github.com/sogeti-esec-lab/LKD/
 [SAMPLE_DIR]: https://github.com/hakril/PythonForWindows/tree/master/samples
 [ONLINE_DOC]: http://hakril.github.io/PythonForWindows/
-[ONLINE_SAMPLE]: http://hakril.github.io/PythonForWindows/sample.html
-[ONLINE_IATHOOK]: http://hakril.github.io/PythonForWindows/iat_hook.html
+[ONLINE_SAMPLE]: http://hakril.github.io/PythonForWindows/build/html/sample.html
+[ONLINE_SAMPLE_ALPC]: http://hakril.github.io/PythonForWindows/build/html/sample.html#windows-alpc
+[ONLINE_SAMPLE_RPC]: http://hakril.github.io/PythonForWindows/build/html/sample.html#windows-rpc
+[ONLINE_IATHOOK]: http://hakril.github.io/PythonForWindows/build/html/iat_hook.html

TODO

@@ -1,13 +1,59 @@
 TODO:
-    - Documentation
-    - ProcessMemory object ? (metasm like)
-    - Extend Registry feature (write)
 
-FIXME:
-    - WMI
-        - COM initialisation when injected in another process
-        - The CoInitialize might be already called
-        - Fix that
+=== CRITICAL BEFORE 0.4 ===
 
-    - Add INVALID_HANDLE_VALUE to windef
-        - change error_check of CreateFile(A|W)
+======
+
+    - DBG
+        - Verif multiple bp at same place..
+        - Verif multiple pending at same place
+        - Test !! (bp, BP_HX, bp on only on process, bp_hx on only one thread..)
+		- test breakpoint with specific target
+
+        - Rethink/adapt Debugger._explicit_single_step
+            - Does not handle case where EEFlags.TF was by the debugge before trigering the exception
+            - Should set the flag explicitly in single_step ? and not just use EEFlags.TF ?
+        - _handle_load_dll
+            - error in keys of 'self._module_by_process[self.current_process.pid]'
+            - if I have a ntdll32 and ntdll64: both would have the same name in the list..
+
+
+        - Il y a un truc fucked-up avec le add_bp(target=XXX)
+            - j'attends a avoir un thread/process mais je fait des check sur TID/PID..
+                - Ecrire un test et fix..
+
+
+    - remotectypes
+        - pretty sur I can get rid of PointerToStruct64/PointerToStruct32
+
+
+    - winutils
+        - some stuff in winutils.py are not documented.
+            - Fix/test/refactor API + doc
+
+    - winobject\exception.py
+        - large part could be rewritten with ctypes-generation extended-def
+
+    - add winobject/window.py + winobject/kernobj.py to System()
+        - Some test/doc on both
+
+
+    - wintrust doc:
+        add : https://blogs.msdn.microsoft.com/winsdk/2016/01/05/why-cryptcatadmincalchashfromfilehandle-fails-with-a-seemingly-unexpected-error-code/
+
+    - COM:
+        - test https://msdn.microsoft.com/en-us/library/vs/alm/hh846255(v=vs.85).aspx
+
+    - Hook
+        - Probleme with enabled hook + gc
+            - Prevent GC of enabled hook ?
+            - Raise on deletion of enabled hook ?
+                - if I implem __del__ -> we have a __del__ cycle -> no gc (gc.garbage instead..)
+
+
+Documentation
+    * verif samples
+    * windows.bits
+
+RESSOURCE
+    * read http://www.codeproject.com/Articles/18975/Listing-Used-Files

ctypes_generation/com_parser.py

@@ -0,0 +1,152 @@
+from collections import namedtuple
+
+import dummy_wintypes
+import struct_parser
+from winstruct import WinStruct, WinUnion, WinStructType, Ptr, WinEnum
+from simpleparser import *
+
+
+class WinComParser(Parser):
+    PARAM_INFO =  ["__RPC__deref_out", "__RPC__in", "__RPC__deref_out_opt", "__RPC__out", "__RPC__in_opt",
+        "__RPC__deref_opt_inout_opt", "__in", "__out", "__out_opt", "__in_opt", "__inout",
+        "__reserved", "__RPC__in_opt_string", "__RPC__inout_opt", "__RPC__in_string", "__deref_out_opt"]
+    PARAM_INFO_WITH_VALUE = ["__RPC__in_ecount", "__RPC__out_ecount_part", "__RPC__in_ecount_full",
+            "__RPC__in_range", "__RPC__out_ecount_full", "__out_ecount_opt", "__out_ecount", "__in_ecount_opt",
+            "__in_ecount", "__out_bcount_opt", "__out_bcount", "__in_bcount", "__in_bcount_opt", "__RPC__out_ecount_full_string"]
+
+    def __init__(self, data):
+        # data = self.initial_processing(data)
+        #print(data)
+        super(WinComParser, self).__init__(data)
+
+    def assert_name(self, expected_name, n=None):
+        if n is None:
+            n = self.assert_token_type(NameToken)
+        if n.value != expected_name:
+            raise ParsingError("Expected name {0} got {1} instead".format(expected_name, n.value))
+        return n
+
+    def parse_argument(self):
+        byreflevel = 0
+        # Pass __RPC__deref_out
+        while self.peek() in [NameToken(x) for x in self.PARAM_INFO + self.PARAM_INFO_WITH_VALUE]:
+            ign = self.assert_token_type(NameToken)
+            if ign.value in self.PARAM_INFO_WITH_VALUE:
+                # pass __RPC__in_ecount(cNames)
+                self.assert_token_type(OpenParenthesisToken)
+                while type(self.peek()) != CloseParenthesisToken:
+                    self.next_token()
+                self.next_token()
+        if self.peek() == KeywordToken("const"):
+            self.next_token()
+        type_name = self.assert_token_type(NameToken)
+        if type_name.value.startswith("_"):
+            print("type_name = <{0}> might be a PARAM_INFO".format(type_name.value))
+
+        while type(self.peek()) == StarToken:
+            byreflevel += 1
+            discard_star = self.next_token()
+        arg_name = self.assert_token_type(NameToken)
+        if type(self.peek()) not in [CommaToken, CloseParenthesisToken]:
+            raise ParsingError("COM PARSING: argument decl should finish by <,> or <)> (arg {0})".format(type_name.value))
+        if type(self.peek()) == CommaToken:
+            self.assert_token_type(CommaToken)
+        return type_name.value, byreflevel, arg_name.value
+
+    def parse_method(self):
+        ret_type = self.assert_token_type(NameToken)
+        #print(ret_type)
+        self.assert_token_type(OpenParenthesisToken)
+        self.assert_name("STDMETHODCALLTYPE")
+        #if type(self.peek()) == StarToken:
+        self.assert_token_type(StarToken)
+        method_name = self.assert_token_type(NameToken)
+        #print("Parsing method <{0}>".format(method_name))
+        self.assert_token_type(CloseParenthesisToken)
+
+
+        args = []
+        self.assert_token_type(OpenParenthesisToken)
+        while type(self.peek()) != CloseParenthesisToken:
+            if self.peek().value == "...": #TODO: '...' token ?
+                self.next_token()
+                # '...' should be last token before ')'
+                args.append("...") # Put a type ?
+                assert type(self.peek()) == CloseParenthesisToken
+                continue
+            args.append(self.parse_argument())
+            #print("Pass <{0}>".format(p))
+        self.next_token()
+        self.assert_token_type(ColonToken)
+        return ret_type.value, method_name.value, args
+
+    def parse(self):
+        tok = self.peek()
+        if type(tok) == NameToken and tok.value == "@IID:":
+            self.next_token()
+            iid = self.assert_token_type(NameToken).value
+        else:
+            iid = None
+        self.assert_keyword("typedef")
+        self.assert_keyword("struct")
+
+        vtable_name = self.assert_token_type(NameToken).value
+        self.assert_token_type(OpenBracketToken)
+        self.assert_name("BEGIN_INTERFACE")
+
+        res = WinCOMVTABLE(vtable_name)
+        res.iid = iid
+
+        while self.peek() != NameToken("END_INTERFACE"):
+            ret_type, method_name, args = self.parse_method()
+            #print("Method name is {0}".format(method_name))
+            for arg in args:
+                pass
+                #print("    Param is {0}".format(arg))
+            res.add_method(ret_type, method_name, args)
+        end_interface = self.assert_name("END_INTERFACE")
+        self.assert_token_type(CloseBracketToken)
+        typdef = self.assert_token_type(NameToken)
+        # Do a real thing able to see multiple typedef..
+        typedefptr = None
+        if type(self.peek()) == CommaToken:
+            self.next_token()
+            self.assert_token_type(StarToken)
+            typedefptr = self.assert_token_type(NameToken).value
+        self.assert_token_type(ColonToken)
+        res.typedefptr = typedefptr
+        return res
+
+        #print(self.data)
+
+Method = namedtuple("Method", ["ret_type", "name", "args", 'functype'])
+MethodArg = namedtuple("MethodArg", ["type", "byreflevel", "name"])
+class WinCOMVTABLE(object):
+    def __init__(self, vtbl_name):
+        self.vtbl_name = vtbl_name
+        if not vtbl_name.endswith("Vtbl"):
+            raise ValueError("Com interface are expected to finish by <Vtbl> got <{0}".format(vtbl.name))
+        self.name = vtbl_name[:-len("Vtbl")]
+        self.methods = []
+
+    def add_method(self, ret_type, method_name, args):
+        new_args = []
+        functype = 'stdcall'
+        if args[-1] == "...":
+            print("{0}.{1} is a cdecl COM method".format(self.name, method_name))
+            args = args[:-1]
+            functype = 'cdecl'
+        for type, byreflevel, name in args:
+            if type in ["long", "int"]:
+                type = type.upper()
+            new_args.append(MethodArg(type, byreflevel, name))
+
+        if ret_type in ["long", "int"]:
+            ret_type = ret_type.upper()
+        self.methods.append(Method(ret_type, method_name, new_args, functype))
+
+
+if __name__ == "__main__":
+    import sys
+    x = WinComParser(open(sys.argv[1]).read()).parse()
+    print(x)

ctypes_generation/def_parser.py

@@ -7,12 +7,11 @@ class WinDef(object):
     def __init__(self, name, code):
         self.name = name
         self.code = code
-        
+
     def generate_ctypes(self):
-        return """{0} = Flag("{0}", {1})""".format(self.name, self.code)
+        return """{0} = make_flag("{0}", {1})""".format(self.name, self.code)
 
 class WinDefParser(Parser):
-
     def parse_define(self):
         self.assert_token_type(SharpToken)
         define = self.assert_token_type(NameToken)
@@ -26,9 +25,26 @@ class WinDefParser(Parser):
                 v = v[:-1]
             define_value.append(v)
         return WinDef(define_name.value, " ".join(define_value))
-        
+
     def parse(self):
         res = []
         while self.peek() is not None:
             res.append(self.parse_define())
-        return res 
+        return res
+
+# A simple Fake parser for NTSTATUS
+class NtStatusParser(object):
+    def __init__(self, data):
+        self.input = data
+
+    def parse(self):
+        nt_status_defs = []
+        for line in self.input.split("\n"):
+            if not line:
+                continue
+            code, name, descr = line.split("|", 2)
+            code = int(code, 0)
+            descr = re.sub(" +", " ", descr[:-1]) # remove \n
+            descr = descr.replace('"', "'")
+            nt_status_defs.append((code, name, descr))
+        return nt_status_defs

ctypes_generation/definitions/com/IBackgroundCopyCallback.txt

@@ -0,0 +1,32 @@
+typedef struct IBackgroundCopyCallbackVtbl
+    {
+        BEGIN_INTERFACE
+
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+            __RPC__in IBackgroundCopyCallback * This,
+            /* [in] */ __RPC__in REFIID riid,
+            /* [annotation][iid_is][out] */
+            __RPC__deref_out  void **ppvObject);
+
+        ULONG ( STDMETHODCALLTYPE *AddRef )(
+            __RPC__in IBackgroundCopyCallback * This);
+
+        ULONG ( STDMETHODCALLTYPE *Release )(
+            __RPC__in IBackgroundCopyCallback * This);
+
+        HRESULT ( STDMETHODCALLTYPE *JobTransferred )(
+            __RPC__in IBackgroundCopyCallback * This,
+            /* [in] */ __RPC__in_opt IBackgroundCopyJob *pJob);
+
+        HRESULT ( STDMETHODCALLTYPE *JobError )(
+            __RPC__in IBackgroundCopyCallback * This,
+            /* [in] */ __RPC__in_opt IBackgroundCopyJob *pJob,
+            /* [in] */ __RPC__in_opt IBackgroundCopyError *pError);
+
+        HRESULT ( STDMETHODCALLTYPE *JobModification )(
+            __RPC__in IBackgroundCopyCallback * This,
+            /* [in] */ __RPC__in_opt IBackgroundCopyJob *pJob,
+            /* [in] */ DWORD dwReserved);
+
+        END_INTERFACE
+    } IBackgroundCopyCallbackVtbl;

ctypes_generation/definitions/com/IBackgroundCopyError.txt

@@ -0,0 +1,41 @@
+typedef struct IBackgroundCopyErrorVtbl
+    {
+        BEGIN_INTERFACE
+
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+            __RPC__in IBackgroundCopyError * This,
+            /* [in] */ __RPC__in REFIID riid,
+            /* [annotation][iid_is][out] */
+            __RPC__deref_out  void **ppvObject);
+
+        ULONG ( STDMETHODCALLTYPE *AddRef )(
+            __RPC__in IBackgroundCopyError * This);
+
+        ULONG ( STDMETHODCALLTYPE *Release )(
+            __RPC__in IBackgroundCopyError * This);
+
+        HRESULT ( STDMETHODCALLTYPE *GetError )(
+            __RPC__in IBackgroundCopyError * This,
+            /* [ref][out] */ __RPC__out BG_ERROR_CONTEXT *pContext,
+            /* [ref][out] */ __RPC__out HRESULT *pCode);
+
+        HRESULT ( STDMETHODCALLTYPE *GetFile )(
+            __RPC__in IBackgroundCopyError * This,
+            /* [out] */ __RPC__deref_out_opt IBackgroundCopyFile **pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *GetErrorDescription )(
+            __RPC__in IBackgroundCopyError * This,
+            /* [in] */ DWORD LanguageId,
+            /* [ref][out] */ __RPC__deref_out_opt LPWSTR *pErrorDescription);
+
+        HRESULT ( STDMETHODCALLTYPE *GetErrorContextDescription )(
+            __RPC__in IBackgroundCopyError * This,
+            /* [in] */ DWORD LanguageId,
+            /* [ref][out] */ __RPC__deref_out_opt LPWSTR *pContextDescription);
+
+        HRESULT ( STDMETHODCALLTYPE *GetProtocol )(
+            __RPC__in IBackgroundCopyError * This,
+            /* [ref][out] */ __RPC__deref_out_opt LPWSTR *pProtocol);
+
+        END_INTERFACE
+    } IBackgroundCopyErrorVtbl;

ctypes_generation/definitions/com/IBackgroundCopyFile.txt

@@ -0,0 +1,30 @@
+typedef struct IBackgroundCopyFileVtbl
+    {
+        BEGIN_INTERFACE
+
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+            __RPC__in IBackgroundCopyFile * This,
+            /* [in] */ __RPC__in REFIID riid,
+            /* [annotation][iid_is][out] */
+            __RPC__deref_out  void **ppvObject);
+
+        ULONG ( STDMETHODCALLTYPE *AddRef )(
+            __RPC__in IBackgroundCopyFile * This);
+
+        ULONG ( STDMETHODCALLTYPE *Release )(
+            __RPC__in IBackgroundCopyFile * This);
+
+        HRESULT ( STDMETHODCALLTYPE *GetRemoteName )(
+            __RPC__in IBackgroundCopyFile * This,
+            /* [out] */ __RPC__deref_out_opt LPWSTR *pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *GetLocalName )(
+            __RPC__in IBackgroundCopyFile * This,
+            /* [out] */ __RPC__deref_out_opt LPWSTR *pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *GetProgress )(
+            __RPC__in IBackgroundCopyFile * This,
+            /* [out] */ __RPC__out BG_FILE_PROGRESS *pVal);
+
+        END_INTERFACE
+    } IBackgroundCopyFileVtbl;

ctypes_generation/definitions/com/IBackgroundCopyJob.txt

@@ -0,0 +1,147 @@
+typedef struct IBackgroundCopyJobVtbl
+    {
+        BEGIN_INTERFACE
+
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [in] */ __RPC__in REFIID riid,
+            /* [annotation][iid_is][out] */
+            __RPC__deref_out  void **ppvObject);
+
+        ULONG ( STDMETHODCALLTYPE *AddRef )(
+            __RPC__in IBackgroundCopyJob * This);
+
+        ULONG ( STDMETHODCALLTYPE *Release )(
+            __RPC__in IBackgroundCopyJob * This);
+
+        HRESULT ( STDMETHODCALLTYPE *AddFileSet )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [in] */ ULONG cFileCount,
+            /* [size_is][in] */ __RPC__in_ecount_full(cFileCount) BG_FILE_INFO *pFileSet);
+
+        HRESULT ( STDMETHODCALLTYPE *AddFile )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [in] */ __RPC__in LPCWSTR RemoteUrl,
+            /* [in] */ __RPC__in LPCWSTR LocalName);
+
+        HRESULT ( STDMETHODCALLTYPE *EnumFiles )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__deref_out_opt IEnumBackgroundCopyFiles **pEnum);
+
+        HRESULT ( STDMETHODCALLTYPE *Suspend )(
+            __RPC__in IBackgroundCopyJob * This);
+
+        HRESULT ( STDMETHODCALLTYPE *Resume )(
+            __RPC__in IBackgroundCopyJob * This);
+
+        HRESULT ( STDMETHODCALLTYPE *Cancel )(
+            __RPC__in IBackgroundCopyJob * This);
+
+        HRESULT ( STDMETHODCALLTYPE *Complete )(
+            __RPC__in IBackgroundCopyJob * This);
+
+        HRESULT ( STDMETHODCALLTYPE *GetId )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__out GUID *pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *GetType )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__out BG_JOB_TYPE *pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *GetProgress )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__out BG_JOB_PROGRESS *pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *GetTimes )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__out BG_JOB_TIMES *pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *GetState )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__out BG_JOB_STATE *pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *GetError )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__deref_out_opt IBackgroundCopyError **ppError);
+
+        HRESULT ( STDMETHODCALLTYPE *GetOwner )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__deref_out_opt LPWSTR *pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *SetDisplayName )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [in] */ __RPC__in LPCWSTR Val);
+
+        HRESULT ( STDMETHODCALLTYPE *GetDisplayName )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__deref_out_opt LPWSTR *pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *SetDescription )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [in] */ __RPC__in LPCWSTR Val);
+
+        HRESULT ( STDMETHODCALLTYPE *GetDescription )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__deref_out_opt LPWSTR *pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *SetPriority )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [in] */ BG_JOB_PRIORITY Val);
+
+        HRESULT ( STDMETHODCALLTYPE *GetPriority )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__out BG_JOB_PRIORITY *pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *SetNotifyFlags )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [in] */ ULONG Val);
+
+        HRESULT ( STDMETHODCALLTYPE *GetNotifyFlags )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__out ULONG *pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *SetNotifyInterface )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [in] */ __RPC__in_opt IUnknown *Val);
+
+        HRESULT ( STDMETHODCALLTYPE *GetNotifyInterface )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__deref_out_opt IUnknown **pVal);
+
+        HRESULT ( STDMETHODCALLTYPE *SetMinimumRetryDelay )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [in] */ ULONG Seconds);
+
+        HRESULT ( STDMETHODCALLTYPE *GetMinimumRetryDelay )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__out ULONG *Seconds);
+
+        HRESULT ( STDMETHODCALLTYPE *SetNoProgressTimeout )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [in] */ ULONG Seconds);
+
+        HRESULT ( STDMETHODCALLTYPE *GetNoProgressTimeout )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__out ULONG *Seconds);
+
+        HRESULT ( STDMETHODCALLTYPE *GetErrorCount )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__out ULONG *Errors);
+
+        HRESULT ( STDMETHODCALLTYPE *SetProxySettings )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [in] */ BG_JOB_PROXY_USAGE ProxyUsage,
+            /* [unique][string][in] */ __RPC__in_opt_string const WCHAR *ProxyList,
+            /* [unique][string][in] */ __RPC__in_opt_string const WCHAR *ProxyBypassList);
+
+        HRESULT ( STDMETHODCALLTYPE *GetProxySettings )(
+            __RPC__in IBackgroundCopyJob * This,
+            /* [out] */ __RPC__out BG_JOB_PROXY_USAGE *pProxyUsage,
+            /* [out] */ __RPC__deref_out_opt LPWSTR *pProxyList,
+            /* [out] */ __RPC__deref_out_opt LPWSTR *pProxyBypassList);
+
+        HRESULT ( STDMETHODCALLTYPE *TakeOwnership )(
+            __RPC__in IBackgroundCopyJob * This);
+
+        END_INTERFACE
+    } IBackgroundCopyJobVtbl;

ctypes_generation/definitions/com/IBackgroundCopyManager.txt

@@ -0,0 +1,41 @@
+typedef struct IBackgroundCopyManagerVtbl
+    {
+        BEGIN_INTERFACE
+
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+            __RPC__in IBackgroundCopyManager * This,
+            /* [in] */ __RPC__in REFIID riid,
+            /* [annotation][iid_is][out] */
+            __RPC__deref_out  void **ppvObject);
+
+        ULONG ( STDMETHODCALLTYPE *AddRef )(
+            __RPC__in IBackgroundCopyManager * This);
+
+        ULONG ( STDMETHODCALLTYPE *Release )(
+            __RPC__in IBackgroundCopyManager * This);
+
+        HRESULT ( STDMETHODCALLTYPE *CreateJob )(
+            __RPC__in IBackgroundCopyManager * This,
+            /* [in] */ __RPC__in LPCWSTR DisplayName,
+            /* [in] */ BG_JOB_TYPE Type,
+            /* [out] */ __RPC__out GUID *pJobId,
+            /* [out] */ __RPC__deref_out_opt IBackgroundCopyJob **ppJob);
+
+        HRESULT ( STDMETHODCALLTYPE *GetJob )(
+            __RPC__in IBackgroundCopyManager * This,
+            /* [in] */ __RPC__in REFGUID jobID,
+            /* [out] */ __RPC__deref_out_opt IBackgroundCopyJob **ppJob);
+
+        HRESULT ( STDMETHODCALLTYPE *EnumJobs )(
+            __RPC__in IBackgroundCopyManager * This,
+            /* [in] */ DWORD dwFlags,
+            /* [out] */ __RPC__deref_out_opt IEnumBackgroundCopyJobs **ppEnum);
+
+        HRESULT ( STDMETHODCALLTYPE *GetErrorDescription )(
+            __RPC__in IBackgroundCopyManager * This,
+            /* [in] */ HRESULT hResult,
+            /* [in] */ DWORD LanguageId,
+            /* [out] */ __RPC__deref_out_opt LPWSTR *pErrorDescription);
+
+        END_INTERFACE
+    } IBackgroundCopyManagerVtbl;

ctypes_generation/definitions/com/ICallFrame.txt

@@ -0,0 +1,127 @@
+typedef struct ICallFrameVtbl
+    {
+        BEGIN_INTERFACE
+
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+            ICallFrame * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */
+            __RPC__deref_out  void **ppvObject);
+
+        ULONG ( STDMETHODCALLTYPE *AddRef )(
+            ICallFrame * This);
+
+        ULONG ( STDMETHODCALLTYPE *Release )(
+            ICallFrame * This);
+
+        HRESULT ( STDMETHODCALLTYPE *GetInfo )(
+            ICallFrame * This,
+            /* [out] */ CALLFRAMEINFO *pInfo);
+
+        HRESULT ( STDMETHODCALLTYPE *GetIIDAndMethod )(
+            ICallFrame * This,
+            /* [out] */ IID *pIID,
+            /* [out] */ ULONG *piMethod);
+
+        HRESULT ( STDMETHODCALLTYPE *GetNames )(
+            ICallFrame * This,
+            /* [annotation][out] */
+            __deref_out_opt  LPWSTR *pwszInterface,
+            /* [annotation][out] */
+            __deref_out_opt  LPWSTR *pwszMethod);
+
+        PVOID ( STDMETHODCALLTYPE *GetStackLocation )(
+            ICallFrame * This);
+
+        VOID ( STDMETHODCALLTYPE *SetStackLocation )(
+            ICallFrame * This,
+            /* [in] */ PVOID pvStack);
+
+        VOID ( STDMETHODCALLTYPE *SetReturnValue )(
+            ICallFrame * This,
+            /* [in] */ HRESULT hr);
+
+        HRESULT ( STDMETHODCALLTYPE *GetReturnValue )(
+            ICallFrame * This);
+
+        HRESULT ( STDMETHODCALLTYPE *GetParamInfo )(
+            ICallFrame * This,
+            /* [in] */ ULONG iparam,
+            /* [out] */ CALLFRAMEPARAMINFO *pInfo);
+
+        HRESULT ( STDMETHODCALLTYPE *SetParam )(
+            ICallFrame * This,
+            /* [in] */ ULONG iparam,
+            /* [in] */ VARIANT *pvar);
+
+        HRESULT ( STDMETHODCALLTYPE *GetParam )(
+            ICallFrame * This,
+            /* [in] */ ULONG iparam,
+            /* [out] */ VARIANT *pvar);
+
+        HRESULT ( STDMETHODCALLTYPE *Copy )(
+            ICallFrame * This,
+            /* [in] */ CALLFRAME_COPY copyControl,
+            /* [in] */ ICallFrameWalker *pWalker,
+            /* [out] */ ICallFrame **ppFrame);
+
+        HRESULT ( STDMETHODCALLTYPE *Free )(
+            ICallFrame * This,
+            /* [in] */ ICallFrame *pframeArgsDest,
+            /* [in] */ ICallFrameWalker *pWalkerDestFree,
+            /* [in] */ ICallFrameWalker *pWalkerCopy,
+            /* [in] */ DWORD freeFlags,
+            /* [in] */ ICallFrameWalker *pWalkerFree,
+            /* [in] */ DWORD nullFlags);
+
+        HRESULT ( STDMETHODCALLTYPE *FreeParam )(
+            ICallFrame * This,
+            /* [in] */ ULONG iparam,
+            /* [in] */ DWORD freeFlags,
+            /* [in] */ ICallFrameWalker *pWalkerFree,
+            /* [in] */ DWORD nullFlags);
+
+        HRESULT ( STDMETHODCALLTYPE *WalkFrame )(
+            ICallFrame * This,
+            /* [in] */ DWORD walkWhat,
+            /* [in] */ ICallFrameWalker *pWalker);
+
+        HRESULT ( STDMETHODCALLTYPE *GetMarshalSizeMax )(
+            ICallFrame * This,
+            /* [in] */ CALLFRAME_MARSHALCONTEXT *pmshlContext,
+            /* [in] */ MSHLFLAGS mshlflags,
+            /* [out] */ ULONG *pcbBufferNeeded);
+
+        HRESULT ( STDMETHODCALLTYPE *Marshal )(
+            ICallFrame * This,
+            /* [in] */ CALLFRAME_MARSHALCONTEXT *pmshlContext,
+            /* [in] */ MSHLFLAGS mshlflags,
+            /* [size_is][in] */ PVOID pBuffer,
+            /* [in] */ ULONG cbBuffer,
+            /* [out] */ ULONG *pcbBufferUsed,
+            /* [out] */ RPCOLEDATAREP *pdataRep,
+            /* [out] */ ULONG *prpcFlags);
+
+        HRESULT ( STDMETHODCALLTYPE *Unmarshal )(
+            ICallFrame * This,
+            /* [size_is][in] */ PVOID pBuffer,
+            /* [in] */ ULONG cbBuffer,
+            /* [in] */ RPCOLEDATAREP dataRep,
+            /* [in] */ CALLFRAME_MARSHALCONTEXT *pcontext,
+            /* [out] */ ULONG *pcbUnmarshalled);
+
+        HRESULT ( STDMETHODCALLTYPE *ReleaseMarshalData )(
+            ICallFrame * This,
+            /* [size_is][in] */ PVOID pBuffer,
+            /* [in] */ ULONG cbBuffer,
+            /* [in] */ ULONG ibFirstRelease,
+            /* [in] */ RPCOLEDATAREP dataRep,
+            /* [in] */ CALLFRAME_MARSHALCONTEXT *pcontext);
+
+        HRESULT ( STDMETHODCALLTYPE *Invoke )(
+            ICallFrame * This,
+            /* [in] */ void *pvReceiver,
+            ...);
+
+        END_INTERFACE
+    } ICallFrameVtbl;

ctypes_generation/definitions/com/ICallFrameEvents.txt

@@ -0,0 +1,22 @@
+typedef struct ICallFrameEventsVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ICallFrameEvents * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ICallFrameEvents * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ICallFrameEvents * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *OnCall )( 
+            ICallFrameEvents * This,
+            /* [in] */ ICallFrame *pFrame);
+        
+        END_INTERFACE
+    } ICallFrameEventsVtbl;

ctypes_generation/definitions/com/ICallFrameWalker.txt

@@ -0,0 +1,25 @@
+typedef struct ICallFrameWalkerVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ICallFrameWalker * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ICallFrameWalker * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ICallFrameWalker * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *OnWalkInterface )( 
+            ICallFrameWalker * This,
+            /* [in] */ REFIID iid,
+            /* [in] */ PVOID *ppvInterface,
+            /* [in] */ BOOL fIn,
+            /* [in] */ BOOL fOut);
+        
+        END_INTERFACE
+    } ICallFrameWalkerVtbl;

ctypes_generation/definitions/com/ICallInterceptor.txt

@@ -0,0 +1,56 @@
+typedef struct ICallInterceptorVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ICallInterceptor * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ICallInterceptor * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ICallInterceptor * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *CallIndirect )( 
+            ICallInterceptor * This,
+            /* [out] */ HRESULT *phrReturn,
+            /* [in] */ ULONG iMethod,
+            /* [in] */ void *pvArgs,
+            /* [out] */ ULONG *cbArgs);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetMethodInfo )( 
+            ICallInterceptor * This,
+            /* [in] */ ULONG iMethod,
+            /* [out] */ CALLFRAMEINFO *pInfo,
+            /* [annotation][out] */ 
+            __deref_out_opt  LPWSTR *pwszMethod);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetStackSize )( 
+            ICallInterceptor * This,
+            /* [in] */ ULONG iMethod,
+            /* [out] */ ULONG *cbArgs);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetIID )( 
+            ICallInterceptor * This,
+            /* [annotation][out] */ 
+            __out_opt  IID *piid,
+            /* [annotation][out] */ 
+            __out_opt  BOOL *pfDerivesFromIDispatch,
+            /* [annotation][out] */ 
+            __out_opt  ULONG *pcMethod,
+            /* [annotation][out] */ 
+            __deref_out_opt  LPWSTR *pwszInterface);
+        
+        HRESULT ( STDMETHODCALLTYPE *RegisterSink )( 
+            ICallInterceptor * This,
+            /* [in] */ ICallFrameEvents *psink);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetRegisteredSink )( 
+            ICallInterceptor * This,
+            /* [out] */ ICallFrameEvents **ppsink);
+        
+        END_INTERFACE
+    } ICallInterceptorVtbl;

ctypes_generation/definitions/com/IDispatch.txt

@@ -0,0 +1,47 @@
+typedef struct IDispatchVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            __RPC__in IDispatch * This,
+            /* [in] */ __RPC__in REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            __RPC__in IDispatch * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            __RPC__in IDispatch * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )( 
+            __RPC__in IDispatch * This,
+            /* [out] */ __RPC__out UINT *pctinfo);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )( 
+            __RPC__in IDispatch * This,
+            /* [in] */ UINT iTInfo,
+            /* [in] */ LCID lcid,
+            /* [out] */ __RPC__deref_out_opt ITypeInfo **ppTInfo);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )( 
+            __RPC__in IDispatch * This,
+            /* [in] */ __RPC__in REFIID riid,
+            /* [size_is][in] */ __RPC__in_ecount_full(cNames) LPOLESTR *rgszNames,
+            /* [range][in] */ __RPC__in_range(0,16384) UINT cNames,
+            /* [in] */ LCID lcid,
+            /* [size_is][out] */ __RPC__out_ecount_full(cNames) DISPID *rgDispId);
+        
+        /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )( 
+            IDispatch * This,
+            /* [in] */ DISPID dispIdMember,
+            /* [in] */ REFIID riid,
+            /* [in] */ LCID lcid,
+            /* [in] */ WORD wFlags,
+            /* [out][in] */ DISPPARAMS *pDispParams,
+            /* [out] */ VARIANT *pVarResult,
+            /* [out] */ EXCEPINFO *pExcepInfo,
+            /* [out] */ UINT *puArgErr);
+        
+        END_INTERFACE
+    } IDispatchVtbl;

ctypes_generation/definitions/com/IEnumBackgroundCopyFiles.txt

@@ -0,0 +1,39 @@
+typedef struct IEnumBackgroundCopyFilesVtbl
+    {
+        BEGIN_INTERFACE
+
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+            __RPC__in IEnumBackgroundCopyFiles * This,
+            /* [in] */ __RPC__in REFIID riid,
+            /* [annotation][iid_is][out] */
+            __RPC__deref_out  void **ppvObject);
+
+        ULONG ( STDMETHODCALLTYPE *AddRef )(
+            __RPC__in IEnumBackgroundCopyFiles * This);
+
+        ULONG ( STDMETHODCALLTYPE *Release )(
+            __RPC__in IEnumBackgroundCopyFiles * This);
+
+        HRESULT ( STDMETHODCALLTYPE *Next )(
+            __RPC__in IEnumBackgroundCopyFiles * This,
+            /* [in] */ ULONG celt,
+            /* [length_is][size_is][out] */ __RPC__out_ecount_part(celt, pceltFetched ? *pceltFetched : celt) IBackgroundCopyFile **rgelt,
+            /* [unique][out][in] */ __RPC__inout_opt ULONG *pceltFetched);
+
+        HRESULT ( STDMETHODCALLTYPE *Skip )(
+            __RPC__in IEnumBackgroundCopyFiles * This,
+            /* [in] */ ULONG celt);
+
+        HRESULT ( STDMETHODCALLTYPE *Reset )(
+            __RPC__in IEnumBackgroundCopyFiles * This);
+
+        HRESULT ( STDMETHODCALLTYPE *Clone )(
+            __RPC__in IEnumBackgroundCopyFiles * This,
+            /* [out] */ __RPC__deref_out_opt IEnumBackgroundCopyFiles **ppenum);
+
+        HRESULT ( STDMETHODCALLTYPE *GetCount )(
+            __RPC__in IEnumBackgroundCopyFiles * This,
+            /* [out] */ __RPC__out ULONG *puCount);
+
+        END_INTERFACE
+    } IEnumBackgroundCopyFilesVtbl;

ctypes_generation/definitions/com/IEnumBackgroundCopyJobs.txt

@@ -0,0 +1,39 @@
+typedef struct IEnumBackgroundCopyJobsVtbl
+    {
+        BEGIN_INTERFACE
+
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+            __RPC__in IEnumBackgroundCopyJobs * This,
+            /* [in] */ __RPC__in REFIID riid,
+            /* [annotation][iid_is][out] */
+            __RPC__deref_out  void **ppvObject);
+
+        ULONG ( STDMETHODCALLTYPE *AddRef )(
+            __RPC__in IEnumBackgroundCopyJobs * This);
+
+        ULONG ( STDMETHODCALLTYPE *Release )(
+            __RPC__in IEnumBackgroundCopyJobs * This);
+
+        HRESULT ( STDMETHODCALLTYPE *Next )(
+            __RPC__in IEnumBackgroundCopyJobs * This,
+            /* [in] */ ULONG celt,
+            /* [length_is][size_is][out] */ __RPC__out_ecount_part(celt, pceltFetched ? *pceltFetched : celt) IBackgroundCopyJob **rgelt,
+            /* [unique][out][in] */ __RPC__inout_opt ULONG *pceltFetched);
+
+        HRESULT ( STDMETHODCALLTYPE *Skip )(
+            __RPC__in IEnumBackgroundCopyJobs * This,
+            /* [in] */ ULONG celt);
+
+        HRESULT ( STDMETHODCALLTYPE *Reset )(
+            __RPC__in IEnumBackgroundCopyJobs * This);
+
+        HRESULT ( STDMETHODCALLTYPE *Clone )(
+            __RPC__in IEnumBackgroundCopyJobs * This,
+            /* [out] */ __RPC__deref_out_opt IEnumBackgroundCopyJobs **ppenum);
+
+        HRESULT ( STDMETHODCALLTYPE *GetCount )(
+            __RPC__in IEnumBackgroundCopyJobs * This,
+            /* [out] */ __RPC__out ULONG *puCount);
+
+        END_INTERFACE
+    } IEnumBackgroundCopyJobsVtbl;

ctypes_generation/definitions/com/IEnumVARIANT.txt

@@ -0,0 +1,35 @@
+typedef struct IEnumVARIANTVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            __RPC__in IEnumVARIANT * This,
+            /* [in] */ __RPC__in REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            __RPC__in IEnumVARIANT * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            __RPC__in IEnumVARIANT * This);
+        
+        /* [local] */ HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IEnumVARIANT * This,
+            /* [in] */ ULONG celt,
+            /* [length_is][size_is][out] */ VARIANT *rgVar,
+            /* [out] */ ULONG *pCeltFetched);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            __RPC__in IEnumVARIANT * This,
+            /* [in] */ ULONG celt);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            __RPC__in IEnumVARIANT * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            __RPC__in IEnumVARIANT * This,
+            /* [out] */ __RPC__deref_out_opt IEnumVARIANT **ppEnum);
+        
+        END_INTERFACE
+    } IEnumVARIANTVtbl;

ctypes_generation/definitions/com/IEnumWbemClassObject.txt

@@ -0,0 +1,42 @@
+typedef struct IEnumWbemClassObjectVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            __RPC__in IEnumWbemClassObject * This,
+            /* [in] */ __RPC__in REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            __RPC__in IEnumWbemClassObject * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            __RPC__in IEnumWbemClassObject * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            __RPC__in IEnumWbemClassObject * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            __RPC__in IEnumWbemClassObject * This,
+            /* [in] */ long lTimeout,
+            /* [in] */ ULONG uCount,
+            /* [length_is][size_is][out] */ __RPC__out_ecount_part(uCount, *puReturned) IWbemClassObject **apObjects,
+            /* [out] */ __RPC__out ULONG *puReturned);
+        
+        HRESULT ( STDMETHODCALLTYPE *NextAsync )( 
+            __RPC__in IEnumWbemClassObject * This,
+            /* [in] */ ULONG uCount,
+            /* [in] */ __RPC__in_opt IWbemObjectSink *pSink);
+        
+        HRESULT ( STDMETHODCALLTYPE *Clone )( 
+            __RPC__in IEnumWbemClassObject * This,
+            /* [out] */ __RPC__deref_out_opt IEnumWbemClassObject **ppEnum);
+        
+        HRESULT ( STDMETHODCALLTYPE *Skip )( 
+            __RPC__in IEnumWbemClassObject * This,
+            /* [in] */ long lTimeout,
+            /* [in] */ ULONG nCount);
+        
+        END_INTERFACE
+    } IEnumWbemClassObjectVtbl;

ctypes_generation/definitions/com/INetFwPolicy2.txt

@@ -0,0 +1,153 @@
+typedef struct INetFwPolicy2Vtbl
+{
+    BEGIN_INTERFACE
+
+    HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+        INetFwPolicy2 * This,
+        /* [in] */ REFIID riid,
+        /* [annotation][iid_is][out] */
+        __RPC__deref_out  void **ppvObject);
+
+    ULONG ( STDMETHODCALLTYPE *AddRef )(
+        INetFwPolicy2 * This);
+
+    ULONG ( STDMETHODCALLTYPE *Release )(
+        INetFwPolicy2 * This);
+
+    HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )(
+        INetFwPolicy2 * This,
+        /* [out] */ UINT *pctinfo);
+
+    HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
+        INetFwPolicy2 * This,
+        /* [in] */ UINT iTInfo,
+        /* [in] */ LCID lcid,
+        /* [out] */ ITypeInfo **ppTInfo);
+
+    HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )(
+        INetFwPolicy2 * This,
+        /* [in] */ REFIID riid,
+        /* [size_is][in] */ LPOLESTR *rgszNames,
+        /* [range][in] */ UINT cNames,
+        /* [in] */ LCID lcid,
+        /* [size_is][out] */ DISPID *rgDispId);
+
+    /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )(
+        INetFwPolicy2 * This,
+        /* [in] */ DISPID dispIdMember,
+        /* [in] */ REFIID riid,
+        /* [in] */ LCID lcid,
+        /* [in] */ WORD wFlags,
+        /* [out][in] */ DISPPARAMS *pDispParams,
+        /* [out] */ VARIANT *pVarResult,
+        /* [out] */ EXCEPINFO *pExcepInfo,
+        /* [out] */ UINT *puArgErr);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_CurrentProfileTypes )(
+        INetFwPolicy2 * This,
+        /* [retval][out] */ long *profileTypesBitmask);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_FirewallEnabled )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [retval][out] */ VARIANT_BOOL *enabled);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_FirewallEnabled )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [in] */ VARIANT_BOOL enabled);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ExcludedInterfaces )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [retval][out] */ VARIANT *interfaces);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ExcludedInterfaces )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [in] */ VARIANT interfaces);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_BlockAllInboundTraffic )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [retval][out] */ VARIANT_BOOL *Block);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_BlockAllInboundTraffic )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [in] */ VARIANT_BOOL Block);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_NotificationsDisabled )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [retval][out] */ VARIANT_BOOL *disabled);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_NotificationsDisabled )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [in] */ VARIANT_BOOL disabled);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_UnicastResponsesToMulticastBroadcastDisabled )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [retval][out] */ VARIANT_BOOL *disabled);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_UnicastResponsesToMulticastBroadcastDisabled )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [in] */ VARIANT_BOOL disabled);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Rules )(
+        INetFwPolicy2 * This,
+        /* [retval][out] */ INetFwRules **rules);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ServiceRestriction )(
+        INetFwPolicy2 * This,
+        /* [retval][out] */ INetFwServiceRestriction **ServiceRestriction);
+
+    /* [id] */ HRESULT ( STDMETHODCALLTYPE *EnableRuleGroup )(
+        INetFwPolicy2 * This,
+        /* [in] */ long profileTypesBitmask,
+        /* [in] */ BSTR group,
+        /* [in] */ VARIANT_BOOL enable);
+
+    /* [id] */ HRESULT ( STDMETHODCALLTYPE *IsRuleGroupEnabled )(
+        INetFwPolicy2 * This,
+        /* [in] */ long profileTypesBitmask,
+        /* [in] */ BSTR group,
+        /* [retval][out] */ VARIANT_BOOL *enabled);
+
+    /* [id] */ HRESULT ( STDMETHODCALLTYPE *RestoreLocalFirewallDefaults )(
+        INetFwPolicy2 * This);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DefaultInboundAction )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [retval][out] */ NET_FW_ACTION *action);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DefaultInboundAction )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [in] */ NET_FW_ACTION action);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_DefaultOutboundAction )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [retval][out] */ NET_FW_ACTION *action);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_DefaultOutboundAction )(
+        INetFwPolicy2 * This,
+        /* [in] */ NET_FW_PROFILE_TYPE2 profileType,
+        /* [in] */ NET_FW_ACTION action);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_IsRuleGroupCurrentlyEnabled )(
+        INetFwPolicy2 * This,
+        /* [in] */ BSTR group,
+        /* [retval][out] */ VARIANT_BOOL *enabled);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_LocalPolicyModifyState )(
+        INetFwPolicy2 * This,
+        /* [retval][out] */ NET_FW_MODIFY_STATE *modifyState);
+
+    END_INTERFACE
+} INetFwPolicy2Vtbl;

ctypes_generation/definitions/com/INetFwRuleVtbl.txt

@@ -0,0 +1,191 @@
+typedef struct INetFwRuleVtbl
+{
+    BEGIN_INTERFACE
+
+    HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+        INetFwRule * This,
+        /* [in] */ REFIID riid,
+        /* [annotation][iid_is][out] */
+        __RPC__deref_out  void **ppvObject);
+
+    ULONG ( STDMETHODCALLTYPE *AddRef )(
+        INetFwRule * This);
+
+    ULONG ( STDMETHODCALLTYPE *Release )(
+        INetFwRule * This);
+
+    HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )(
+        INetFwRule * This,
+        /* [out] */ UINT *pctinfo);
+
+    HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
+        INetFwRule * This,
+        /* [in] */ UINT iTInfo,
+        /* [in] */ LCID lcid,
+        /* [out] */ ITypeInfo **ppTInfo);
+
+    HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )(
+        INetFwRule * This,
+        /* [in] */ REFIID riid,
+        /* [size_is][in] */ LPOLESTR *rgszNames,
+        /* [range][in] */ UINT cNames,
+        /* [in] */ LCID lcid,
+        /* [size_is][out] */ DISPID *rgDispId);
+
+    /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )(
+        INetFwRule * This,
+        /* [in] */ DISPID dispIdMember,
+        /* [in] */ REFIID riid,
+        /* [in] */ LCID lcid,
+        /* [in] */ WORD wFlags,
+        /* [out][in] */ DISPPARAMS *pDispParams,
+        /* [out] */ VARIANT *pVarResult,
+        /* [out] */ EXCEPINFO *pExcepInfo,
+        /* [out] */ UINT *puArgErr);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Name )(
+        INetFwRule * This,
+        /* [retval][out] */ BSTR *name);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Name )(
+        INetFwRule * This,
+        /* [in] */ BSTR name);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Description )(
+        INetFwRule * This,
+        /* [retval][out] */ BSTR *desc);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Description )(
+        INetFwRule * This,
+        /* [in] */ BSTR desc);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ApplicationName )(
+        INetFwRule * This,
+        /* [retval][out] */ BSTR *imageFileName);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ApplicationName )(
+        INetFwRule * This,
+        /* [in] */ BSTR imageFileName);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_ServiceName )(
+        INetFwRule * This,
+        /* [retval][out] */ BSTR *serviceName);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_ServiceName )(
+        INetFwRule * This,
+        /* [in] */ BSTR serviceName);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Protocol )(
+        INetFwRule * This,
+        /* [retval][out] */ LONG *protocol);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Protocol )(
+        INetFwRule * This,
+        /* [in] */ LONG protocol);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_LocalPorts )(
+        INetFwRule * This,
+        /* [retval][out] */ BSTR *portNumbers);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_LocalPorts )(
+        INetFwRule * This,
+        /* [in] */ BSTR portNumbers);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RemotePorts )(
+        INetFwRule * This,
+        /* [retval][out] */ BSTR *portNumbers);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RemotePorts )(
+        INetFwRule * This,
+        /* [in] */ BSTR portNumbers);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_LocalAddresses )(
+        INetFwRule * This,
+        /* [retval][out] */ BSTR *localAddrs);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_LocalAddresses )(
+        INetFwRule * This,
+        /* [in] */ BSTR localAddrs);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_RemoteAddresses )(
+        INetFwRule * This,
+        /* [retval][out] */ BSTR *remoteAddrs);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_RemoteAddresses )(
+        INetFwRule * This,
+        /* [in] */ BSTR remoteAddrs);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_IcmpTypesAndCodes )(
+        INetFwRule * This,
+        /* [retval][out] */ BSTR *icmpTypesAndCodes);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_IcmpTypesAndCodes )(
+        INetFwRule * This,
+        /* [in] */ BSTR icmpTypesAndCodes);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Direction )(
+        INetFwRule * This,
+        /* [retval][out] */ NET_FW_RULE_DIRECTION *dir);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Direction )(
+        INetFwRule * This,
+        /* [in] */ NET_FW_RULE_DIRECTION dir);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Interfaces )(
+        INetFwRule * This,
+        /* [retval][out] */ VARIANT *interfaces);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Interfaces )(
+        INetFwRule * This,
+        /* [in] */ VARIANT interfaces);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_InterfaceTypes )(
+        INetFwRule * This,
+        /* [retval][out] */ BSTR *interfaceTypes);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_InterfaceTypes )(
+        INetFwRule * This,
+        /* [in] */ BSTR interfaceTypes);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Enabled )(
+        INetFwRule * This,
+        /* [retval][out] */ VARIANT_BOOL *enabled);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Enabled )(
+        INetFwRule * This,
+        /* [in] */ VARIANT_BOOL enabled);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Grouping )(
+        INetFwRule * This,
+        /* [retval][out] */ BSTR *context);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Grouping )(
+        INetFwRule * This,
+        /* [in] */ BSTR context);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Profiles )(
+        INetFwRule * This,
+        /* [retval][out] */ long *profileTypesBitmask);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Profiles )(
+        INetFwRule * This,
+        /* [in] */ long profileTypesBitmask);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_EdgeTraversal )(
+        INetFwRule * This,
+        /* [retval][out] */ VARIANT_BOOL *enabled);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_EdgeTraversal )(
+        INetFwRule * This,
+        /* [in] */ VARIANT_BOOL enabled);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Action )(
+        INetFwRule * This,
+        /* [retval][out] */ NET_FW_ACTION *action);
+
+    /* [propput][id] */ HRESULT ( STDMETHODCALLTYPE *put_Action )(
+        INetFwRule * This,
+        /* [in] */ NET_FW_ACTION action);
+
+    END_INTERFACE
+} INetFwRuleVtbl;

ctypes_generation/definitions/com/INetFwRulesVtbl.txt

@@ -0,0 +1,68 @@
+typedef struct INetFwRulesVtbl
+{
+    BEGIN_INTERFACE
+
+    HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+        INetFwRules * This,
+        /* [in] */ REFIID riid,
+        /* [annotation][iid_is][out] */
+        __RPC__deref_out  void **ppvObject);
+
+    ULONG ( STDMETHODCALLTYPE *AddRef )(
+        INetFwRules * This);
+
+    ULONG ( STDMETHODCALLTYPE *Release )(
+        INetFwRules * This);
+
+    HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )(
+        INetFwRules * This,
+        /* [out] */ UINT *pctinfo);
+
+    HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
+        INetFwRules * This,
+        /* [in] */ UINT iTInfo,
+        /* [in] */ LCID lcid,
+        /* [out] */ ITypeInfo **ppTInfo);
+
+    HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )(
+        INetFwRules * This,
+        /* [in] */ REFIID riid,
+        /* [size_is][in] */ LPOLESTR *rgszNames,
+        /* [range][in] */ UINT cNames,
+        /* [in] */ LCID lcid,
+        /* [size_is][out] */ DISPID *rgDispId);
+
+    /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )(
+        INetFwRules * This,
+        /* [in] */ DISPID dispIdMember,
+        /* [in] */ REFIID riid,
+        /* [in] */ LCID lcid,
+        /* [in] */ WORD wFlags,
+        /* [out][in] */ DISPPARAMS *pDispParams,
+        /* [out] */ VARIANT *pVarResult,
+        /* [out] */ EXCEPINFO *pExcepInfo,
+        /* [out] */ UINT *puArgErr);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Count )(
+        INetFwRules * This,
+        /* [retval][out] */ long *count);
+
+    /* [id] */ HRESULT ( STDMETHODCALLTYPE *Add )(
+        INetFwRules * This,
+        /* [in] */ INetFwRule *rule);
+
+    /* [id] */ HRESULT ( STDMETHODCALLTYPE *Remove )(
+        INetFwRules * This,
+        /* [in] */ BSTR name);
+
+    /* [id] */ HRESULT ( STDMETHODCALLTYPE *Item )(
+        INetFwRules * This,
+        /* [in] */ BSTR name,
+        /* [retval][out] */ INetFwRule **rule);
+
+    /* [restricted][propget][id] */ HRESULT ( STDMETHODCALLTYPE *get__NewEnum )(
+        INetFwRules * This,
+        /* [retval][out] */ IUnknown **newEnum);
+
+    END_INTERFACE
+} INetFwRulesVtbl;

ctypes_generation/definitions/com/INetFwServiceRestriction.txt

@@ -0,0 +1,64 @@
+typedef struct INetFwServiceRestrictionVtbl
+{
+    BEGIN_INTERFACE
+
+    HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+        INetFwServiceRestriction * This,
+        /* [in] */ REFIID riid,
+        /* [annotation][iid_is][out] */
+        __RPC__deref_out  void **ppvObject);
+
+    ULONG ( STDMETHODCALLTYPE *AddRef )(
+        INetFwServiceRestriction * This);
+
+    ULONG ( STDMETHODCALLTYPE *Release )(
+        INetFwServiceRestriction * This);
+
+    HRESULT ( STDMETHODCALLTYPE *GetTypeInfoCount )(
+        INetFwServiceRestriction * This,
+        /* [out] */ UINT *pctinfo);
+
+    HRESULT ( STDMETHODCALLTYPE *GetTypeInfo )(
+        INetFwServiceRestriction * This,
+        /* [in] */ UINT iTInfo,
+        /* [in] */ LCID lcid,
+        /* [out] */ ITypeInfo **ppTInfo);
+
+    HRESULT ( STDMETHODCALLTYPE *GetIDsOfNames )(
+        INetFwServiceRestriction * This,
+        /* [in] */ REFIID riid,
+        /* [size_is][in] */ LPOLESTR *rgszNames,
+        /* [range][in] */ UINT cNames,
+        /* [in] */ LCID lcid,
+        /* [size_is][out] */ DISPID *rgDispId);
+
+    /* [local] */ HRESULT ( STDMETHODCALLTYPE *Invoke )(
+        INetFwServiceRestriction * This,
+        /* [in] */ DISPID dispIdMember,
+        /* [in] */ REFIID riid,
+        /* [in] */ LCID lcid,
+        /* [in] */ WORD wFlags,
+        /* [out][in] */ DISPPARAMS *pDispParams,
+        /* [out] */ VARIANT *pVarResult,
+        /* [out] */ EXCEPINFO *pExcepInfo,
+        /* [out] */ UINT *puArgErr);
+
+    /* [id] */ HRESULT ( STDMETHODCALLTYPE *RestrictService )(
+        INetFwServiceRestriction * This,
+        /* [in] */ BSTR serviceName,
+        /* [in] */ BSTR appName,
+        /* [in] */ VARIANT_BOOL restrictService,
+        /* [in] */ VARIANT_BOOL serviceSidRestricted);
+
+    /* [id] */ HRESULT ( STDMETHODCALLTYPE *ServiceRestricted )(
+        INetFwServiceRestriction * This,
+        /* [in] */ BSTR serviceName,
+        /* [in] */ BSTR appName,
+        /* [retval][out] */ VARIANT_BOOL *serviceRestricted);
+
+    /* [propget][id] */ HRESULT ( STDMETHODCALLTYPE *get_Rules )(
+        INetFwServiceRestriction * This,
+        /* [retval][out] */ INetFwRules **rules);
+
+    END_INTERFACE
+} INetFwServiceRestrictionVtbl;

ctypes_generation/definitions/com/IPersistFile.txt

@@ -0,0 +1,43 @@
+typedef struct IPersistFileVtbl
+ {
+     BEGIN_INTERFACE
+
+     HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+         __RPC__in IPersistFile * This,
+         /* [in] */ __RPC__in REFIID riid,
+         /* [annotation][iid_is][out] */
+         __RPC__deref_out  void **ppvObject);
+
+     ULONG ( STDMETHODCALLTYPE *AddRef )(
+         __RPC__in IPersistFile * This);
+
+     ULONG ( STDMETHODCALLTYPE *Release )(
+         __RPC__in IPersistFile * This);
+
+     HRESULT ( STDMETHODCALLTYPE *GetClassID )(
+         __RPC__in IPersistFile * This,
+         /* [out] */ __RPC__out CLSID *pClassID);
+
+     HRESULT ( STDMETHODCALLTYPE *IsDirty )(
+         __RPC__in IPersistFile * This);
+
+     HRESULT ( STDMETHODCALLTYPE *Load )(
+         __RPC__in IPersistFile * This,
+         /* [in] */ __RPC__in LPCOLESTR pszFileName,
+         /* [in] */ DWORD dwMode);
+
+     HRESULT ( STDMETHODCALLTYPE *Save )(
+         __RPC__in IPersistFile * This,
+         /* [unique][in] */ __RPC__in_opt LPCOLESTR pszFileName,
+         /* [in] */ BOOL fRemember);
+
+     HRESULT ( STDMETHODCALLTYPE *SaveCompleted )(
+         __RPC__in IPersistFile * This,
+         /* [unique][in] */ __RPC__in_opt LPCOLESTR pszFileName);
+
+     HRESULT ( STDMETHODCALLTYPE *GetCurFile )(
+         __RPC__in IPersistFile * This,
+         /* [out] */ __RPC__deref_out_opt LPOLESTR *ppszFileName);
+
+     END_INTERFACE
+} IPersistFileVtbl;

ctypes_generation/definitions/com/IShellLinkAVtbl.txt

@@ -0,0 +1,101 @@
+typedef struct IShellLinkAVtbl
+{
+    BEGIN_INTERFACE
+
+    HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+        __RPC__in IShellLinkA * This,
+        /* [in] */ __RPC__in REFIID riid,
+        /* [annotation][iid_is][out] */
+        __RPC__deref_out  void **ppvObject);
+
+    ULONG ( STDMETHODCALLTYPE *AddRef )(
+        __RPC__in IShellLinkA * This);
+
+    ULONG ( STDMETHODCALLTYPE *Release )(
+        __RPC__in IShellLinkA * This);
+
+    HRESULT ( STDMETHODCALLTYPE *GetPath )(
+        __RPC__in IShellLinkA * This,
+        /* [size_is][string][out] */ __RPC__out_ecount_full_string(cch) LPSTR pszFile,
+        /* [in] */ int cch,
+        /* [unique][out][in] */ __RPC__inout_opt WIN32_FIND_DATAA *pfd,
+        /* [in] */ DWORD fFlags);
+
+    HRESULT ( STDMETHODCALLTYPE *GetIDList )(
+        __RPC__in IShellLinkA * This,
+        /* [out] */ __RPC__deref_out_opt PIDLIST_ABSOLUTE *ppidl);
+
+    HRESULT ( STDMETHODCALLTYPE *SetIDList )(
+        __RPC__in IShellLinkA * This,
+        /* [in] */ __RPC__in PCIDLIST_ABSOLUTE pidl);
+
+    HRESULT ( STDMETHODCALLTYPE *GetDescription )(
+        __RPC__in IShellLinkA * This,
+        /* [size_is][string][out] */ __RPC__out_ecount_full_string(cch) LPSTR pszName,
+        /* [in] */ int cch);
+
+    HRESULT ( STDMETHODCALLTYPE *SetDescription )(
+        __RPC__in IShellLinkA * This,
+        /* [string][in] */ __RPC__in_string LPCSTR pszName);
+
+    HRESULT ( STDMETHODCALLTYPE *GetWorkingDirectory )(
+        __RPC__in IShellLinkA * This,
+        /* [size_is][string][out] */ __RPC__out_ecount_full_string(cch) LPSTR pszDir,
+        /* [in] */ int cch);
+
+    HRESULT ( STDMETHODCALLTYPE *SetWorkingDirectory )(
+        __RPC__in IShellLinkA * This,
+        /* [string][in] */ __RPC__in_string LPCSTR pszDir);
+
+    HRESULT ( STDMETHODCALLTYPE *GetArguments )(
+        __RPC__in IShellLinkA * This,
+        /* [size_is][string][out] */ __RPC__out_ecount_full_string(cch) LPSTR pszArgs,
+        /* [in] */ int cch);
+
+    HRESULT ( STDMETHODCALLTYPE *SetArguments )(
+        __RPC__in IShellLinkA * This,
+        /* [string][in] */ __RPC__in_string LPCSTR pszArgs);
+
+    HRESULT ( STDMETHODCALLTYPE *GetHotkey )(
+        __RPC__in IShellLinkA * This,
+        /* [out] */ __RPC__out WORD *pwHotkey);
+
+    HRESULT ( STDMETHODCALLTYPE *SetHotkey )(
+        __RPC__in IShellLinkA * This,
+        /* [in] */ WORD wHotkey);
+
+    HRESULT ( STDMETHODCALLTYPE *GetShowCmd )(
+        __RPC__in IShellLinkA * This,
+        /* [out] */ __RPC__out int *piShowCmd);
+
+    HRESULT ( STDMETHODCALLTYPE *SetShowCmd )(
+        __RPC__in IShellLinkA * This,
+        /* [in] */ int iShowCmd);
+
+    HRESULT ( STDMETHODCALLTYPE *GetIconLocation )(
+        __RPC__in IShellLinkA * This,
+        /* [size_is][string][out] */ __RPC__out_ecount_full_string(cch) LPSTR pszIconPath,
+        /* [in] */ int cch,
+        /* [out] */ __RPC__out int *piIcon);
+
+    HRESULT ( STDMETHODCALLTYPE *SetIconLocation )(
+        __RPC__in IShellLinkA * This,
+        /* [string][in] */ __RPC__in_string LPCSTR pszIconPath,
+        /* [in] */ int iIcon);
+
+    HRESULT ( STDMETHODCALLTYPE *SetRelativePath )(
+        __RPC__in IShellLinkA * This,
+        /* [string][in] */ __RPC__in_string LPCSTR pszPathRel,
+        /* [in] */ DWORD dwReserved);
+
+    HRESULT ( STDMETHODCALLTYPE *Resolve )(
+        __RPC__in IShellLinkA * This,
+        /* [unique][in] */ __RPC__in_opt HWND hwnd,
+        /* [in] */ DWORD fFlags);
+
+    HRESULT ( STDMETHODCALLTYPE *SetPath )(
+        __RPC__in IShellLinkA * This,
+        /* [string][in] */ __RPC__in_string LPCSTR pszFile);
+
+    END_INTERFACE
+} IShellLinkAVtbl;

ctypes_generation/definitions/com/IShellLinkW.txt

@@ -0,0 +1,101 @@
+typedef struct IShellLinkWVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            __RPC__in IShellLinkW * This,
+            /* [in] */ __RPC__in REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            __RPC__in IShellLinkW * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            __RPC__in IShellLinkW * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPath )( 
+            __RPC__in IShellLinkW * This,
+            /* [size_is][string][out] */ __RPC__out_ecount_full_string(cch) LPWSTR pszFile,
+            /* [in] */ int cch,
+            /* [unique][out][in] */ __RPC__inout_opt WIN32_FIND_DATAW *pfd,
+            /* [in] */ DWORD fFlags);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetIDList )( 
+            __RPC__in IShellLinkW * This,
+            /* [out] */ __RPC__deref_out_opt PIDLIST_ABSOLUTE *ppidl);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetIDList )( 
+            __RPC__in IShellLinkW * This,
+            /* [unique][in] */ __RPC__in_opt PCIDLIST_ABSOLUTE pidl);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDescription )( 
+            __RPC__in IShellLinkW * This,
+            /* [size_is][string][out] */ __RPC__out_ecount_full_string(cch) LPWSTR pszName,
+            int cch);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetDescription )( 
+            __RPC__in IShellLinkW * This,
+            /* [string][in] */ __RPC__in_string LPCWSTR pszName);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetWorkingDirectory )( 
+            __RPC__in IShellLinkW * This,
+            /* [size_is][string][out] */ __RPC__out_ecount_full_string(cch) LPWSTR pszDir,
+            int cch);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetWorkingDirectory )( 
+            __RPC__in IShellLinkW * This,
+            /* [string][in] */ __RPC__in_string LPCWSTR pszDir);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetArguments )( 
+            __RPC__in IShellLinkW * This,
+            /* [size_is][string][out] */ __RPC__out_ecount_full_string(cch) LPWSTR pszArgs,
+            /* [in] */ int cch);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetArguments )( 
+            __RPC__in IShellLinkW * This,
+            /* [string][in] */ __RPC__in_string LPCWSTR pszArgs);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetHotkey )( 
+            __RPC__in IShellLinkW * This,
+            /* [out] */ __RPC__out WORD *pwHotkey);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetHotkey )( 
+            __RPC__in IShellLinkW * This,
+            /* [in] */ WORD wHotkey);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetShowCmd )( 
+            __RPC__in IShellLinkW * This,
+            /* [out] */ __RPC__out int *piShowCmd);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetShowCmd )( 
+            __RPC__in IShellLinkW * This,
+            /* [in] */ int iShowCmd);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetIconLocation )( 
+            __RPC__in IShellLinkW * This,
+            /* [size_is][string][out] */ __RPC__out_ecount_full_string(cch) LPWSTR pszIconPath,
+            /* [in] */ int cch,
+            /* [out] */ __RPC__out int *piIcon);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetIconLocation )( 
+            __RPC__in IShellLinkW * This,
+            /* [string][in] */ __RPC__in_string LPCWSTR pszIconPath,
+            /* [in] */ int iIcon);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetRelativePath )( 
+            __RPC__in IShellLinkW * This,
+            /* [string][in] */ __RPC__in_string LPCWSTR pszPathRel,
+            /* [in] */ DWORD dwReserved);
+        
+        HRESULT ( STDMETHODCALLTYPE *Resolve )( 
+            __RPC__in IShellLinkW * This,
+            /* [unique][in] */ __RPC__in_opt HWND hwnd,
+            /* [in] */ DWORD fFlags);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPath )( 
+            __RPC__in IShellLinkW * This,
+            /* [string][in] */ __RPC__in_string LPCWSTR pszFile);
+        
+        END_INTERFACE
+    } IShellLinkWVtbl;

ctypes_generation/definitions/com/IUnknownVtbl.txt

@@ -0,0 +1,18 @@
+typedef struct IUnknownVtbl
+{
+    BEGIN_INTERFACE
+
+    HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+        IUnknown * This,
+        /* [in] */ REFIID riid,
+        /* [annotation][iid_is][out] */
+        __RPC__deref_out  void **ppvObject);
+
+    ULONG ( STDMETHODCALLTYPE *AddRef )(
+        IUnknown * This);
+
+    ULONG ( STDMETHODCALLTYPE *Release )(
+        IUnknown * This);
+
+    END_INTERFACE
+} IUnknownVtbl;

ctypes_generation/definitions/com/IWbemCallResultVtbl.txt

@@ -0,0 +1,38 @@
+typedef struct IWbemCallResultVtbl
+{
+    BEGIN_INTERFACE
+
+    HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+        __RPC__in IWbemCallResult * This,
+        /* [in] */ __RPC__in REFIID riid,
+        /* [annotation][iid_is][out] */
+        __RPC__deref_out  void **ppvObject);
+
+    ULONG ( STDMETHODCALLTYPE *AddRef )(
+        __RPC__in IWbemCallResult * This);
+
+    ULONG ( STDMETHODCALLTYPE *Release )(
+        __RPC__in IWbemCallResult * This);
+
+    HRESULT ( STDMETHODCALLTYPE *GetResultObject )(
+        __RPC__in IWbemCallResult * This,
+        /* [in] */ long lTimeout,
+        /* [out] */ __RPC__deref_out_opt IWbemClassObject **ppResultObject);
+
+    HRESULT ( STDMETHODCALLTYPE *GetResultString )(
+        __RPC__in IWbemCallResult * This,
+        /* [in] */ long lTimeout,
+        /* [out] */ __RPC__deref_out_opt BSTR *pstrResultString);
+
+    HRESULT ( STDMETHODCALLTYPE *GetResultServices )(
+        __RPC__in IWbemCallResult * This,
+        /* [in] */ long lTimeout,
+        /* [out] */ __RPC__deref_out_opt IWbemServices **ppServices);
+
+    HRESULT ( STDMETHODCALLTYPE *GetCallStatus )(
+        __RPC__in IWbemCallResult * This,
+        /* [in] */ long lTimeout,
+        /* [out] */ __RPC__out long *plStatus);
+
+    END_INTERFACE
+} IWbemCallResultVtbl;

ctypes_generation/definitions/com/IWbemClassObjectVtbl.txt

@@ -0,0 +1,143 @@
+typedef struct IWbemClassObjectVtbl
+{
+    BEGIN_INTERFACE
+
+    HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+        IWbemClassObject * This,
+        /* [in] */ REFIID riid,
+        /* [annotation][iid_is][out] */
+        __RPC__deref_out  void **ppvObject);
+
+    ULONG ( STDMETHODCALLTYPE *AddRef )(
+        IWbemClassObject * This);
+
+    ULONG ( STDMETHODCALLTYPE *Release )(
+        IWbemClassObject * This);
+
+    HRESULT ( STDMETHODCALLTYPE *GetQualifierSet )(
+        IWbemClassObject * This,
+        /* [out] */ IWbemQualifierSet **ppQualSet);
+
+    HRESULT ( STDMETHODCALLTYPE *Get )(
+        IWbemClassObject * This,
+        /* [string][in] */ LPCWSTR wszName,
+        /* [in] */ long lFlags,
+        /* [unique][in][out] */ VARIANT *pVal,
+        /* [unique][in][out] */ CIMTYPE *pType,
+        /* [unique][in][out] */ long *plFlavor);
+
+    HRESULT ( STDMETHODCALLTYPE *Put )(
+        IWbemClassObject * This,
+        /* [string][in] */ LPCWSTR wszName,
+        /* [in] */ long lFlags,
+        /* [in] */ VARIANT *pVal,
+        /* [in] */ CIMTYPE Type);
+
+    HRESULT ( STDMETHODCALLTYPE *Delete )(
+        IWbemClassObject * This,
+        /* [string][in] */ LPCWSTR wszName);
+
+    HRESULT ( STDMETHODCALLTYPE *GetNames )(
+        IWbemClassObject * This,
+        /* [string][in] */ LPCWSTR wszQualifierName,
+        /* [in] */ long lFlags,
+        /* [in] */ VARIANT *pQualifierVal,
+        /* [out] */ SAFEARRAY * *pNames);
+
+    HRESULT ( STDMETHODCALLTYPE *BeginEnumeration )(
+        IWbemClassObject * This,
+        /* [in] */ long lEnumFlags);
+
+    HRESULT ( STDMETHODCALLTYPE *Next )(
+        IWbemClassObject * This,
+        /* [in] */ long lFlags,
+        /* [unique][in][out] */ BSTR *strName,
+        /* [unique][in][out] */ VARIANT *pVal,
+        /* [unique][in][out] */ CIMTYPE *pType,
+        /* [unique][in][out] */ long *plFlavor);
+
+    HRESULT ( STDMETHODCALLTYPE *EndEnumeration )(
+        IWbemClassObject * This);
+
+    HRESULT ( STDMETHODCALLTYPE *GetPropertyQualifierSet )(
+        IWbemClassObject * This,
+        /* [string][in] */ LPCWSTR wszProperty,
+        /* [out] */ IWbemQualifierSet **ppQualSet);
+
+    HRESULT ( STDMETHODCALLTYPE *Clone )(
+        IWbemClassObject * This,
+        /* [out] */ IWbemClassObject **ppCopy);
+
+    HRESULT ( STDMETHODCALLTYPE *GetObjectText )(
+        IWbemClassObject * This,
+        /* [in] */ long lFlags,
+        /* [out] */ BSTR *pstrObjectText);
+
+    HRESULT ( STDMETHODCALLTYPE *SpawnDerivedClass )(
+        IWbemClassObject * This,
+        /* [in] */ long lFlags,
+        /* [out] */ IWbemClassObject **ppNewClass);
+
+    HRESULT ( STDMETHODCALLTYPE *SpawnInstance )(
+        IWbemClassObject * This,
+        /* [in] */ long lFlags,
+        /* [out] */ IWbemClassObject **ppNewInstance);
+
+    HRESULT ( STDMETHODCALLTYPE *CompareTo )(
+        IWbemClassObject * This,
+        /* [in] */ long lFlags,
+        /* [in] */ IWbemClassObject *pCompareTo);
+
+    HRESULT ( STDMETHODCALLTYPE *GetPropertyOrigin )(
+        IWbemClassObject * This,
+        /* [string][in] */ LPCWSTR wszName,
+        /* [out] */ BSTR *pstrClassName);
+
+    HRESULT ( STDMETHODCALLTYPE *InheritsFrom )(
+        IWbemClassObject * This,
+        /* [in] */ LPCWSTR strAncestor);
+
+    HRESULT ( STDMETHODCALLTYPE *GetMethod )(
+        IWbemClassObject * This,
+        /* [string][in] */ LPCWSTR wszName,
+        /* [in] */ long lFlags,
+        /* [out] */ IWbemClassObject **ppInSignature,
+        /* [out] */ IWbemClassObject **ppOutSignature);
+
+    HRESULT ( STDMETHODCALLTYPE *PutMethod )(
+        IWbemClassObject * This,
+        /* [string][in] */ LPCWSTR wszName,
+        /* [in] */ long lFlags,
+        /* [in] */ IWbemClassObject *pInSignature,
+        /* [in] */ IWbemClassObject *pOutSignature);
+
+    HRESULT ( STDMETHODCALLTYPE *DeleteMethod )(
+        IWbemClassObject * This,
+        /* [string][in] */ LPCWSTR wszName);
+
+    HRESULT ( STDMETHODCALLTYPE *BeginMethodEnumeration )(
+        IWbemClassObject * This,
+        /* [in] */ long lEnumFlags);
+
+    HRESULT ( STDMETHODCALLTYPE *NextMethod )(
+        IWbemClassObject * This,
+        /* [in] */ long lFlags,
+        /* [unique][in][out] */ BSTR *pstrName,
+        /* [unique][in][out] */ IWbemClassObject **ppInSignature,
+        /* [unique][in][out] */ IWbemClassObject **ppOutSignature);
+
+    HRESULT ( STDMETHODCALLTYPE *EndMethodEnumeration )(
+        IWbemClassObject * This);
+
+    HRESULT ( STDMETHODCALLTYPE *GetMethodQualifierSet )(
+        IWbemClassObject * This,
+        /* [string][in] */ LPCWSTR wszMethod,
+        /* [out] */ IWbemQualifierSet **ppQualSet);
+
+    HRESULT ( STDMETHODCALLTYPE *GetMethodOrigin )(
+        IWbemClassObject * This,
+        /* [string][in] */ LPCWSTR wszMethodName,
+        /* [out] */ BSTR *pstrClassName);
+
+    END_INTERFACE
+} IWbemClassObjectVtbl;

ctypes_generation/definitions/com/IWbemContextVtbl.txt

@@ -0,0 +1,60 @@
+typedef struct IWbemContextVtbl
+{
+    BEGIN_INTERFACE
+
+    HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+        IWbemContext * This,
+        /* [in] */ REFIID riid,
+        /* [annotation][iid_is][out] */
+        __RPC__deref_out  void **ppvObject);
+
+    ULONG ( STDMETHODCALLTYPE *AddRef )(
+        IWbemContext * This);
+
+    ULONG ( STDMETHODCALLTYPE *Release )(
+        IWbemContext * This);
+
+    HRESULT ( STDMETHODCALLTYPE *Clone )(
+        IWbemContext * This,
+        /* [out] */ IWbemContext **ppNewCopy);
+
+    HRESULT ( STDMETHODCALLTYPE *GetNames )(
+        IWbemContext * This,
+        /* [in] */ long lFlags,
+        /* [out] */ SAFEARRAY * *pNames);
+
+    HRESULT ( STDMETHODCALLTYPE *BeginEnumeration )(
+        IWbemContext * This,
+        /* [in] */ long lFlags);
+
+    HRESULT ( STDMETHODCALLTYPE *Next )(
+        IWbemContext * This,
+        /* [in] */ long lFlags,
+        /* [out] */ BSTR *pstrName,
+        /* [out] */ VARIANT *pValue);
+
+    HRESULT ( STDMETHODCALLTYPE *EndEnumeration )(
+        IWbemContext * This);
+
+    HRESULT ( STDMETHODCALLTYPE *SetValue )(
+        IWbemContext * This,
+        /* [string][in] */ LPCWSTR wszName,
+        /* [in] */ long lFlags,
+        /* [in] */ VARIANT *pValue);
+
+    HRESULT ( STDMETHODCALLTYPE *GetValue )(
+        IWbemContext * This,
+        /* [string][in] */ LPCWSTR wszName,
+        /* [in] */ long lFlags,
+        /* [out] */ VARIANT *pValue);
+
+    HRESULT ( STDMETHODCALLTYPE *DeleteValue )(
+        IWbemContext * This,
+        /* [string][in] */ LPCWSTR wszName,
+        /* [in] */ long lFlags);
+
+    HRESULT ( STDMETHODCALLTYPE *DeleteAll )(
+        IWbemContext * This);
+
+    END_INTERFACE
+} IWbemContextVtbl;

ctypes_generation/definitions/com/IWbemLocatorVtbl.txt

@@ -0,0 +1,29 @@
+typedef struct IWbemLocatorVtbl
+{
+    BEGIN_INTERFACE
+
+    HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+        IWbemLocator * This,
+        /* [in] */ REFIID riid,
+        /* [annotation][iid_is][out] */
+        __RPC__deref_out  void **ppvObject);
+
+    ULONG ( STDMETHODCALLTYPE *AddRef )(
+        IWbemLocator * This);
+
+    ULONG ( STDMETHODCALLTYPE *Release )(
+        IWbemLocator * This);
+
+    HRESULT ( STDMETHODCALLTYPE *ConnectServer )(
+        IWbemLocator * This,
+        /* [in] */ const BSTR strNetworkResource,
+        /* [in] */ const BSTR strUser,
+        /* [in] */ const BSTR strPassword,
+        /* [in] */ const BSTR strLocale,
+        /* [in] */ long lSecurityFlags,
+        /* [in] */ const BSTR strAuthority,
+        /* [in] */ IWbemContext *pCtx,
+        /* [out] */ IWbemServices **ppNamespace);
+
+    END_INTERFACE
+} IWbemLocatorVtbl;

ctypes_generation/definitions/com/IWbemObjectSink.txt

@@ -0,0 +1,30 @@
+typedef struct IWbemObjectSinkVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            __RPC__in IWbemObjectSink * This,
+            /* [in] */ __RPC__in REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            __RPC__in IWbemObjectSink * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            __RPC__in IWbemObjectSink * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Indicate )( 
+            __RPC__in IWbemObjectSink * This,
+            /* [in] */ long lObjectCount,
+            /* [size_is][in] */ __RPC__in_ecount_full(lObjectCount) IWbemClassObject **apObjArray);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetStatus )( 
+            __RPC__in IWbemObjectSink * This,
+            /* [in] */ long lFlags,
+            /* [in] */ HRESULT hResult,
+            /* [unique][in] */ __RPC__in_opt BSTR strParam,
+            /* [unique][in] */ __RPC__in_opt IWbemClassObject *pObjParam);
+        
+        END_INTERFACE
+    } IWbemObjectSinkVtbl;

ctypes_generation/definitions/com/IWbemQualifierSet.txt

@@ -0,0 +1,54 @@
+typedef struct IWbemQualifierSetVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IWbemQualifierSet * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            __RPC__deref_out  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IWbemQualifierSet * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IWbemQualifierSet * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Get )( 
+            IWbemQualifierSet * This,
+            /* [string][in] */ LPCWSTR wszName,
+            /* [in] */ long lFlags,
+            /* [unique][in][out] */ VARIANT *pVal,
+            /* [unique][in][out] */ long *plFlavor);
+        
+        HRESULT ( STDMETHODCALLTYPE *Put )( 
+            IWbemQualifierSet * This,
+            /* [string][in] */ LPCWSTR wszName,
+            /* [in] */ VARIANT *pVal,
+            /* [in] */ long lFlavor);
+        
+        HRESULT ( STDMETHODCALLTYPE *Delete )( 
+            IWbemQualifierSet * This,
+            /* [string][in] */ LPCWSTR wszName);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetNames )( 
+            IWbemQualifierSet * This,
+            /* [in] */ long lFlags,
+            /* [out] */ SAFEARRAY * *pNames);
+        
+        HRESULT ( STDMETHODCALLTYPE *BeginEnumeration )( 
+            IWbemQualifierSet * This,
+            /* [in] */ long lFlags);
+        
+        HRESULT ( STDMETHODCALLTYPE *Next )( 
+            IWbemQualifierSet * This,
+            /* [in] */ long lFlags,
+            /* [unique][in][out] */ BSTR *pstrName,
+            /* [unique][in][out] */ VARIANT *pVal,
+            /* [unique][in][out] */ long *plFlavor);
+        
+        HRESULT ( STDMETHODCALLTYPE *EndEnumeration )( 
+            IWbemQualifierSet * This);
+        
+        END_INTERFACE
+    } IWbemQualifierSetVtbl;

ctypes_generation/definitions/com/IWbemServicesVtbl.txt

@@ -0,0 +1,185 @@
+typedef struct IWbemServicesVtbl
+{
+    BEGIN_INTERFACE
+
+    HRESULT ( STDMETHODCALLTYPE *QueryInterface )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in REFIID riid,
+        /* [annotation][iid_is][out] */
+        __RPC__deref_out  void **ppvObject);
+
+    ULONG ( STDMETHODCALLTYPE *AddRef )(
+        __RPC__in IWbemServices * This);
+
+    ULONG ( STDMETHODCALLTYPE *Release )(
+        __RPC__in IWbemServices * This);
+
+    HRESULT ( STDMETHODCALLTYPE *OpenNamespace )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strNamespace,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [unique][in][out] */ __RPC__deref_opt_inout_opt IWbemServices **ppWorkingNamespace,
+        /* [unique][in][out] */ __RPC__deref_opt_inout_opt IWbemCallResult **ppResult);
+
+    HRESULT ( STDMETHODCALLTYPE *CancelAsyncCall )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in_opt IWbemObjectSink *pSink);
+
+    HRESULT ( STDMETHODCALLTYPE *QueryObjectSink )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ long lFlags,
+        /* [out] */ __RPC__deref_out_opt IWbemObjectSink **ppResponseHandler);
+
+    HRESULT ( STDMETHODCALLTYPE *GetObject )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strObjectPath,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [unique][in][out] */ __RPC__deref_opt_inout_opt IWbemClassObject **ppObject,
+        /* [unique][in][out] */ __RPC__deref_opt_inout_opt IWbemCallResult **ppCallResult);
+
+    HRESULT ( STDMETHODCALLTYPE *GetObjectAsync )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strObjectPath,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [in] */ __RPC__in_opt IWbemObjectSink *pResponseHandler);
+
+    HRESULT ( STDMETHODCALLTYPE *PutClass )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in_opt IWbemClassObject *pObject,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [unique][in][out] */ __RPC__deref_opt_inout_opt IWbemCallResult **ppCallResult);
+
+    HRESULT ( STDMETHODCALLTYPE *PutClassAsync )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in_opt IWbemClassObject *pObject,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [in] */ __RPC__in_opt IWbemObjectSink *pResponseHandler);
+
+    HRESULT ( STDMETHODCALLTYPE *DeleteClass )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strClass,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [unique][in][out] */ __RPC__deref_opt_inout_opt IWbemCallResult **ppCallResult);
+
+    HRESULT ( STDMETHODCALLTYPE *DeleteClassAsync )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strClass,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [in] */ __RPC__in_opt IWbemObjectSink *pResponseHandler);
+
+    HRESULT ( STDMETHODCALLTYPE *CreateClassEnum )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strSuperclass,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [out] */ __RPC__deref_out_opt IEnumWbemClassObject **ppEnum);
+
+    HRESULT ( STDMETHODCALLTYPE *CreateClassEnumAsync )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strSuperclass,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [in] */ __RPC__in_opt IWbemObjectSink *pResponseHandler);
+
+    HRESULT ( STDMETHODCALLTYPE *PutInstance )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in_opt IWbemClassObject *pInst,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [unique][in][out] */ __RPC__deref_opt_inout_opt IWbemCallResult **ppCallResult);
+
+    HRESULT ( STDMETHODCALLTYPE *PutInstanceAsync )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in_opt IWbemClassObject *pInst,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [in] */ __RPC__in_opt IWbemObjectSink *pResponseHandler);
+
+    HRESULT ( STDMETHODCALLTYPE *DeleteInstance )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strObjectPath,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [unique][in][out] */ __RPC__deref_opt_inout_opt IWbemCallResult **ppCallResult);
+
+    HRESULT ( STDMETHODCALLTYPE *DeleteInstanceAsync )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strObjectPath,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [in] */ __RPC__in_opt IWbemObjectSink *pResponseHandler);
+
+    HRESULT ( STDMETHODCALLTYPE *CreateInstanceEnum )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strFilter,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [out] */ __RPC__deref_out_opt IEnumWbemClassObject **ppEnum);
+
+    HRESULT ( STDMETHODCALLTYPE *CreateInstanceEnumAsync )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strFilter,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [in] */ __RPC__in_opt IWbemObjectSink *pResponseHandler);
+
+    HRESULT ( STDMETHODCALLTYPE *ExecQuery )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strQueryLanguage,
+        /* [in] */ __RPC__in const BSTR strQuery,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [out] */ __RPC__deref_out_opt IEnumWbemClassObject **ppEnum);
+
+    HRESULT ( STDMETHODCALLTYPE *ExecQueryAsync )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strQueryLanguage,
+        /* [in] */ __RPC__in const BSTR strQuery,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [in] */ __RPC__in_opt IWbemObjectSink *pResponseHandler);
+
+    HRESULT ( STDMETHODCALLTYPE *ExecNotificationQuery )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strQueryLanguage,
+        /* [in] */ __RPC__in const BSTR strQuery,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [out] */ __RPC__deref_out_opt IEnumWbemClassObject **ppEnum);
+
+    HRESULT ( STDMETHODCALLTYPE *ExecNotificationQueryAsync )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strQueryLanguage,
+        /* [in] */ __RPC__in const BSTR strQuery,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [in] */ __RPC__in_opt IWbemObjectSink *pResponseHandler);
+
+    HRESULT ( STDMETHODCALLTYPE *ExecMethod )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strObjectPath,
+        /* [in] */ __RPC__in const BSTR strMethodName,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [in] */ __RPC__in_opt IWbemClassObject *pInParams,
+        /* [unique][in][out] */ __RPC__deref_opt_inout_opt IWbemClassObject **ppOutParams,
+        /* [unique][in][out] */ __RPC__deref_opt_inout_opt IWbemCallResult **ppCallResult);
+
+    HRESULT ( STDMETHODCALLTYPE *ExecMethodAsync )(
+        __RPC__in IWbemServices * This,
+        /* [in] */ __RPC__in const BSTR strObjectPath,
+        /* [in] */ __RPC__in const BSTR strMethodName,
+        /* [in] */ long lFlags,
+        /* [in] */ __RPC__in_opt IWbemContext *pCtx,
+        /* [in] */ __RPC__in_opt IWbemClassObject *pInParams,
+        /* [in] */ __RPC__in_opt IWbemObjectSink *pResponseHandler);
+
+    END_INTERFACE
+} IWbemServicesVtbl;

ctypes_generation/definitions/com/template.py

@@ -0,0 +1,15 @@
+import functools
+import ctypes
+
+
+generate_IID = IID.from_raw
+
+class COMInterface(ctypes.c_void_p):
+    _functions_ = {
+    }
+
+    def __getattr__(self, name):
+        if name in self._functions_:
+            return functools.partial(self._functions_[name], self)
+        return super(COMInterface, self).__getattribute__(name)
+

ctypes_generation/definitions/defines/comdef.txt

@@ -0,0 +1,46 @@
+#define CWCSTORAGENAME 32
+
+/* Storage instantiation modes */
+#define STGM_DIRECT             0x00000000L
+#define STGM_TRANSACTED         0x00010000L
+#define STGM_SIMPLE             0x08000000L
+
+#define STGM_READ               0x00000000L
+#define STGM_WRITE              0x00000001L
+#define STGM_READWRITE          0x00000002L
+
+#define STGM_SHARE_DENY_NONE    0x00000040L
+#define STGM_SHARE_DENY_READ    0x00000030L
+#define STGM_SHARE_DENY_WRITE   0x00000020L
+#define STGM_SHARE_EXCLUSIVE    0x00000010L
+
+#define STGM_PRIORITY           0x00040000L
+#define STGM_DELETEONRELEASE    0x04000000L
+#define STGM_NOSCRATCH          0x00100000L
+
+#define STGM_CREATE             0x00001000L
+#define STGM_CONVERT            0x00020000L
+#define STGM_FAILIFTHERE        0x00000000L
+
+#define STGM_NOSNAPSHOT         0x00200000L
+#define STGM_DIRECT_SWMR        0x00400000L
+
+/*  flags for internet asyncronous and layout docfile */
+#define ASYNC_MODE_COMPATIBILITY    0x00000001L
+#define ASYNC_MODE_DEFAULT          0x00000000L
+
+#define STGTY_REPEAT                0x00000100L
+#define STG_TOEND                   0xFFFFFFFFL
+
+#define STG_LAYOUT_SEQUENTIAL       0x00000000L
+#define STG_LAYOUT_INTERLEAVED      0x00000001L
+
+
+#define STGFMT_STORAGE          0
+#define STGFMT_NATIVE           1
+#define STGFMT_FILE             3
+#define STGFMT_ANY              4
+#define STGFMT_DOCFILE          5
+
+// This is a legacy define to allow old component to builds
+#define STGFMT_DOCUMENT         0

ctypes_generation/definitions/defines/custom_rpc_windef.txt

@@ -0,0 +1,10 @@
+#define RPC_REQUEST_TYPE_CALL  0
+#define RPC_REQUEST_TYPE_BIND  1
+
+#define RPC_RESPONSE_TYPE_BIND_OK 1
+#define RPC_RESPONSE_TYPE_FAIL 2
+#define RPC_RESPONSE_TYPE_SUCCESS 3
+
+#define BIND_IF_SYNTAX_NDR32 1
+#define BIND_IF_SYNTAX_NDR64 2
+#define BIND_IF_SYNTAX_UNKNOWN 4

ctypes_generation/definitions/defines/pipe.txt

@@ -0,0 +1,34 @@
+#define PIPE_ACCESS_INBOUND         0x00000001
+#define PIPE_ACCESS_OUTBOUND        0x00000002
+#define PIPE_ACCESS_DUPLEX          0x00000003
+
+//
+// Define the Named Pipe End flags for GetNamedPipeInfo
+//
+
+#define PIPE_CLIENT_END             0x00000000
+#define PIPE_SERVER_END             0x00000001
+
+//
+// Define the dwPipeMode values for CreateNamedPipe
+//
+
+#define PIPE_WAIT                   0x00000000
+#define PIPE_NOWAIT                 0x00000001
+#define PIPE_READMODE_BYTE          0x00000000
+#define PIPE_READMODE_MESSAGE       0x00000002
+#define PIPE_TYPE_BYTE              0x00000000
+#define PIPE_TYPE_MESSAGE           0x00000004
+#define PIPE_ACCEPT_REMOTE_CLIENTS  0x00000000
+#define PIPE_REJECT_REMOTE_CLIENTS  0x00000008
+
+//
+// Define the well known values for CreateNamedPipe nMaxInstances
+//
+
+#define PIPE_UNLIMITED_INSTANCES    255
+
+
+#define NMPWAIT_WAIT_FOREVER            0xffffffff
+#define NMPWAIT_NOWAIT                  0x00000001
+#define NMPWAIT_USE_DEFAULT_WAIT        0x00000000

ctypes_generation/definitions/defines/template.py

@@ -0,0 +1,7 @@
+import platform
+from flag import make_flag
+
+bits = platform.architecture()[0]
+bitness =  int(bits[:2])
+
+NATIVE_WORD_MAX_VALUE = 0xffffffff if bitness == 32 else 0xffffffffffffffff

ctypes_generation/definitions/defines/windef_error.txt

@@ -0,0 +1,511 @@
+#define ERROR_SUCCESS                    0
+#define ERROR_INVALID_FUNCTION           1
+#define ERROR_FILE_NOT_FOUND             2
+#define ERROR_PATH_NOT_FOUND             3
+#define ERROR_TOO_MANY_OPEN_FILES        4
+#define ERROR_ACCESS_DENIED              5
+#define ERROR_INVALID_HANDLE             6
+#define ERROR_ARENA_TRASHED              7
+#define ERROR_NOT_ENOUGH_MEMORY          8
+#define ERROR_INVALID_BLOCK              9
+#define ERROR_BAD_ENVIRONMENT            10
+#define ERROR_BAD_FORMAT                 11
+#define ERROR_INVALID_ACCESS             12
+#define ERROR_INVALID_DATA               13
+#define ERROR_OUTOFMEMORY                14
+#define ERROR_INVALID_DRIVE              15
+#define ERROR_CURRENT_DIRECTORY          16
+#define ERROR_NOT_SAME_DEVICE            17
+#define ERROR_NO_MORE_FILES              18
+#define ERROR_WRITE_PROTECT              19
+#define ERROR_BAD_UNIT                   20
+#define ERROR_NOT_READY                  21
+#define ERROR_BAD_COMMAND                22
+#define ERROR_CRC                        23
+#define ERROR_BAD_LENGTH                 24
+#define ERROR_SEEK                       25
+#define ERROR_NOT_DOS_DISK               26
+#define ERROR_SECTOR_NOT_FOUND           27
+#define ERROR_OUT_OF_PAPER               28
+#define ERROR_WRITE_FAULT                29
+#define ERROR_READ_FAULT                 30
+#define ERROR_GEN_FAILURE                31
+#define ERROR_SHARING_VIOLATION          32
+#define ERROR_LOCK_VIOLATION             33
+#define ERROR_WRONG_DISK                 34
+#define ERROR_SHARING_BUFFER_EXCEEDED    36
+#define ERROR_HANDLE_EOF                 38
+#define ERROR_HANDLE_DISK_FULL           39
+#define ERROR_NOT_SUPPORTED              50
+#define ERROR_REM_NOT_LIST               51
+#define ERROR_DUP_NAME                   52
+#define ERROR_BAD_NETPATH                53
+#define ERROR_NETWORK_BUSY               54
+#define ERROR_DEV_NOT_EXIST              55
+#define ERROR_TOO_MANY_CMDS              56
+#define ERROR_ADAP_HDW_ERR               57
+#define ERROR_BAD_NET_RESP               58
+#define ERROR_UNEXP_NET_ERR              59
+#define ERROR_BAD_REM_ADAP               60
+#define ERROR_PRINTQ_FULL                61
+#define ERROR_NO_SPOOL_SPACE             62
+#define ERROR_PRINT_CANCELLED            63
+#define ERROR_NETNAME_DELETED            64
+#define ERROR_NETWORK_ACCESS_DENIED      65
+#define ERROR_BAD_DEV_TYPE               66
+#define ERROR_BAD_NET_NAME               67
+#define ERROR_TOO_MANY_NAMES             68
+#define ERROR_TOO_MANY_SESS              69
+#define ERROR_SHARING_PAUSED             70
+#define ERROR_REQ_NOT_ACCEP              71
+#define ERROR_REDIR_PAUSED               72
+#define ERROR_FILE_EXISTS                80
+#define ERROR_CANNOT_MAKE                82
+#define ERROR_FAIL_I24                   83
+#define ERROR_OUT_OF_STRUCTURES          84
+#define ERROR_ALREADY_ASSIGNED           85
+#define ERROR_INVALID_PASSWORD           86
+#define ERROR_INVALID_PARAMETER          87
+#define ERROR_NET_WRITE_FAULT            88
+#define ERROR_NO_PROC_SLOTS              89
+#define ERROR_TOO_MANY_SEMAPHORES        100
+#define ERROR_EXCL_SEM_ALREADY_OWNED     101
+#define ERROR_SEM_IS_SET                 102
+#define ERROR_TOO_MANY_SEM_REQUESTS      103
+#define ERROR_INVALID_AT_INTERRUPT_TIME  104
+#define ERROR_SEM_OWNER_DIED             105
+#define ERROR_SEM_USER_LIMIT             106
+#define ERROR_DISK_CHANGE                107
+#define ERROR_DRIVE_LOCKED               108
+#define ERROR_BROKEN_PIPE                109
+#define ERROR_OPEN_FAILED                110
+#define ERROR_BUFFER_OVERFLOW            111
+#define ERROR_DISK_FULL                  112
+#define ERROR_NO_MORE_SEARCH_HANDLES     113
+#define ERROR_INVALID_TARGET_HANDLE      114
+#define ERROR_INVALID_CATEGORY           117
+#define ERROR_INVALID_VERIFY_SWITCH      118
+#define ERROR_BAD_DRIVER_LEVEL           119
+#define ERROR_CALL_NOT_IMPLEMENTED       120
+#define ERROR_SEM_TIMEOUT                121
+#define ERROR_INSUFFICIENT_BUFFER        122
+#define ERROR_INVALID_NAME               123
+#define ERROR_INVALID_LEVEL              124
+#define ERROR_NO_VOLUME_LABEL            125
+#define ERROR_MOD_NOT_FOUND              126
+#define ERROR_PROC_NOT_FOUND             127
+#define ERROR_WAIT_NO_CHILDREN           128
+#define ERROR_CHILD_NOT_COMPLETE         129
+#define ERROR_DIRECT_ACCESS_HANDLE       130
+#define ERROR_NEGATIVE_SEEK              131
+#define ERROR_SEEK_ON_DEVICE             132
+#define ERROR_IS_JOIN_TARGET             133
+#define ERROR_IS_JOINED                  134
+#define ERROR_IS_SUBSTED                 135
+#define ERROR_NOT_JOINED                 136
+#define ERROR_NOT_SUBSTED                137
+#define ERROR_JOIN_TO_JOIN               138
+#define ERROR_SUBST_TO_SUBST             139
+#define ERROR_JOIN_TO_SUBST              140
+#define ERROR_SUBST_TO_JOIN              141
+#define ERROR_BUSY_DRIVE                 142
+#define ERROR_SAME_DRIVE                 143
+#define ERROR_DIR_NOT_ROOT               144
+#define ERROR_DIR_NOT_EMPTY              145
+#define ERROR_IS_SUBST_PATH              146
+#define ERROR_IS_JOIN_PATH               147
+#define ERROR_PATH_BUSY                  148
+#define ERROR_IS_SUBST_TARGET            149
+#define ERROR_SYSTEM_TRACE               150
+#define ERROR_INVALID_EVENT_COUNT        151
+#define ERROR_TOO_MANY_MUXWAITERS        152
+#define ERROR_INVALID_LIST_FORMAT        153
+#define ERROR_LABEL_TOO_LONG             154
+#define ERROR_TOO_MANY_TCBS              155
+#define ERROR_SIGNAL_REFUSED             156
+#define ERROR_DISCARDED                  157
+#define ERROR_NOT_LOCKED                 158
+#define ERROR_BAD_THREADID_ADDR          159
+#define ERROR_BAD_ARGUMENTS              160
+#define ERROR_BAD_PATHNAME               161
+#define ERROR_SIGNAL_PENDING             162
+#define ERROR_MAX_THRDS_REACHED          164
+#define ERROR_LOCK_FAILED                167
+#define ERROR_BUSY                       170
+#define ERROR_CANCEL_VIOLATION           173
+#define ERROR_ATOMIC_LOCKS_NOT_SUPPORTED 174
+#define ERROR_INVALID_SEGMENT_NUMBER     180
+#define ERROR_INVALID_ORDINAL            182
+#define ERROR_ALREADY_EXISTS             183
+#define ERROR_INVALID_FLAG_NUMBER        186
+#define ERROR_SEM_NOT_FOUND              187
+#define ERROR_INVALID_STARTING_CODESEG   188
+#define ERROR_INVALID_STACKSEG           189
+#define ERROR_INVALID_MODULETYPE         190
+#define ERROR_INVALID_EXE_SIGNATURE      191
+#define ERROR_EXE_MARKED_INVALID         192
+#define ERROR_BAD_EXE_FORMAT             193
+#define ERROR_ITERATED_DATA_EXCEEDS_64k  194
+#define ERROR_INVALID_MINALLOCSIZE       195
+#define ERROR_DYNLINK_FROM_INVALID_RING  196
+#define ERROR_IOPL_NOT_ENABLED           197
+#define ERROR_INVALID_SEGDPL             198
+#define ERROR_AUTODATASEG_EXCEEDS_64k    199
+#define ERROR_RING2SEG_MUST_BE_MOVABLE   200
+#define ERROR_RELOC_CHAIN_XEEDS_SEGLIM   201
+#define ERROR_INFLOOP_IN_RELOC_CHAIN     202
+#define ERROR_ENVVAR_NOT_FOUND           203
+#define ERROR_NO_SIGNAL_SENT             205
+#define ERROR_FILENAME_EXCED_RANGE       206
+#define ERROR_RING2_STACK_IN_USE         207
+#define ERROR_META_EXPANSION_TOO_LONG    208
+#define ERROR_INVALID_SIGNAL_NUMBER      209
+#define ERROR_THREAD_1_INACTIVE          210
+#define ERROR_LOCKED                     212
+#define ERROR_TOO_MANY_MODULES           214
+#define ERROR_NESTING_NOT_ALLOWED        215
+#define ERROR_EXE_MACHINE_TYPE_MISMATCH  216
+#define ERROR_EXE_CANNOT_MODIFY_SIGNED_BINARY 217
+#define ERROR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY 218
+#define ERROR_FILE_CHECKED_OUT           220
+#define ERROR_CHECKOUT_REQUIRED          221
+#define ERROR_BAD_FILE_TYPE              222
+#define ERROR_FILE_TOO_LARGE             223
+#define ERROR_FORMS_AUTH_REQUIRED        224
+#define ERROR_VIRUS_INFECTED             225
+#define ERROR_VIRUS_DELETED              226
+#define ERROR_PIPE_LOCAL                 229
+#define ERROR_BAD_PIPE                   230
+#define ERROR_PIPE_BUSY                  231
+#define ERROR_NO_DATA                    232
+#define ERROR_PIPE_NOT_CONNECTED         233
+#define ERROR_MORE_DATA                  234
+#define ERROR_VC_DISCONNECTED            240
+#define ERROR_INVALID_EA_NAME            254
+#define ERROR_EA_LIST_INCONSISTENT       255
+#define ERROR_NO_MORE_ITEMS              259
+#define ERROR_CANNOT_COPY                266
+#define ERROR_DIRECTORY                  267
+#define ERROR_EAS_DIDNT_FIT              275
+#define ERROR_EA_FILE_CORRUPT            276
+#define ERROR_EA_TABLE_FULL              277
+#define ERROR_INVALID_EA_HANDLE          278
+#define ERROR_EAS_NOT_SUPPORTED          282
+#define ERROR_NOT_OWNER                  288
+#define ERROR_TOO_MANY_POSTS             298
+#define ERROR_PARTIAL_COPY               299
+#define ERROR_OPLOCK_NOT_GRANTED         300
+#define ERROR_INVALID_OPLOCK_PROTOCOL    301
+#define ERROR_DISK_TOO_FRAGMENTED        302
+#define ERROR_DELETE_PENDING             303
+#define ERROR_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING 304
+#define ERROR_SHORT_NAMES_NOT_ENABLED_ON_VOLUME 305
+#define ERROR_SECURITY_STREAM_IS_INCONSISTENT 306
+#define ERROR_INVALID_LOCK_RANGE         307
+#define ERROR_IMAGE_SUBSYSTEM_NOT_PRESENT 308
+#define ERROR_NOTIFICATION_GUID_ALREADY_DEFINED 309
+#define ERROR_MR_MID_NOT_FOUND           317
+#define ERROR_SCOPE_NOT_FOUND            318
+#define ERROR_FAIL_NOACTION_REBOOT       350
+#define ERROR_FAIL_SHUTDOWN              351
+#define ERROR_FAIL_RESTART               352
+#define ERROR_MAX_SESSIONS_REACHED       353
+#define ERROR_THREAD_MODE_ALREADY_BACKGROUND 400
+#define ERROR_THREAD_MODE_NOT_BACKGROUND 401
+#define ERROR_PROCESS_MODE_ALREADY_BACKGROUND 402
+#define ERROR_PROCESS_MODE_NOT_BACKGROUND 403
+#define ERROR_INVALID_ADDRESS            487
+#define ERROR_USER_PROFILE_LOAD          500
+#define ERROR_ARITHMETIC_OVERFLOW        534
+#define ERROR_PIPE_CONNECTED             535
+#define ERROR_PIPE_LISTENING             536
+#define ERROR_VERIFIER_STOP              537
+#define ERROR_ABIOS_ERROR                538
+#define ERROR_WX86_WARNING               539
+#define ERROR_WX86_ERROR                 540
+#define ERROR_TIMER_NOT_CANCELED         541
+#define ERROR_UNWIND                     542
+#define ERROR_BAD_STACK                  543
+#define ERROR_INVALID_UNWIND_TARGET      544
+#define ERROR_INVALID_PORT_ATTRIBUTES    545
+#define ERROR_PORT_MESSAGE_TOO_LONG      546
+#define ERROR_INVALID_QUOTA_LOWER        547
+#define ERROR_DEVICE_ALREADY_ATTACHED    548
+#define ERROR_INSTRUCTION_MISALIGNMENT   549
+#define ERROR_PROFILING_NOT_STARTED      550
+#define ERROR_PROFILING_NOT_STOPPED      551
+#define ERROR_COULD_NOT_INTERPRET        552
+#define ERROR_PROFILING_AT_LIMIT         553
+#define ERROR_CANT_WAIT                  554
+#define ERROR_CANT_TERMINATE_SELF        555
+#define ERROR_UNEXPECTED_MM_CREATE_ERR   556
+#define ERROR_UNEXPECTED_MM_MAP_ERROR    557
+#define ERROR_UNEXPECTED_MM_EXTEND_ERR   558
+#define ERROR_BAD_FUNCTION_TABLE         559
+#define ERROR_NO_GUID_TRANSLATION        560
+#define ERROR_INVALID_LDT_SIZE           561
+#define ERROR_INVALID_LDT_OFFSET         563
+#define ERROR_INVALID_LDT_DESCRIPTOR     564
+#define ERROR_TOO_MANY_THREADS           565
+#define ERROR_THREAD_NOT_IN_PROCESS      566
+#define ERROR_PAGEFILE_QUOTA_EXCEEDED    567
+#define ERROR_LOGON_SERVER_CONFLICT      568
+#define ERROR_SYNCHRONIZATION_REQUIRED   569
+#define ERROR_NET_OPEN_FAILED            570
+#define ERROR_IO_PRIVILEGE_FAILED        571
+#define ERROR_CONTROL_C_EXIT             572
+#define ERROR_MISSING_SYSTEMFILE         573
+#define ERROR_UNHANDLED_EXCEPTION        574
+#define ERROR_APP_INIT_FAILURE           575
+#define ERROR_PAGEFILE_CREATE_FAILED     576
+#define ERROR_INVALID_IMAGE_HASH         577
+#define ERROR_NO_PAGEFILE                578
+#define ERROR_ILLEGAL_FLOAT_CONTEXT      579
+#define ERROR_NO_EVENT_PAIR              580
+#define ERROR_DOMAIN_CTRLR_CONFIG_ERROR  581
+#define ERROR_ILLEGAL_CHARACTER          582
+#define ERROR_UNDEFINED_CHARACTER        583
+#define ERROR_FLOPPY_VOLUME              584
+#define ERROR_BIOS_FAILED_TO_CONNECT_INTERRUPT 585
+#define ERROR_BACKUP_CONTROLLER          586
+#define ERROR_MUTANT_LIMIT_EXCEEDED      587
+#define ERROR_FS_DRIVER_REQUIRED         588
+#define ERROR_CANNOT_LOAD_REGISTRY_FILE  589
+#define ERROR_DEBUG_ATTACH_FAILED        590
+#define ERROR_SYSTEM_PROCESS_TERMINATED  591
+#define ERROR_DATA_NOT_ACCEPTED          592
+#define ERROR_VDM_HARD_ERROR             593
+#define ERROR_DRIVER_CANCEL_TIMEOUT      594
+#define ERROR_REPLY_MESSAGE_MISMATCH     595
+#define ERROR_LOST_WRITEBEHIND_DATA      596
+#define ERROR_CLIENT_SERVER_PARAMETERS_INVALID 597
+#define ERROR_NOT_TINY_STREAM            598
+#define ERROR_STACK_OVERFLOW_READ        599
+#define ERROR_CONVERT_TO_LARGE           600
+#define ERROR_FOUND_OUT_OF_SCOPE         601
+#define ERROR_ALLOCATE_BUCKET            602
+#define ERROR_MARSHALL_OVERFLOW          603
+#define ERROR_INVALID_VARIANT            604
+#define ERROR_BAD_COMPRESSION_BUFFER     605
+#define ERROR_AUDIT_FAILED               606
+#define ERROR_TIMER_RESOLUTION_NOT_SET   607
+#define ERROR_INSUFFICIENT_LOGON_INFO    608
+#define ERROR_BAD_DLL_ENTRYPOINT         609
+#define ERROR_BAD_SERVICE_ENTRYPOINT     610
+#define ERROR_IP_ADDRESS_CONFLICT1       611
+#define ERROR_IP_ADDRESS_CONFLICT2       612
+#define ERROR_REGISTRY_QUOTA_LIMIT       613
+#define ERROR_NO_CALLBACK_ACTIVE         614
+#define ERROR_PWD_TOO_SHORT              615
+#define ERROR_PWD_TOO_RECENT             616
+#define ERROR_PWD_HISTORY_CONFLICT       617
+#define ERROR_UNSUPPORTED_COMPRESSION    618
+#define ERROR_INVALID_HW_PROFILE         619
+#define ERROR_INVALID_PLUGPLAY_DEVICE_PATH 620
+#define ERROR_QUOTA_LIST_INCONSISTENT    621
+#define ERROR_EVALUATION_EXPIRATION      622
+#define ERROR_ILLEGAL_DLL_RELOCATION     623
+#define ERROR_DLL_INIT_FAILED_LOGOFF     624
+#define ERROR_VALIDATE_CONTINUE          625
+#define ERROR_NO_MORE_MATCHES            626
+#define ERROR_RANGE_LIST_CONFLICT        627
+#define ERROR_SERVER_SID_MISMATCH        628
+#define ERROR_CANT_ENABLE_DENY_ONLY      629
+#define ERROR_FLOAT_MULTIPLE_FAULTS      630
+#define ERROR_FLOAT_MULTIPLE_TRAPS       631
+#define ERROR_NOINTERFACE                632
+#define ERROR_DRIVER_FAILED_SLEEP        633
+#define ERROR_CORRUPT_SYSTEM_FILE        634
+#define ERROR_COMMITMENT_MINIMUM         635
+#define ERROR_PNP_RESTART_ENUMERATION    636
+#define ERROR_SYSTEM_IMAGE_BAD_SIGNATURE 637
+#define ERROR_PNP_REBOOT_REQUIRED        638
+#define ERROR_INSUFFICIENT_POWER         639
+#define ERROR_MULTIPLE_FAULT_VIOLATION   640
+#define ERROR_SYSTEM_SHUTDOWN            641
+#define ERROR_PORT_NOT_SET               642
+#define ERROR_DS_VERSION_CHECK_FAILURE   643
+#define ERROR_RANGE_NOT_FOUND            644
+#define ERROR_NOT_SAFE_MODE_DRIVER       646
+#define ERROR_FAILED_DRIVER_ENTRY        647
+#define ERROR_DEVICE_ENUMERATION_ERROR   648
+#define ERROR_MOUNT_POINT_NOT_RESOLVED   649
+#define ERROR_INVALID_DEVICE_OBJECT_PARAMETER 650
+#define ERROR_MCA_OCCURED                651
+#define ERROR_DRIVER_DATABASE_ERROR      652
+#define ERROR_SYSTEM_HIVE_TOO_LARGE      653
+#define ERROR_DRIVER_FAILED_PRIOR_UNLOAD 654
+#define ERROR_VOLSNAP_PREPARE_HIBERNATE  655
+#define ERROR_HIBERNATION_FAILURE        656
+#define ERROR_FILE_SYSTEM_LIMITATION     665
+#define ERROR_ASSERTION_FAILURE          668
+#define ERROR_ACPI_ERROR                 669
+#define ERROR_WOW_ASSERTION              670
+#define ERROR_PNP_BAD_MPS_TABLE          671
+#define ERROR_PNP_TRANSLATION_FAILED     672
+#define ERROR_PNP_IRQ_TRANSLATION_FAILED 673
+#define ERROR_PNP_INVALID_ID             674
+#define ERROR_WAKE_SYSTEM_DEBUGGER       675
+#define ERROR_HANDLES_CLOSED             676
+#define ERROR_EXTRANEOUS_INFORMATION     677
+#define ERROR_RXACT_COMMIT_NECESSARY     678
+#define ERROR_MEDIA_CHECK                679
+#define ERROR_GUID_SUBSTITUTION_MADE     680
+#define ERROR_STOPPED_ON_SYMLINK         681
+#define ERROR_LONGJUMP                   682
+#define ERROR_PLUGPLAY_QUERY_VETOED      683
+#define ERROR_UNWIND_CONSOLIDATE         684
+#define ERROR_REGISTRY_HIVE_RECOVERED    685
+#define ERROR_DLL_MIGHT_BE_INSECURE      686
+#define ERROR_DLL_MIGHT_BE_INCOMPATIBLE  687
+#define ERROR_DBG_EXCEPTION_NOT_HANDLED  688
+#define ERROR_DBG_REPLY_LATER            689
+#define ERROR_DBG_UNABLE_TO_PROVIDE_HANDLE 690
+#define ERROR_DBG_TERMINATE_THREAD       691
+#define ERROR_DBG_TERMINATE_PROCESS      692
+#define ERROR_DBG_CONTROL_C              693
+#define ERROR_DBG_PRINTEXCEPTION_C       694
+#define ERROR_DBG_RIPEXCEPTION           695
+#define ERROR_DBG_CONTROL_BREAK          696
+#define ERROR_DBG_COMMAND_EXCEPTION      697
+#define ERROR_OBJECT_NAME_EXISTS         698
+#define ERROR_THREAD_WAS_SUSPENDED       699
+#define ERROR_IMAGE_NOT_AT_BASE          700
+#define ERROR_RXACT_STATE_CREATED        701
+#define ERROR_SEGMENT_NOTIFICATION       702
+#define ERROR_BAD_CURRENT_DIRECTORY      703
+#define ERROR_FT_READ_RECOVERY_FROM_BACKUP 704
+#define ERROR_FT_WRITE_RECOVERY          705
+#define ERROR_IMAGE_MACHINE_TYPE_MISMATCH 706
+#define ERROR_RECEIVE_PARTIAL            707
+#define ERROR_RECEIVE_EXPEDITED          708
+#define ERROR_RECEIVE_PARTIAL_EXPEDITED  709
+#define ERROR_EVENT_DONE                 710
+#define ERROR_EVENT_PENDING              711
+#define ERROR_CHECKING_FILE_SYSTEM       712
+#define ERROR_FATAL_APP_EXIT             713
+#define ERROR_PREDEFINED_HANDLE          714
+#define ERROR_WAS_UNLOCKED               715
+#define ERROR_SERVICE_NOTIFICATION       716
+#define ERROR_WAS_LOCKED                 717
+#define ERROR_LOG_HARD_ERROR             718
+#define ERROR_ALREADY_WIN32              719
+#define ERROR_IMAGE_MACHINE_TYPE_MISMATCH_EXE 720
+#define ERROR_NO_YIELD_PERFORMED         721
+#define ERROR_TIMER_RESUME_IGNORED       722
+#define ERROR_ARBITRATION_UNHANDLED      723
+#define ERROR_CARDBUS_NOT_SUPPORTED      724
+#define ERROR_MP_PROCESSOR_MISMATCH      725
+#define ERROR_HIBERNATED                 726
+#define ERROR_RESUME_HIBERNATION         727
+#define ERROR_FIRMWARE_UPDATED           728
+#define ERROR_DRIVERS_LEAKING_LOCKED_PAGES 729
+#define ERROR_WAKE_SYSTEM                730
+#define ERROR_WAIT_1                     731
+#define ERROR_WAIT_2                     732
+#define ERROR_WAIT_3                     733
+#define ERROR_WAIT_63                    734
+#define ERROR_ABANDONED_WAIT_0           735
+#define ERROR_ABANDONED_WAIT_63          736
+#define ERROR_USER_APC                   737
+#define ERROR_KERNEL_APC                 738
+#define ERROR_ALERTED                    739
+#define ERROR_ELEVATION_REQUIRED         740
+#define ERROR_REPARSE                    741
+#define ERROR_OPLOCK_BREAK_IN_PROGRESS   742
+#define ERROR_VOLUME_MOUNTED             743
+#define ERROR_RXACT_COMMITTED            744
+#define ERROR_NOTIFY_CLEANUP             745
+#define ERROR_PRIMARY_TRANSPORT_CONNECT_FAILED 746
+#define ERROR_PAGE_FAULT_TRANSITION      747
+#define ERROR_PAGE_FAULT_DEMAND_ZERO     748
+#define ERROR_PAGE_FAULT_COPY_ON_WRITE   749
+#define ERROR_PAGE_FAULT_GUARD_PAGE      750
+#define ERROR_PAGE_FAULT_PAGING_FILE     751
+#define ERROR_CACHE_PAGE_LOCKED          752
+#define ERROR_CRASH_DUMP                 753
+#define ERROR_BUFFER_ALL_ZEROS           754
+#define ERROR_REPARSE_OBJECT             755
+#define ERROR_RESOURCE_REQUIREMENTS_CHANGED 756
+#define ERROR_TRANSLATION_COMPLETE       757
+#define ERROR_NOTHING_TO_TERMINATE       758
+#define ERROR_PROCESS_NOT_IN_JOB         759
+#define ERROR_PROCESS_IN_JOB             760
+#define ERROR_VOLSNAP_HIBERNATE_READY    761
+#define ERROR_FSFILTER_OP_COMPLETED_SUCCESSFULLY 762
+#define ERROR_INTERRUPT_VECTOR_ALREADY_CONNECTED 763
+#define ERROR_INTERRUPT_STILL_CONNECTED  764
+#define ERROR_WAIT_FOR_OPLOCK            765
+#define ERROR_DBG_EXCEPTION_HANDLED      766
+#define ERROR_DBG_CONTINUE               767
+#define ERROR_CALLBACK_POP_STACK         768
+#define ERROR_COMPRESSION_DISABLED       769
+#define ERROR_CANTFETCHBACKWARDS         770
+#define ERROR_CANTSCROLLBACKWARDS        771
+#define ERROR_ROWSNOTRELEASED            772
+#define ERROR_BAD_ACCESSOR_FLAGS         773
+#define ERROR_ERRORS_ENCOUNTERED         774
+#define ERROR_NOT_CAPABLE                775
+#define ERROR_REQUEST_OUT_OF_SEQUENCE    776
+#define ERROR_VERSION_PARSE_ERROR        777
+#define ERROR_BADSTARTPOSITION           778
+#define ERROR_MEMORY_HARDWARE            779
+#define ERROR_DISK_REPAIR_DISABLED       780
+#define ERROR_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE 781
+#define ERROR_SYSTEM_POWERSTATE_TRANSITION 782
+#define ERROR_SYSTEM_POWERSTATE_COMPLEX_TRANSITION 783
+#define ERROR_MCA_EXCEPTION              784
+#define ERROR_ACCESS_AUDIT_BY_POLICY     785
+#define ERROR_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY 786
+#define ERROR_ABANDON_HIBERFILE          787
+#define ERROR_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED 788
+#define ERROR_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR 789
+#define ERROR_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR 790
+#define ERROR_BAD_MCFG_TABLE             791
+#define ERROR_OPLOCK_SWITCHED_TO_NEW_HANDLE 800
+#define ERROR_CANNOT_GRANT_REQUESTED_OPLOCK 801
+#define ERROR_CANNOT_BREAK_OPLOCK        802
+#define ERROR_OPLOCK_HANDLE_CLOSED       803
+#define ERROR_NO_ACE_CONDITION           804
+#define ERROR_INVALID_ACE_CONDITION      805
+#define ERROR_EA_ACCESS_DENIED           994
+#define ERROR_OPERATION_ABORTED          995
+#define ERROR_IO_INCOMPLETE              996
+#define ERROR_IO_PENDING                 997
+#define ERROR_NOACCESS                   998
+#define ERROR_SWAPERROR                  999
+#define ERROR_STACK_OVERFLOW             1001
+#define ERROR_INVALID_MESSAGE            1002
+#define ERROR_CAN_NOT_COMPLETE           1003
+#define ERROR_INVALID_FLAGS              1004
+#define ERROR_UNRECOGNIZED_VOLUME        1005
+#define ERROR_FILE_INVALID               1006
+#define ERROR_FULLSCREEN_MODE            1007
+#define ERROR_NO_TOKEN                   1008
+#define ERROR_BADDB                      1009
+#define ERROR_BADKEY                     1010
+#define ERROR_CANTOPEN                   1011
+#define ERROR_CANTREAD                   1012
+#define ERROR_CANTWRITE                  1013
+#define ERROR_REGISTRY_RECOVERED         1014
+#define ERROR_REGISTRY_CORRUPT           1015
+#define ERROR_REGISTRY_IO_FAILED         1016
+#define ERROR_NOT_REGISTRY_FILE          1017
+#define ERROR_KEY_DELETED                1018
+#define ERROR_NO_LOG_SPACE               1019
+#define ERROR_KEY_HAS_CHILDREN           1020
+#define ERROR_CHILD_MUST_BE_VOLATILE     1021
+#define ERROR_NOTIFY_ENUM_DIR            1022
+
+#define RPC_X_BAD_STUB_DATA 1783
+#define RPC_S_UNKNOWN_IF 1717
+#define RPC_S_PROTOCOL_ERROR 1728
+#define RPC_S_UNSUPPORTED_TRANS_SYN 1730
+#define RPC_S_PROCNUM_OUT_OF_RANGE 1745
+
+#define ERROR_INVALID_TRANSACTION 6700
+#define ERROR_TRANSACTION_NOT_ACTIVE 6701
+#define ERROR_TRANSACTION_REQUEST_NOT_VALID 6702
+#define ERROR_TRANSACTION_NOT_REQUESTED 6703
+#define ERROR_TRANSACTION_ALREADY_ABORTED 6704
+#define ERROR_TRANSACTION_ALREADY_COMMITTED 6705

ctypes_generation/definitions/defines/windef_evtlog.txt

@@ -0,0 +1,362 @@
+#define EVENTLOG_SUCCESS                0x0000
+#define EVENTLOG_ERROR_TYPE             0x0001
+#define EVENTLOG_WARNING_TYPE           0x0002
+#define EVENTLOG_INFORMATION_TYPE       0x0004
+#define EVENTLOG_AUDIT_SUCCESS          0x0008
+#define EVENTLOG_AUDIT_FAILURE          0x0010
+
+
+#define EVENTLOG_SEQUENTIAL_READ        0x0001
+#define EVENTLOG_SEEK_READ              0x0002
+#define EVENTLOG_FORWARDS_READ          0x0004
+#define EVENTLOG_BACKWARDS_READ         0x0008
+
+
+///////////////////////////////////////////////////
+//                                               //
+//           Start of WinEvt Error codes         //
+//                                               //
+//                 15000 to 15079                //
+///////////////////////////////////////////////////
+
+//
+// MessageId: ERROR_EVT_INVALID_CHANNEL_PATH
+//
+// MessageText:
+//
+// The specified channel path is invalid.
+//
+#define ERROR_EVT_INVALID_CHANNEL_PATH   15000L
+
+//
+// MessageId: ERROR_EVT_INVALID_QUERY
+//
+// MessageText:
+//
+// The specified query is invalid.
+//
+#define ERROR_EVT_INVALID_QUERY          15001L
+
+//
+// MessageId: ERROR_EVT_PUBLISHER_METADATA_NOT_FOUND
+//
+// MessageText:
+//
+// The publisher metadata cannot be found in the resource.
+//
+#define ERROR_EVT_PUBLISHER_METADATA_NOT_FOUND 15002L
+
+//
+// MessageId: ERROR_EVT_EVENT_TEMPLATE_NOT_FOUND
+//
+// MessageText:
+//
+// The template for an event definition cannot be found in the resource (error = %1).
+//
+#define ERROR_EVT_EVENT_TEMPLATE_NOT_FOUND 15003L
+
+//
+// MessageId: ERROR_EVT_INVALID_PUBLISHER_NAME
+//
+// MessageText:
+//
+// The specified publisher name is invalid.
+//
+#define ERROR_EVT_INVALID_PUBLISHER_NAME 15004L
+
+//
+// MessageId: ERROR_EVT_INVALID_EVENT_DATA
+//
+// MessageText:
+//
+// The event data raised by the publisher is not compatible with the event template definition in the publisher's manifest
+//
+#define ERROR_EVT_INVALID_EVENT_DATA     15005L
+
+//
+// MessageId: ERROR_EVT_CHANNEL_NOT_FOUND
+//
+// MessageText:
+//
+// The specified channel could not be found. Check channel configuration.
+//
+#define ERROR_EVT_CHANNEL_NOT_FOUND      15007L
+
+//
+// MessageId: ERROR_EVT_MALFORMED_XML_TEXT
+//
+// MessageText:
+//
+// The specified xml text was not well-formed. See Extended Error for more details.
+//
+#define ERROR_EVT_MALFORMED_XML_TEXT     15008L
+
+//
+// MessageId: ERROR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL
+//
+// MessageText:
+//
+// The caller is trying to subscribe to a direct channel which is not allowed. The events for a direct channel go directly to a logfile and cannot be subscribed to.
+//
+#define ERROR_EVT_SUBSCRIPTION_TO_DIRECT_CHANNEL 15009L
+
+//
+// MessageId: ERROR_EVT_CONFIGURATION_ERROR
+//
+// MessageText:
+//
+// Configuration error.
+//
+#define ERROR_EVT_CONFIGURATION_ERROR    15010L
+
+//
+// MessageId: ERROR_EVT_QUERY_RESULT_STALE
+//
+// MessageText:
+//
+// The query result is stale / invalid. This may be due to the log being cleared or rolling over after the query result was created. Users should handle this code by releasing the query result object and reissuing the query.
+//
+#define ERROR_EVT_QUERY_RESULT_STALE     15011L
+
+//
+// MessageId: ERROR_EVT_QUERY_RESULT_INVALID_POSITION
+//
+// MessageText:
+//
+// Query result is currently at an invalid position.
+//
+#define ERROR_EVT_QUERY_RESULT_INVALID_POSITION 15012L
+
+//
+// MessageId: ERROR_EVT_NON_VALIDATING_MSXML
+//
+// MessageText:
+//
+// Registered MSXML doesn't support validation.
+//
+#define ERROR_EVT_NON_VALIDATING_MSXML   15013L
+
+//
+// MessageId: ERROR_EVT_FILTER_ALREADYSCOPED
+//
+// MessageText:
+//
+// An expression can only be followed by a change of scope operation if it itself evaluates to a node set and is not already part of some other change of scope operation.
+//
+#define ERROR_EVT_FILTER_ALREADYSCOPED   15014L
+
+//
+// MessageId: ERROR_EVT_FILTER_NOTELTSET
+//
+// MessageText:
+//
+// Can't perform a step operation from a term that does not represent an element set.
+//
+#define ERROR_EVT_FILTER_NOTELTSET       15015L
+
+//
+// MessageId: ERROR_EVT_FILTER_INVARG
+//
+// MessageText:
+//
+// Left hand side arguments to binary operators must be either attributes, nodes or variables and right hand side arguments must be constants.
+//
+#define ERROR_EVT_FILTER_INVARG          15016L
+
+//
+// MessageId: ERROR_EVT_FILTER_INVTEST
+//
+// MessageText:
+//
+// A step operation must involve either a node test or, in the case of a predicate, an algebraic expression against which to test each node in the node set identified by the preceeding node set can be evaluated.
+//
+#define ERROR_EVT_FILTER_INVTEST         15017L
+
+//
+// MessageId: ERROR_EVT_FILTER_INVTYPE
+//
+// MessageText:
+//
+// This data type is currently unsupported.
+//
+#define ERROR_EVT_FILTER_INVTYPE         15018L
+
+//
+// MessageId: ERROR_EVT_FILTER_PARSEERR
+//
+// MessageText:
+//
+// A syntax error occurred at position %1!d!
+//
+#define ERROR_EVT_FILTER_PARSEERR        15019L
+
+//
+// MessageId: ERROR_EVT_FILTER_UNSUPPORTEDOP
+//
+// MessageText:
+//
+// This operator is unsupported by this implementation of the filter.
+//
+#define ERROR_EVT_FILTER_UNSUPPORTEDOP   15020L
+
+//
+// MessageId: ERROR_EVT_FILTER_UNEXPECTEDTOKEN
+//
+// MessageText:
+//
+// The token encountered was unexpected.
+//
+#define ERROR_EVT_FILTER_UNEXPECTEDTOKEN 15021L
+
+//
+// MessageId: ERROR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL
+//
+// MessageText:
+//
+// The requested operation cannot be performed over an enabled direct channel. The channel must first be disabled before performing the requested operation.
+//
+#define ERROR_EVT_INVALID_OPERATION_OVER_ENABLED_DIRECT_CHANNEL 15022L
+
+//
+// MessageId: ERROR_EVT_INVALID_CHANNEL_PROPERTY_VALUE
+//
+// MessageText:
+//
+// Channel property %1!s! contains invalid value. The value has invalid type, is outside of valid range, can't be updated or is not supported by this type of channel.
+//
+#define ERROR_EVT_INVALID_CHANNEL_PROPERTY_VALUE 15023L
+
+//
+// MessageId: ERROR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE
+//
+// MessageText:
+//
+// Publisher property %1!s! contains invalid value. The value has invalid type, is outside of valid range, can't be updated or is not supported by this type of publisher.
+//
+#define ERROR_EVT_INVALID_PUBLISHER_PROPERTY_VALUE 15024L
+
+//
+// MessageId: ERROR_EVT_CHANNEL_CANNOT_ACTIVATE
+//
+// MessageText:
+//
+// The channel fails to activate.
+//
+#define ERROR_EVT_CHANNEL_CANNOT_ACTIVATE 15025L
+
+//
+// MessageId: ERROR_EVT_FILTER_TOO_COMPLEX
+//
+// MessageText:
+//
+// The xpath expression exceeded supported complexity. Please symplify it or split it into two or more simple expressions.
+//
+#define ERROR_EVT_FILTER_TOO_COMPLEX     15026L
+
+//
+// MessageId: ERROR_EVT_MESSAGE_NOT_FOUND
+//
+// MessageText:
+//
+// the message resource is present but the message is not found in the string/message table
+//
+#define ERROR_EVT_MESSAGE_NOT_FOUND      15027L
+
+//
+// MessageId: ERROR_EVT_MESSAGE_ID_NOT_FOUND
+//
+// MessageText:
+//
+// The message id for the desired message could not be found.
+//
+#define ERROR_EVT_MESSAGE_ID_NOT_FOUND   15028L
+
+//
+// MessageId: ERROR_EVT_UNRESOLVED_VALUE_INSERT
+//
+// MessageText:
+//
+// The substitution string for insert index (%1) could not be found.
+//
+#define ERROR_EVT_UNRESOLVED_VALUE_INSERT 15029L
+
+//
+// MessageId: ERROR_EVT_UNRESOLVED_PARAMETER_INSERT
+//
+// MessageText:
+//
+// The description string for parameter reference (%1) could not be found.
+//
+#define ERROR_EVT_UNRESOLVED_PARAMETER_INSERT 15030L
+
+//
+// MessageId: ERROR_EVT_MAX_INSERTS_REACHED
+//
+// MessageText:
+//
+// The maximum number of replacements has been reached.
+//
+#define ERROR_EVT_MAX_INSERTS_REACHED    15031L
+
+//
+// MessageId: ERROR_EVT_EVENT_DEFINITION_NOT_FOUND
+//
+// MessageText:
+//
+// The event definition could not be found for event id (%1).
+//
+#define ERROR_EVT_EVENT_DEFINITION_NOT_FOUND 15032L
+
+//
+// MessageId: ERROR_EVT_MESSAGE_LOCALE_NOT_FOUND
+//
+// MessageText:
+//
+// The locale specific resource for the desired message is not present.
+//
+#define ERROR_EVT_MESSAGE_LOCALE_NOT_FOUND 15033L
+
+//
+// MessageId: ERROR_EVT_VERSION_TOO_OLD
+//
+// MessageText:
+//
+// The resource is too old to be compatible.
+//
+#define ERROR_EVT_VERSION_TOO_OLD        15034L
+
+//
+// MessageId: ERROR_EVT_VERSION_TOO_NEW
+//
+// MessageText:
+//
+// The resource is too new to be compatible.
+//
+#define ERROR_EVT_VERSION_TOO_NEW        15035L
+
+//
+// MessageId: ERROR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY
+//
+// MessageText:
+//
+// The channel at index %1!d! of the query can't be opened.
+//
+#define ERROR_EVT_CANNOT_OPEN_CHANNEL_OF_QUERY 15036L
+
+//
+// MessageId: ERROR_EVT_PUBLISHER_DISABLED
+//
+// MessageText:
+//
+// The publisher has been disabled and its resource is not avaiable. This usually occurs when the publisher is in the process of being uninstalled or upgraded.
+//
+#define ERROR_EVT_PUBLISHER_DISABLED     15037L
+
+//
+// MessageId: ERROR_EVT_FILTER_OUT_OF_RANGE
+//
+// MessageText:
+//
+// Attempted to create a numeric type that is outside of its valid range.
+//
+#define ERROR_EVT_FILTER_OUT_OF_RANGE    15038L

ctypes_generation/definitions/defines/windef_pe.txt

@@ -0,0 +1,49 @@
+// A LOT of PE related definition are in windef.txt
+// This refactoring (multiple .txt file) come very late in the dev
+
+#define IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA    0x0020  // Image can handle a high entropy 64-bit virtual address space.
+#define IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE 0x0040     // DLL can move.
+#define IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY    0x0080     // Code Integrity Image
+#define IMAGE_DLLCHARACTERISTICS_NX_COMPAT    0x0100     // Image is NX compatible
+#define IMAGE_DLLCHARACTERISTICS_NO_ISOLATION 0x0200     // Image understands isolation and doesn't want it
+#define IMAGE_DLLCHARACTERISTICS_NO_SEH       0x0400     // Image does not use SEH.  No SE handler may reside in this image
+#define IMAGE_DLLCHARACTERISTICS_NO_BIND      0x0800     // Do not bind this image.
+#define IMAGE_DLLCHARACTERISTICS_APPCONTAINER 0x1000     // Image should execute in an AppContainer
+#define IMAGE_DLLCHARACTERISTICS_WDM_DRIVER   0x2000     // Driver uses WDM model
+#define IMAGE_DLLCHARACTERISTICS_GUARD_CF     0x4000     // Image supports Control Flow Guard.
+#define IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE     0x8000
+
+// Directory Entries
+
+#define IMAGE_DIRECTORY_ENTRY_EXPORT          0   // Export Directory
+#define IMAGE_DIRECTORY_ENTRY_IMPORT          1   // Import Directory
+#define IMAGE_DIRECTORY_ENTRY_RESOURCE        2   // Resource Directory
+#define IMAGE_DIRECTORY_ENTRY_EXCEPTION       3   // Exception Directory
+#define IMAGE_DIRECTORY_ENTRY_SECURITY        4   // Security Directory
+#define IMAGE_DIRECTORY_ENTRY_BASERELOC       5   // Base Relocation Table
+#define IMAGE_DIRECTORY_ENTRY_DEBUG           6   // Debug Directory
+
+#define IMAGE_DIRECTORY_ENTRY_ARCHITECTURE    7   // Architecture Specific Data
+#define IMAGE_DIRECTORY_ENTRY_GLOBALPTR       8   // RVA of GP
+#define IMAGE_DIRECTORY_ENTRY_TLS             9   // TLS Directory
+#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG    10   // Load Configuration Directory
+#define IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT   11   // Bound Import Directory in headers
+#define IMAGE_DIRECTORY_ENTRY_IAT            12   // Import Address Table
+#define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT   13   // Delay Load Import Descriptors
+#define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR 14   // COM Runtime descriptor
+
+//
+// Based relocation types.
+//
+
+#define IMAGE_REL_BASED_ABSOLUTE              0
+#define IMAGE_REL_BASED_HIGH                  1
+#define IMAGE_REL_BASED_LOW                   2
+#define IMAGE_REL_BASED_HIGHLOW               3
+#define IMAGE_REL_BASED_HIGHADJ               4
+#define IMAGE_REL_BASED_MACHINE_SPECIFIC_5    5
+#define IMAGE_REL_BASED_RESERVED              6
+#define IMAGE_REL_BASED_MACHINE_SPECIFIC_7    7
+#define IMAGE_REL_BASED_MACHINE_SPECIFIC_8    8
+#define IMAGE_REL_BASED_MACHINE_SPECIFIC_9    9
+#define IMAGE_REL_BASED_DIR64                 10

ctypes_generation/definitions/defines/wintrust_crypt_def.txt

@@ -0,0 +1,677 @@
+#define     CERT_QUERY_OBJECT_FILE         0x00000001
+#define     CERT_QUERY_OBJECT_BLOB         0x00000002
+
+#define     CERT_QUERY_CONTENT_CERT                 1
+#define     CERT_QUERY_CONTENT_CTL                  2
+#define     CERT_QUERY_CONTENT_CRL                  3
+#define     CERT_QUERY_CONTENT_SERIALIZED_STORE     4
+#define     CERT_QUERY_CONTENT_SERIALIZED_CERT      5
+#define     CERT_QUERY_CONTENT_SERIALIZED_CTL       6
+#define     CERT_QUERY_CONTENT_SERIALIZED_CRL       7
+#define     CERT_QUERY_CONTENT_PKCS7_SIGNED         8
+#define     CERT_QUERY_CONTENT_PKCS7_UNSIGNED       9
+#define     CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED   10
+#define     CERT_QUERY_CONTENT_PKCS10               11
+#define     CERT_QUERY_CONTENT_PFX                  12
+#define     CERT_QUERY_CONTENT_CERT_PAIR            13
+#define     CERT_QUERY_CONTENT_PFX_AND_LOAD         14
+
+#define     CERT_QUERY_FORMAT_BINARY                1
+#define     CERT_QUERY_FORMAT_BASE64_ENCODED        2
+#define     CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED 3
+
+#define     CERT_QUERY_FORMAT_FLAG_BINARY         ( 1 << CERT_QUERY_FORMAT_BINARY)
+
+#define     CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED    ( 1 << CERT_QUERY_FORMAT_BASE64_ENCODED)
+
+#define     CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED  ( 1 << CERT_QUERY_FORMAT_ASN_ASCII_HEX_ENCODED)
+
+#define     CERT_QUERY_FORMAT_FLAG_ALL   (CERT_QUERY_FORMAT_FLAG_BINARY | CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED | CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED)
+
+
+#define     CERT_QUERY_CONTENT_FLAG_CERT                   ( 1 << CERT_QUERY_CONTENT_CERT)
+
+#define     CERT_QUERY_CONTENT_FLAG_CTL                   ( 1 << CERT_QUERY_CONTENT_CTL)
+
+#define     CERT_QUERY_CONTENT_FLAG_CRL                   ( 1 << CERT_QUERY_CONTENT_CRL)
+
+#define     CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE                   ( 1 << CERT_QUERY_CONTENT_SERIALIZED_STORE)
+
+#define     CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT                   ( 1 << CERT_QUERY_CONTENT_SERIALIZED_CERT)
+
+#define     CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL                   ( 1 << CERT_QUERY_CONTENT_SERIALIZED_CTL)
+
+#define     CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL                   ( 1 << CERT_QUERY_CONTENT_SERIALIZED_CRL)
+
+#define     CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED                   ( 1 << CERT_QUERY_CONTENT_PKCS7_SIGNED)
+
+#define     CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED                   ( 1 << CERT_QUERY_CONTENT_PKCS7_UNSIGNED)
+
+#define     CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED                  ( 1 << CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED)
+
+#define     CERT_QUERY_CONTENT_FLAG_PKCS10                   ( 1 << CERT_QUERY_CONTENT_PKCS10)
+
+#define     CERT_QUERY_CONTENT_FLAG_PFX                      ( 1 << CERT_QUERY_CONTENT_PFX)
+
+#define     CERT_QUERY_CONTENT_FLAG_CERT_PAIR                   ( 1 << CERT_QUERY_CONTENT_CERT_PAIR)
+
+#define     CERT_QUERY_CONTENT_FLAG_PFX_AND_LOAD                    ( 1 << CERT_QUERY_CONTENT_PFX_AND_LOAD)
+
+#define     CERT_QUERY_CONTENT_FLAG_ALL             ( CERT_QUERY_CONTENT_FLAG_CERT | CERT_QUERY_CONTENT_FLAG_CTL  | CERT_QUERY_CONTENT_FLAG_CRL  | CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT  | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL   | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED | CERT_QUERY_CONTENT_FLAG_PKCS10 | CERT_QUERY_CONTENT_FLAG_PFX | CERT_QUERY_CONTENT_FLAG_CERT_PAIR )
+
+
+
+#define CRYPT_ASN_ENCODING          0x00000001
+#define CRYPT_NDR_ENCODING          0x00000002
+#define X509_ASN_ENCODING           0x00000001
+#define X509_NDR_ENCODING           0x00000002
+#define PKCS_7_ASN_ENCODING         0x00010000
+#define PKCS_7_NDR_ENCODING         0x00020000
+
+#define CERT_ENCODING_TYPE_MASK     0x0000FFFF
+#define CMSG_ENCODING_TYPE_MASK     0xFFFF0000
+
+
+#define CERT_COMPARE_MASK           0xFFFF
+#define CERT_COMPARE_SHIFT          16
+#define CERT_COMPARE_ANY            0
+#define CERT_COMPARE_SHA1_HASH      1
+#define CERT_COMPARE_NAME           2
+#define CERT_COMPARE_ATTR           3
+#define CERT_COMPARE_MD5_HASH       4
+#define CERT_COMPARE_PROPERTY       5
+#define CERT_COMPARE_PUBLIC_KEY     6
+#define CERT_COMPARE_HASH           CERT_COMPARE_SHA1_HASH
+#define CERT_COMPARE_NAME_STR_A     7
+#define CERT_COMPARE_NAME_STR_W     8
+#define CERT_COMPARE_KEY_SPEC       9
+#define CERT_COMPARE_ENHKEY_USAGE   10
+#define CERT_COMPARE_CTL_USAGE      CERT_COMPARE_ENHKEY_USAGE
+#define CERT_COMPARE_SUBJECT_CERT   11
+#define CERT_COMPARE_ISSUER_OF      12
+#define CERT_COMPARE_EXISTING       13
+#define CERT_COMPARE_SIGNATURE_HASH 14
+#define CERT_COMPARE_KEY_IDENTIFIER 15
+#define CERT_COMPARE_CERT_ID        16
+#define CERT_COMPARE_CROSS_CERT_DIST_POINTS 17
+#define CERT_COMPARE_PUBKEY_MD5_HASH 18
+#define CERT_COMPARE_SUBJECT_INFO_ACCESS 19
+
+#define CERT_NAME_ISSUER_FLAG           0x1
+#define CERT_NAME_DISABLE_IE4_UTF8_FLAG 0x00010000
+
+
+#define USAGE_MATCH_TYPE_AND 0x00000000
+#define USAGE_MATCH_TYPE_OR  0x00000001
+
+#define CERT_CHAIN_REVOCATION_CHECK_END_CERT           0x10000000
+#define CERT_CHAIN_REVOCATION_CHECK_CHAIN              0x20000000
+#define CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT 0x40000000
+#define CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY         0x80000000
+
+#define CERT_TRUST_NO_ERROR                             0x00000000
+#define CERT_TRUST_IS_NOT_TIME_VALID                    0x00000001
+#define CERT_TRUST_IS_NOT_TIME_NESTED                   0x00000002
+#define CERT_TRUST_IS_REVOKED                           0x00000004
+#define CERT_TRUST_IS_NOT_SIGNATURE_VALID               0x00000008
+#define CERT_TRUST_IS_NOT_VALID_FOR_USAGE               0x00000010
+#define CERT_TRUST_IS_UNTRUSTED_ROOT                    0x00000020
+#define CERT_TRUST_REVOCATION_STATUS_UNKNOWN            0x00000040
+#define CERT_TRUST_IS_CYCLIC                            0x00000080
+
+#define CERT_TRUST_INVALID_EXTENSION                    0x00000100
+#define CERT_TRUST_INVALID_POLICY_CONSTRAINTS           0x00000200
+#define CERT_TRUST_INVALID_BASIC_CONSTRAINTS            0x00000400
+#define CERT_TRUST_INVALID_NAME_CONSTRAINTS             0x00000800
+#define CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT    0x00001000
+
+#define CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT      0x00002000
+
+#define CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT    0x00004000
+#define CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT         0x00008000
+
+#define CERT_TRUST_IS_OFFLINE_REVOCATION                0x01000000
+#define CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY             0x02000000
+#define CERT_TRUST_IS_EXPLICIT_DISTRUST                 0x04000000
+#define CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT       0x08000000
+
+#define CERT_TRUST_IS_PARTIAL_CHAIN                     0x00010000
+#define CERT_TRUST_CTL_IS_NOT_TIME_VALID                0x00020000
+#define CERT_TRUST_CTL_IS_NOT_SIGNATURE_VALID           0x00040000
+#define CERT_TRUST_CTL_IS_NOT_VALID_FOR_USAGE           0x00080000
+
+#define CERT_TRUST_HAS_EXACT_MATCH_ISSUER               0x00000001
+#define CERT_TRUST_HAS_KEY_MATCH_ISSUER                 0x00000002
+#define CERT_TRUST_HAS_NAME_MATCH_ISSUER                0x00000004
+#define CERT_TRUST_IS_SELF_SIGNED                       0x00000008
+
+#define CERT_TRUST_HAS_PREFERRED_ISSUER                 0x00000100
+#define CERT_TRUST_HAS_ISSUANCE_CHAIN_POLICY            0x00000200
+#define CERT_TRUST_HAS_VALID_NAME_CONSTRAINTS           0x00000400
+#define CERT_TRUST_IS_PEER_TRUSTED                      0x00000800
+#define CERT_TRUST_HAS_CRL_VALIDITY_EXTENDED            0x00001000
+
+
+#define CERT_TRUST_IS_FROM_EXCLUSIVE_TRUST_STORE        0x00002000
+#define CERT_TRUST_IS_COMPLEX_CHAIN                     0x00010000
+
+
+
+#define CMSG_TYPE_PARAM                              1
+#define CMSG_CONTENT_PARAM                           2
+#define CMSG_BARE_CONTENT_PARAM                      3
+#define CMSG_INNER_CONTENT_TYPE_PARAM                4
+#define CMSG_SIGNER_COUNT_PARAM                      5
+#define CMSG_SIGNER_INFO_PARAM                       6
+#define CMSG_SIGNER_CERT_INFO_PARAM                  7
+#define CMSG_SIGNER_HASH_ALGORITHM_PARAM             8
+#define CMSG_SIGNER_AUTH_ATTR_PARAM                  9
+#define CMSG_SIGNER_UNAUTH_ATTR_PARAM                10
+#define CMSG_CERT_COUNT_PARAM                        11
+#define CMSG_CERT_PARAM                              12
+#define CMSG_CRL_COUNT_PARAM                         13
+#define CMSG_CRL_PARAM                               14
+#define CMSG_ENVELOPE_ALGORITHM_PARAM                15
+#define CMSG_RECIPIENT_COUNT_PARAM                   17
+#define CMSG_RECIPIENT_INDEX_PARAM                   18
+#define CMSG_RECIPIENT_INFO_PARAM                    19
+#define CMSG_HASH_ALGORITHM_PARAM                    20
+#define CMSG_HASH_DATA_PARAM                         21
+#define CMSG_COMPUTED_HASH_PARAM                     22
+#define CMSG_ENCRYPT_PARAM                           26
+#define CMSG_ENCRYPTED_DIGEST                        27
+#define CMSG_ENCODED_SIGNER                          28
+#define CMSG_ENCODED_MESSAGE                         29
+#define CMSG_VERSION_PARAM                           30
+#define CMSG_ATTR_CERT_COUNT_PARAM                   31
+#define CMSG_ATTR_CERT_PARAM                         32
+#define CMSG_CMS_RECIPIENT_COUNT_PARAM               33
+#define CMSG_CMS_RECIPIENT_INDEX_PARAM               34
+#define CMSG_CMS_RECIPIENT_ENCRYPTED_KEY_INDEX_PARAM 35
+#define CMSG_CMS_RECIPIENT_INFO_PARAM                36
+#define CMSG_UNPROTECTED_ATTR_PARAM                  37
+#define CMSG_SIGNER_CERT_ID_PARAM                    38
+#define CMSG_CMS_SIGNER_INFO_PARAM                   39
+
+
+#define CERT_INFO_VERSION_FLAG                      1
+#define CERT_INFO_SERIAL_NUMBER_FLAG                2
+#define CERT_INFO_SIGNATURE_ALGORITHM_FLAG          3
+#define CERT_INFO_ISSUER_FLAG                       4
+#define CERT_INFO_NOT_BEFORE_FLAG                   5
+#define CERT_INFO_NOT_AFTER_FLAG                    6
+#define CERT_INFO_SUBJECT_FLAG                      7
+#define CERT_INFO_SUBJECT_PUBLIC_KEY_INFO_FLAG      8
+#define CERT_INFO_ISSUER_UNIQUE_ID_FLAG             9
+#define CERT_INFO_SUBJECT_UNIQUE_ID_FLAG            10
+#define CERT_INFO_EXTENSION_FLAG                    11
+
+#define CERT_FIND_ANY           (CERT_COMPARE_ANY << CERT_COMPARE_SHIFT)
+#define CERT_FIND_SHA1_HASH     (CERT_COMPARE_SHA1_HASH << CERT_COMPARE_SHIFT)
+#define CERT_FIND_MD5_HASH      (CERT_COMPARE_MD5_HASH << CERT_COMPARE_SHIFT)
+#define CERT_FIND_SIGNATURE_HASH (CERT_COMPARE_SIGNATURE_HASH << CERT_COMPARE_SHIFT)
+#define CERT_FIND_KEY_IDENTIFIER (CERT_COMPARE_KEY_IDENTIFIER << CERT_COMPARE_SHIFT)
+#define CERT_FIND_HASH          CERT_FIND_SHA1_HASH
+#define CERT_FIND_PROPERTY      (CERT_COMPARE_PROPERTY << CERT_COMPARE_SHIFT)
+#define CERT_FIND_PUBLIC_KEY    (CERT_COMPARE_PUBLIC_KEY << CERT_COMPARE_SHIFT)
+#define CERT_FIND_SUBJECT_NAME  (CERT_COMPARE_NAME << CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG)
+#define CERT_FIND_SUBJECT_ATTR  (CERT_COMPARE_ATTR << CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG)
+#define CERT_FIND_ISSUER_NAME   (CERT_COMPARE_NAME << CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG)
+#define CERT_FIND_ISSUER_ATTR   (CERT_COMPARE_ATTR << CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG)
+#define CERT_FIND_SUBJECT_STR_A (CERT_COMPARE_NAME_STR_A << CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG)
+#define CERT_FIND_SUBJECT_STR_W (CERT_COMPARE_NAME_STR_W << CERT_COMPARE_SHIFT | CERT_INFO_SUBJECT_FLAG)
+#define CERT_FIND_SUBJECT_STR   CERT_FIND_SUBJECT_STR_W
+#define CERT_FIND_ISSUER_STR_A  (CERT_COMPARE_NAME_STR_A << CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG)
+#define CERT_FIND_ISSUER_STR_W  (CERT_COMPARE_NAME_STR_W << CERT_COMPARE_SHIFT | CERT_INFO_ISSUER_FLAG)
+#define CERT_FIND_ISSUER_STR    CERT_FIND_ISSUER_STR_W
+#define CERT_FIND_KEY_SPEC      (CERT_COMPARE_KEY_SPEC << CERT_COMPARE_SHIFT)
+#define CERT_FIND_ENHKEY_USAGE  (CERT_COMPARE_ENHKEY_USAGE << CERT_COMPARE_SHIFT)
+#define CERT_FIND_CTL_USAGE     CERT_FIND_ENHKEY_USAGE
+
+#define CERT_FIND_SUBJECT_CERT  (CERT_COMPARE_SUBJECT_CERT << CERT_COMPARE_SHIFT)
+#define CERT_FIND_ISSUER_OF     (CERT_COMPARE_ISSUER_OF << CERT_COMPARE_SHIFT)
+#define CERT_FIND_EXISTING      (CERT_COMPARE_EXISTING << CERT_COMPARE_SHIFT)
+#define CERT_FIND_CERT_ID       (CERT_COMPARE_CERT_ID << CERT_COMPARE_SHIFT)
+#define CERT_FIND_CROSS_CERT_DIST_POINTS                     (CERT_COMPARE_CROSS_CERT_DIST_POINTS << CERT_COMPARE_SHIFT)
+
+
+#define CERT_FIND_PUBKEY_MD5_HASH                     (CERT_COMPARE_PUBKEY_MD5_HASH << CERT_COMPARE_SHIFT)
+
+#define CERT_FIND_SUBJECT_INFO_ACCESS                     (CERT_COMPARE_SUBJECT_INFO_ACCESS << CERT_COMPARE_SHIFT)
+
+
+#define CERT_NAME_EMAIL_TYPE            1
+#define CERT_NAME_RDN_TYPE              2
+#define CERT_NAME_ATTR_TYPE             3
+#define CERT_NAME_SIMPLE_DISPLAY_TYPE   4
+#define CERT_NAME_FRIENDLY_DISPLAY_TYPE 5
+#define CERT_NAME_DNS_TYPE              6
+#define CERT_NAME_URL_TYPE              7
+#define CERT_NAME_UPN_TYPE              8
+
+
+
+#define CERT_KEY_PROV_HANDLE_PROP_ID        1
+#define CERT_KEY_PROV_INFO_PROP_ID          2
+#define CERT_SHA1_HASH_PROP_ID              3
+#define CERT_MD5_HASH_PROP_ID               4
+#define CERT_HASH_PROP_ID                   CERT_SHA1_HASH_PROP_ID
+#define CERT_KEY_CONTEXT_PROP_ID            5
+#define CERT_KEY_SPEC_PROP_ID               6
+#define CERT_IE30_RESERVED_PROP_ID          7
+#define CERT_PUBKEY_HASH_RESERVED_PROP_ID   8
+#define CERT_ENHKEY_USAGE_PROP_ID           9
+#define CERT_CTL_USAGE_PROP_ID              CERT_ENHKEY_USAGE_PROP_ID
+#define CERT_NEXT_UPDATE_LOCATION_PROP_ID   10
+#define CERT_FRIENDLY_NAME_PROP_ID          11
+#define CERT_PVK_FILE_PROP_ID               12
+#define CERT_DESCRIPTION_PROP_ID            13
+#define CERT_ACCESS_STATE_PROP_ID           14
+#define CERT_SIGNATURE_HASH_PROP_ID         15
+#define CERT_SMART_CARD_DATA_PROP_ID        16
+#define CERT_EFS_PROP_ID                    17
+#define CERT_FORTEZZA_DATA_PROP_ID          18
+#define CERT_ARCHIVED_PROP_ID               19
+#define CERT_KEY_IDENTIFIER_PROP_ID         20
+#define CERT_AUTO_ENROLL_PROP_ID            21
+#define CERT_PUBKEY_ALG_PARA_PROP_ID        22
+#define CERT_CROSS_CERT_DIST_POINTS_PROP_ID 23
+#define CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID     24
+#define CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID    25
+#define CERT_ENROLLMENT_PROP_ID             26
+#define CERT_DATE_STAMP_PROP_ID             27
+#define CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_ID  28
+#define CERT_SUBJECT_NAME_MD5_HASH_PROP_ID  29
+#define CERT_EXTENDED_ERROR_INFO_PROP_ID    30
+#define CERT_RENEWAL_PROP_ID                64
+#define CERT_ARCHIVED_KEY_HASH_PROP_ID      65
+#define CERT_AUTO_ENROLL_RETRY_PROP_ID      66
+#define CERT_AIA_URL_RETRIEVED_PROP_ID      67
+#define CERT_AUTHORITY_INFO_ACCESS_PROP_ID  68
+#define CERT_BACKED_UP_PROP_ID              69
+#define CERT_OCSP_RESPONSE_PROP_ID          70
+#define CERT_REQUEST_ORIGINATOR_PROP_ID     71
+#define CERT_SOURCE_LOCATION_PROP_ID        72
+
+
+
+#define CRYPT_ACQUIRE_CACHE_FLAG                0x00000001
+#define CRYPT_ACQUIRE_USE_PROV_INFO_FLAG        0x00000002
+#define CRYPT_ACQUIRE_COMPARE_KEY_FLAG          0x00000004
+#define CRYPT_ACQUIRE_NO_HEALING                0x00000008
+#define CRYPT_ACQUIRE_SILENT_FLAG               0x00000040
+#define CRYPT_ACQUIRE_NCRYPT_KEY_FLAGS_MASK     0x00070000
+#define CRYPT_ACQUIRE_ALLOW_NCRYPT_KEY_FLAG     0x00010000
+#define CRYPT_ACQUIRE_PREFER_NCRYPT_KEY_FLAG    0x00020000
+#define CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG      0x00040000
+
+
+
+#define CERT_STORE_PROV_MSG                 (1)
+#define CERT_STORE_PROV_MEMORY              (2)
+#define CERT_STORE_PROV_FILE                (3)
+#define CERT_STORE_PROV_REG                 (4)
+
+#define CERT_STORE_PROV_PKCS7               (5)
+#define CERT_STORE_PROV_SERIALIZED          (6)
+#define CERT_STORE_PROV_FILENAME_A          (7)
+#define CERT_STORE_PROV_FILENAME_W          (8)
+#define CERT_STORE_PROV_FILENAME            CERT_STORE_PROV_FILENAME_W
+#define CERT_STORE_PROV_SYSTEM_A            (9)
+#define CERT_STORE_PROV_SYSTEM_W            (10)
+#define CERT_STORE_PROV_SYSTEM              CERT_STORE_PROV_SYSTEM_W
+
+#define CERT_STORE_PROV_COLLECTION          (11)
+#define CERT_STORE_PROV_SYSTEM_REGISTRY_A   (12)
+#define CERT_STORE_PROV_SYSTEM_REGISTRY_W   (13)
+#define CERT_STORE_PROV_SYSTEM_REGISTRY     CERT_STORE_PROV_SYSTEM_REGISTRY_W
+#define CERT_STORE_PROV_PHYSICAL_W          (14)
+#define CERT_STORE_PROV_PHYSICAL            CERT_STORE_PROV_PHYSICAL_W
+
+#define CERT_STORE_PROV_SMART_CARD_W        (15)
+#define CERT_STORE_PROV_SMART_CARD          CERT_STORE_PROV_SMART_CARD_W
+
+#define CERT_STORE_PROV_LDAP_W              (16)
+#define CERT_STORE_PROV_LDAP                CERT_STORE_PROV_LDAP_W
+#define CERT_STORE_PROV_PKCS12              (17)
+
+
+#define szOID_RSA               "1.2.840.113549"
+#define szOID_PKCS              "1.2.840.113549.1"
+#define szOID_RSA_HASH          "1.2.840.113549.2"
+#define szOID_RSA_ENCRYPT       "1.2.840.113549.3"
+#define szOID_PKCS_1            "1.2.840.113549.1.1"
+#define szOID_PKCS_2            "1.2.840.113549.1.2"
+#define szOID_PKCS_3            "1.2.840.113549.1.3"
+#define szOID_PKCS_4            "1.2.840.113549.1.4"
+#define szOID_PKCS_5            "1.2.840.113549.1.5"
+#define szOID_PKCS_6            "1.2.840.113549.1.6"
+#define szOID_PKCS_7            "1.2.840.113549.1.7"
+#define szOID_PKCS_8            "1.2.840.113549.1.8"
+#define szOID_PKCS_9            "1.2.840.113549.1.9"
+#define szOID_PKCS_10           "1.2.840.113549.1.10"
+#define szOID_PKCS_12           "1.2.840.113549.1.12"
+#define szOID_RSA_RSA           "1.2.840.113549.1.1.1"
+#define szOID_RSA_MD2RSA        "1.2.840.113549.1.1.2"
+#define szOID_RSA_MD4RSA        "1.2.840.113549.1.1.3"
+#define szOID_RSA_MD5RSA        "1.2.840.113549.1.1.4"
+#define szOID_RSA_SHA1RSA       "1.2.840.113549.1.1.5"
+#define szOID_RSA_SETOAEP_RSA   "1.2.840.113549.1.1.6"
+#define szOID_RSAES_OAEP        "1.2.840.113549.1.1.7"
+#define szOID_RSA_MGF1          "1.2.840.113549.1.1.8"
+#define szOID_RSA_PSPECIFIED    "1.2.840.113549.1.1.9"
+#define szOID_RSA_SSA_PSS       "1.2.840.113549.1.1.10"
+#define szOID_RSA_SHA256RSA     "1.2.840.113549.1.1.11"
+#define szOID_RSA_SHA384RSA     "1.2.840.113549.1.1.12"
+#define szOID_RSA_SHA512RSA     "1.2.840.113549.1.1.13"
+#define szOID_RSA_DH            "1.2.840.113549.1.3.1"
+#define szOID_RSA_data          "1.2.840.113549.1.7.1"
+#define szOID_RSA_signedData    "1.2.840.113549.1.7.2"
+#define szOID_RSA_envelopedData "1.2.840.113549.1.7.3"
+#define szOID_RSA_signEnvData   "1.2.840.113549.1.7.4"
+#define szOID_RSA_digestedData  "1.2.840.113549.1.7.5"
+#define szOID_RSA_hashedData    "1.2.840.113549.1.7.5"
+#define szOID_RSA_encryptedData "1.2.840.113549.1.7.6"
+#define szOID_RSA_emailAddr     "1.2.840.113549.1.9.1"
+#define szOID_RSA_unstructName  "1.2.840.113549.1.9.2"
+#define szOID_RSA_contentType   "1.2.840.113549.1.9.3"
+#define szOID_RSA_messageDigest "1.2.840.113549.1.9.4"
+#define szOID_RSA_signingTime   "1.2.840.113549.1.9.5"
+#define szOID_RSA_counterSign   "1.2.840.113549.1.9.6"
+#define szOID_RSA_challengePwd  "1.2.840.113549.1.9.7"
+#define szOID_RSA_unstructAddr  "1.2.840.113549.1.9.8"
+#define szOID_RSA_extCertAttrs  "1.2.840.113549.1.9.9"
+#define szOID_RSA_certExtensions "1.2.840.113549.1.9.14"
+#define szOID_RSA_SMIMECapabilities "1.2.840.113549.1.9.15"
+#define szOID_RSA_preferSignedData "1.2.840.113549.1.9.15.1"
+#define szOID_TIMESTAMP_TOKEN           "1.2.840.113549.1.9.16.1.4"
+#define szOID_RFC3161_counterSign "1.3.6.1.4.1.311.3.3.1"
+#define szOID_RSA_SMIMEalg              "1.2.840.113549.1.9.16.3"
+#define szOID_RSA_SMIMEalgESDH          "1.2.840.113549.1.9.16.3.5"
+#define szOID_RSA_SMIMEalgCMS3DESwrap   "1.2.840.113549.1.9.16.3.6"
+#define szOID_RSA_SMIMEalgCMSRC2wrap    "1.2.840.113549.1.9.16.3.7"
+
+#define szOID_RSA_MD2           "1.2.840.113549.2.2"
+#define szOID_RSA_MD4           "1.2.840.113549.2.4"
+#define szOID_RSA_MD5           "1.2.840.113549.2.5"
+#define szOID_RSA_RC2CBC        "1.2.840.113549.3.2"
+#define szOID_RSA_RC4           "1.2.840.113549.3.4"
+#define szOID_RSA_DES_EDE3_CBC  "1.2.840.113549.3.7"
+#define szOID_RSA_RC5_CBCPad    "1.2.840.113549.3.9"
+#define szOID_ANSI_X942         "1.2.840.10046"
+#define szOID_ANSI_X942_DH      "1.2.840.10046.2.1"
+#define szOID_X957              "1.2.840.10040"
+#define szOID_X957_DSA          "1.2.840.10040.4.1"
+#define szOID_X957_SHA1DSA      "1.2.840.10040.4.3"
+#define szOID_ECC_PUBLIC_KEY    "1.2.840.10045.2.1"
+#define szOID_ECC_CURVE_P256    "1.2.840.10045.3.1.7"
+#define szOID_ECC_CURVE_P384    "1.3.132.0.34"
+#define szOID_ECC_CURVE_P521    "1.3.132.0.35"
+#define szOID_ECDSA_SHA1        "1.2.840.10045.4.1"
+#define szOID_ECDSA_SPECIFIED   "1.2.840.10045.4.3"
+#define szOID_ECDSA_SHA256      "1.2.840.10045.4.3.2"
+#define szOID_ECDSA_SHA384      "1.2.840.10045.4.3.3"
+#define szOID_ECDSA_SHA512      "1.2.840.10045.4.3.4"
+#define szOID_NIST_AES128_CBC        "2.16.840.1.101.3.4.1.2"
+#define szOID_NIST_AES192_CBC        "2.16.840.1.101.3.4.1.22"
+#define szOID_NIST_AES256_CBC        "2.16.840.1.101.3.4.1.42"
+#define szOID_NIST_AES128_WRAP       "2.16.840.1.101.3.4.1.5"
+#define szOID_NIST_AES192_WRAP       "2.16.840.1.101.3.4.1.25"
+#define szOID_NIST_AES256_WRAP       "2.16.840.1.101.3.4.1.45"
+#define szOID_DH_SINGLE_PASS_STDDH_SHA1_KDF   "1.3.133.16.840.63.0.2"
+#define szOID_DH_SINGLE_PASS_STDDH_SHA256_KDF "1.3.132.1.11.1"
+#define szOID_DH_SINGLE_PASS_STDDH_SHA384_KDF "1.3.132.1.11.2"
+#define szOID_DS                "2.5"
+#define szOID_DSALG             "2.5.8"
+#define szOID_DSALG_CRPT        "2.5.8.1"
+#define szOID_DSALG_HASH        "2.5.8.2"
+#define szOID_DSALG_SIGN        "2.5.8.3"
+#define szOID_DSALG_RSA         "2.5.8.1.1"
+#define szOID_OIW               "1.3.14"
+#define szOID_OIWSEC            "1.3.14.3.2"
+#define szOID_OIWSEC_md4RSA     "1.3.14.3.2.2"
+#define szOID_OIWSEC_md5RSA     "1.3.14.3.2.3"
+#define szOID_OIWSEC_md4RSA2    "1.3.14.3.2.4"
+#define szOID_OIWSEC_desECB     "1.3.14.3.2.6"
+#define szOID_OIWSEC_desCBC     "1.3.14.3.2.7"
+#define szOID_OIWSEC_desOFB     "1.3.14.3.2.8"
+#define szOID_OIWSEC_desCFB     "1.3.14.3.2.9"
+#define szOID_OIWSEC_desMAC     "1.3.14.3.2.10"
+#define szOID_OIWSEC_rsaSign    "1.3.14.3.2.11"
+#define szOID_OIWSEC_dsa        "1.3.14.3.2.12"
+#define szOID_OIWSEC_shaDSA     "1.3.14.3.2.13"
+#define szOID_OIWSEC_mdc2RSA    "1.3.14.3.2.14"
+#define szOID_OIWSEC_shaRSA     "1.3.14.3.2.15"
+#define szOID_OIWSEC_dhCommMod  "1.3.14.3.2.16"
+#define szOID_OIWSEC_desEDE     "1.3.14.3.2.17"
+#define szOID_OIWSEC_sha        "1.3.14.3.2.18"
+#define szOID_OIWSEC_mdc2       "1.3.14.3.2.19"
+#define szOID_OIWSEC_dsaComm    "1.3.14.3.2.20"
+#define szOID_OIWSEC_dsaCommSHA "1.3.14.3.2.21"
+#define szOID_OIWSEC_rsaXchg    "1.3.14.3.2.22"
+#define szOID_OIWSEC_keyHashSeal "1.3.14.3.2.23"
+#define szOID_OIWSEC_md2RSASign "1.3.14.3.2.24"
+#define szOID_OIWSEC_md5RSASign "1.3.14.3.2.25"
+#define szOID_OIWSEC_sha1       "1.3.14.3.2.26"
+#define szOID_OIWSEC_dsaSHA1    "1.3.14.3.2.27"
+#define szOID_OIWSEC_dsaCommSHA1 "1.3.14.3.2.28"
+#define szOID_OIWSEC_sha1RSASign "1.3.14.3.2.29"
+#define szOID_OIWDIR            "1.3.14.7.2"
+#define szOID_OIWDIR_CRPT       "1.3.14.7.2.1"
+#define szOID_OIWDIR_HASH       "1.3.14.7.2.2"
+#define szOID_OIWDIR_SIGN       "1.3.14.7.2.3"
+#define szOID_OIWDIR_md2        "1.3.14.7.2.2.1"
+#define szOID_OIWDIR_md2RSA     "1.3.14.7.2.3.1"
+#define szOID_INFOSEC                       "2.16.840.1.101.2.1"
+#define szOID_INFOSEC_sdnsSignature         "2.16.840.1.101.2.1.1.1"
+#define szOID_INFOSEC_mosaicSignature       "2.16.840.1.101.2.1.1.2"
+#define szOID_INFOSEC_sdnsConfidentiality   "2.16.840.1.101.2.1.1.3"
+#define szOID_INFOSEC_mosaicConfidentiality "2.16.840.1.101.2.1.1.4"
+#define szOID_INFOSEC_sdnsIntegrity         "2.16.840.1.101.2.1.1.5"
+#define szOID_INFOSEC_mosaicIntegrity       "2.16.840.1.101.2.1.1.6"
+#define szOID_INFOSEC_sdnsTokenProtection   "2.16.840.1.101.2.1.1.7"
+#define szOID_INFOSEC_mosaicTokenProtection "2.16.840.1.101.2.1.1.8"
+#define szOID_INFOSEC_sdnsKeyManagement     "2.16.840.1.101.2.1.1.9"
+#define szOID_INFOSEC_mosaicKeyManagement   "2.16.840.1.101.2.1.1.10"
+#define szOID_INFOSEC_sdnsKMandSig          "2.16.840.1.101.2.1.1.11"
+#define szOID_INFOSEC_mosaicKMandSig        "2.16.840.1.101.2.1.1.12"
+#define szOID_INFOSEC_SuiteASignature       "2.16.840.1.101.2.1.1.13"
+#define szOID_INFOSEC_SuiteAConfidentiality "2.16.840.1.101.2.1.1.14"
+#define szOID_INFOSEC_SuiteAIntegrity       "2.16.840.1.101.2.1.1.15"
+#define szOID_INFOSEC_SuiteATokenProtection "2.16.840.1.101.2.1.1.16"
+#define szOID_INFOSEC_SuiteAKeyManagement   "2.16.840.1.101.2.1.1.17"
+#define szOID_INFOSEC_SuiteAKMandSig        "2.16.840.1.101.2.1.1.18"
+#define szOID_INFOSEC_mosaicUpdatedSig      "2.16.840.1.101.2.1.1.19"
+#define szOID_INFOSEC_mosaicKMandUpdSig     "2.16.840.1.101.2.1.1.20"
+#define szOID_INFOSEC_mosaicUpdatedInteg    "2.16.840.1.101.2.1.1.21"
+#define szOID_NIST_sha256                   "2.16.840.1.101.3.4.2.1"
+#define szOID_NIST_sha384                   "2.16.840.1.101.3.4.2.2"
+#define szOID_NIST_sha512                   "2.16.840.1.101.3.4.2.3"
+
+
+#define CRYPT_E_NOT_FOUND                (0x80092004L)
+
+
+#define CERT_STORE_NO_CRYPT_RELEASE_FLAG                0x00000001
+#define CERT_STORE_SET_LOCALIZED_NAME_FLAG              0x00000002
+#define CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG     0x00000004
+#define CERT_STORE_DELETE_FLAG                          0x00000010
+#define CERT_STORE_UNSAFE_PHYSICAL_FLAG                 0x00000020
+#define CERT_STORE_SHARE_STORE_FLAG                     0x00000040
+#define CERT_STORE_SHARE_CONTEXT_FLAG                   0x00000080
+#define CERT_STORE_MANIFOLD_FLAG                        0x00000100
+#define CERT_STORE_ENUM_ARCHIVED_FLAG                   0x00000200
+#define CERT_STORE_UPDATE_KEYID_FLAG                    0x00000400
+#define CERT_STORE_BACKUP_RESTORE_FLAG                  0x00000800
+#define CERT_STORE_READONLY_FLAG                        0x00008000
+#define CERT_STORE_OPEN_EXISTING_FLAG                   0x00004000
+#define CERT_STORE_CREATE_NEW_FLAG                      0x00002000
+#define CERT_STORE_MAXIMUM_ALLOWED_FLAG                 0x00001000
+
+
+
+#define CRYPT_USER_KEYSET           0x00001000
+#define PKCS12_PREFER_CNG_KSP       0x00000100
+#define PKCS12_ALWAYS_CNG_KSP       0x00000200
+#define PKCS12_ALLOW_OVERWRITE_KEY  0x00004000
+#define PKCS12_NO_PERSIST_KEY       0x00008000
+
+
+#define CRYPT_VERIFYCONTEXT     0xF0000000
+#define CRYPT_NEWKEYSET         0x00000008
+#define CRYPT_DELETEKEYSET      0x00000010
+#define CRYPT_MACHINE_KEYSET    0x00000020
+#define CRYPT_SILENT            0x00000040
+#define CRYPT_DEFAULT_CONTAINER_OPTIONAL 0x00000080
+
+
+#define CRYPT_EXPORTABLE        0x00000001
+#define CRYPT_USER_PROTECTED    0x00000002
+#define CRYPT_CREATE_SALT       0x00000004
+#define CRYPT_UPDATE_KEY        0x00000008
+#define CRYPT_NO_SALT           0x00000010
+#define CRYPT_PREGEN            0x00000040
+#define CRYPT_RECIPIENT         0x00000010
+#define CRYPT_INITIATOR         0x00000040
+#define CRYPT_ONLINE            0x00000080
+#define CRYPT_SF                0x00000100
+#define CRYPT_CREATE_IV         0x00000200
+#define CRYPT_KEK               0x00000400
+#define CRYPT_DATA_KEY          0x00000800
+#define CRYPT_VOLATILE          0x00001000
+#define CRYPT_SGCKEY            0x00002000
+#define CRYPT_ARCHIVABLE        0x00004000
+#define CRYPT_FORCE_KEY_PROTECTION_HIGH 0x00008000
+
+
+#define CRYPT_ENCODE_DECODE_NONE            0
+#define X509_CERT                           (1)
+#define X509_CERT_TO_BE_SIGNED              (2)
+#define X509_CERT_CRL_TO_BE_SIGNED          (3)
+#define X509_CERT_REQUEST_TO_BE_SIGNED      (4)
+#define X509_EXTENSIONS                     (5)
+#define X509_NAME_VALUE                     (6)
+#define X509_NAME                           (7)
+#define X509_PUBLIC_KEY_INFO                (8)
+
+
+#define X509_AUTHORITY_KEY_ID               (9)
+#define X509_KEY_ATTRIBUTES                 (10)
+#define X509_KEY_USAGE_RESTRICTION          (11)
+#define X509_ALTERNATE_NAME                 (12)
+#define X509_BASIC_CONSTRAINTS              (13)
+#define X509_KEY_USAGE                      (14)
+#define X509_BASIC_CONSTRAINTS2             (15)
+#define X509_CERT_POLICIES                  (16)
+
+
+#define PKCS_UTC_TIME                       (17)
+#define PKCS_TIME_REQUEST                   (18)
+#define RSA_CSP_PUBLICKEYBLOB               (19)
+#define X509_UNICODE_NAME                   (20)
+
+#define X509_KEYGEN_REQUEST_TO_BE_SIGNED    (21)
+#define PKCS_ATTRIBUTE                      (22)
+#define PKCS_CONTENT_INFO_SEQUENCE_OF_ANY   (23)
+
+
+
+#define X509_UNICODE_NAME_VALUE             (24)
+#define X509_ANY_STRING                     X509_NAME_VALUE
+#define X509_UNICODE_ANY_STRING             X509_UNICODE_NAME_VALUE
+#define X509_OCTET_STRING                   (25)
+#define X509_BITS                           (26)
+#define X509_INTEGER                        (27)
+#define X509_MULTI_BYTE_INTEGER             (28)
+#define X509_ENUMERATED                     (29)
+#define X509_CHOICE_OF_TIME                 (30)
+
+#define CERT_SIMPLE_NAME_STR        1
+#define CERT_OID_NAME_STR           2
+#define CERT_X500_NAME_STR          3
+#define CERT_XML_NAME_STR           4
+
+#define AT_KEYEXCHANGE          1
+#define AT_SIGNATURE            2
+
+
+
+#define MS_DEF_PROV_A           "Microsoft Base Cryptographic Provider v1.0"
+#define MS_DEF_PROV_W           u"Microsoft Base Cryptographic Provider v1.0"
+#define MS_DEF_PROV             MS_DEF_PROV_A
+
+#define MS_ENHANCED_PROV_A      "Microsoft Enhanced Cryptographic Provider v1.0"
+#define MS_ENHANCED_PROV_W      u"Microsoft Enhanced Cryptographic Provider v1.0"
+#define MS_ENHANCED_PROV        MS_ENHANCED_PROV_A
+
+
+#define MS_STRONG_PROV_A        "Microsoft Strong Cryptographic Provider"
+#define MS_STRONG_PROV_W        u"Microsoft Strong Cryptographic Provider"
+#define MS_STRONG_PROV        MS_STRONG_PROV_A
+
+#define MS_DEF_RSA_SIG_PROV_A   "Microsoft RSA Signature Cryptographic Provider"
+#define MS_DEF_RSA_SIG_PROV_W   u"Microsoft RSA Signature Cryptographic Provider"
+#define MS_DEF_RSA_SIG_PROV   MS_DEF_RSA_SIG_PROV_W
+
+
+#define CERT_STORE_ADD_NEW                                  1
+#define CERT_STORE_ADD_USE_EXISTING                         2
+#define CERT_STORE_ADD_REPLACE_EXISTING                     3
+#define CERT_STORE_ADD_ALWAYS                               4
+#define CERT_STORE_ADD_REPLACE_EXISTING_INHERIT_PROPERTIES  5
+#define CERT_STORE_ADD_NEWER                                6
+#define CERT_STORE_ADD_NEWER_INHERIT_PROPERTIES             7
+
+
+#define PROV_RSA_FULL           1
+#define PROV_RSA_SIG            2
+#define PROV_DSS                3
+#define PROV_FORTEZZA           4
+#define PROV_MS_EXCHANGE        5
+#define PROV_SSL                6
+#define PROV_RSA_SCHANNEL       12
+#define PROV_DSS_DH             13
+#define PROV_EC_ECDSA_SIG       14
+#define PROV_EC_ECNRA_SIG       15
+#define PROV_EC_ECDSA_FULL      16
+#define PROV_EC_ECNRA_FULL      17
+#define PROV_DH_SCHANNEL        18
+#define PROV_SPYRUS_LYNKS       20
+#define PROV_RNG                21
+#define PROV_INTEL_SEC          22
+#define PROV_REPLACE_OWF        23
+#define PROV_RSA_AES            24
+
+
+
+#define REPORT_NO_PRIVATE_KEY                   0x0001
+#define REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY   0x0002
+#define EXPORT_PRIVATE_KEYS                     0x0004
+#define PKCS12_INCLUDE_EXTENDED_PROPERTIES      0x0010
+#define PKCS12_EXPORT_RESERVED_MASK             0xffff0000
+
+
+#define CERT_SYSTEM_STORE_UNPROTECTED_FLAG      0x40000000
+#define CERT_SYSTEM_STORE_LOCATION_MASK         0x00FF0000
+#define CERT_SYSTEM_STORE_LOCATION_SHIFT        16
+
+
+#define CERT_SYSTEM_STORE_CURRENT_USER_ID       1
+#define CERT_SYSTEM_STORE_LOCAL_MACHINE_ID      2
+#define CERT_SYSTEM_STORE_CURRENT_SERVICE_ID    4
+#define CERT_SYSTEM_STORE_SERVICES_ID           5
+#define CERT_SYSTEM_STORE_USERS_ID              6
+#define CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID    7
+#define CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID   8
+#define CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID     9
+
+#define CERT_SYSTEM_STORE_CURRENT_USER              (CERT_SYSTEM_STORE_CURRENT_USER_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT)
+#define CERT_SYSTEM_STORE_LOCAL_MACHINE             (CERT_SYSTEM_STORE_LOCAL_MACHINE_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT)
+#define CERT_SYSTEM_STORE_CURRENT_SERVICE           (CERT_SYSTEM_STORE_CURRENT_SERVICE_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT)
+#define CERT_SYSTEM_STORE_SERVICES                  (CERT_SYSTEM_STORE_SERVICES_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT)
+#define CERT_SYSTEM_STORE_USERS                     (CERT_SYSTEM_STORE_USERS_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT)
+
+#define CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY       (CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT)
+#define CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY      (CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT)
+#define CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE      (CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE_ID << CERT_SYSTEM_STORE_LOCATION_SHIFT)
+

ctypes_generation/definitions/flag.py

@@ -0,0 +1,50 @@
+import sys
+
+if sys.version_info.major == 3:
+    long = int
+
+class Flag(long):
+    def __new__(cls, name, value):
+        return super(Flag, cls).__new__(cls, value)
+
+    def __init__(self, name, value):
+        self.name = name
+
+    def __repr__(self):
+        return "{0}({1})".format(self.name, hex(self))
+
+    __str__ = __repr__
+
+   # Fix pickling with protocol 2
+    def __getnewargs__(self, *args):
+        return self.name, long(self)
+
+class StrFlag(str):
+    def __new__(cls, name, value):
+        if isinstance(value, cls):
+            return value
+        return super(StrFlag, cls).__new__(cls, value)
+
+    def __init__(self, name, value):
+        self.name = name
+
+    def __repr__(self):
+        return "{0}({1})".format(self.name, str.__repr__(self))
+
+    # __str__ = __repr__
+
+    # Fix pickling with protocol 2
+    def __getnewargs__(self, *args):
+        return self.name, str.__str__(self)
+
+def make_flag(name, value):
+    if isinstance(value, (int, long)):
+        return Flag(name, value)
+    return StrFlag(name, value)
+
+class FlagMapper(dict):
+    def __init__(self, *values):
+        self.update({x:x for x in values})
+
+    def __missing__(self, key):
+        return key

ctypes_generation/definitions/functions/com.txt

@@ -0,0 +1,41 @@
+HRESULT WINAPI CoInitializeEx(
+  _In_opt_ LPVOID pvReserved,
+  _In_     DWORD  dwCoInit
+);
+
+HRESULT WINAPI CoInitializeSecurity(
+  _In_opt_ PSECURITY_DESCRIPTOR        pSecDesc,
+  _In_     LONG                        cAuthSvc,
+  _In_opt_ SOLE_AUTHENTICATION_SERVICE *asAuthSvc,
+  _In_opt_ PVOID                        pReserved1,
+  _In_     DWORD                       dwAuthnLevel,
+  _In_     DWORD                       dwImpLevel,
+  _In_opt_ PVOID                       pAuthList,
+  _In_     DWORD                       dwCapabilities,
+  _In_opt_ PVOID                       pReserved3
+);
+
+HRESULT WINAPI CoCreateInstance(
+  _In_  REFCLSID  rclsid,
+  _In_  LPUNKNOWN pUnkOuter,
+  _In_  DWORD     dwClsContext,
+  _In_  REFIID    riid,
+  _Out_ LPVOID    *ppv
+);
+
+HRESULT WINAPI CoCreateInstanceEx(
+  _In_    REFCLSID     rclsid,
+  _In_    IUnknown     *punkOuter,
+  _In_    DWORD        dwClsCtx,
+  _In_    COSERVERINFO *pServerInfo,
+  _In_    DWORD        dwCount,
+  _Inout_ MULTI_QI     *pResults
+);
+
+
+HRESULT WINAPI CoGetInterceptor(
+  _In_  REFIID   iidIntercepted,
+  _In_  IUnknown *punkOuter,
+  _In_  REFIID   iid,
+  _Out_ PVOID     *ppv
+);

ctypes_generation/definitions/functions/ntfs_transaction.txt

@@ -0,0 +1,50 @@
+HANDLE WINAPI CreateFileTransactedA(
+  _In_       LPCSTR               lpFileName,
+  _In_       DWORD                 dwDesiredAccess,
+  _In_       DWORD                 dwShareMode,
+  _In_opt_   LPSECURITY_ATTRIBUTES lpSecurityAttributes,
+  _In_       DWORD                 dwCreationDisposition,
+  _In_       DWORD                 dwFlagsAndAttributes,
+  _In_opt_   HANDLE                hTemplateFile,
+  _In_       HANDLE                hTransaction,
+  _In_opt_   PUSHORT               pusMiniVersion,
+  _Reserved_ PVOID                 pExtendedParameter
+);
+
+
+HANDLE WINAPI CreateFileTransactedW(
+  _In_       LPWSTR               lpFileName,
+  _In_       DWORD                 dwDesiredAccess,
+  _In_       DWORD                 dwShareMode,
+  _In_opt_   LPSECURITY_ATTRIBUTES lpSecurityAttributes,
+  _In_       DWORD                 dwCreationDisposition,
+  _In_       DWORD                 dwFlagsAndAttributes,
+  _In_opt_   HANDLE                hTemplateFile,
+  _In_       HANDLE                hTransaction,
+  _In_opt_   PUSHORT               pusMiniVersion,
+  _Reserved_ PVOID                 pExtendedParameter
+);
+
+
+BOOL WINAPI CommitTransaction(
+  _In_ HANDLE TransactionHandle
+);
+
+HANDLE WINAPI CreateTransaction(
+  _In_opt_ LPSECURITY_ATTRIBUTES lpTransactionAttributes,
+  _In_opt_ LPGUID                UOW,
+  _In_opt_ DWORD                 CreateOptions,
+  _In_opt_ DWORD                 IsolationLevel,
+  _In_opt_ DWORD                 IsolationFlags,
+  _In_opt_ DWORD                 Timeout,
+  _In_opt_ LPWSTR                Description
+);
+
+BOOL WINAPI RollbackTransaction(
+  _In_ HANDLE TransactionHandle
+);
+
+HANDLE WINAPI OpenTransaction(
+  _In_ DWORD  dwDesiredAccess,
+  _In_ LPGUID TransactionId
+);

ctypes_generation/definitions/functions/pipe.txt

@@ -0,0 +1,35 @@
+HANDLE WINAPI CreateNamedPipeA(
+  _In_     LPCSTR                lpName,
+  _In_     DWORD                 dwOpenMode,
+  _In_     DWORD                 dwPipeMode,
+  _In_     DWORD                 nMaxInstances,
+  _In_     DWORD                 nOutBufferSize,
+  _In_     DWORD                 nInBufferSize,
+  _In_     DWORD                 nDefaultTimeOut,
+  _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes
+);
+
+HANDLE WINAPI CreateNamedPipeW(
+  _In_     LPWSTR                lpName,
+  _In_     DWORD                 dwOpenMode,
+  _In_     DWORD                 dwPipeMode,
+  _In_     DWORD                 nMaxInstances,
+  _In_     DWORD                 nOutBufferSize,
+  _In_     DWORD                 nInBufferSize,
+  _In_     DWORD                 nDefaultTimeOut,
+  _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes
+);
+
+
+BOOL WINAPI ConnectNamedPipe(
+  _In_        HANDLE       hNamedPipe,
+  _Inout_opt_ LPOVERLAPPED lpOverlapped
+);
+
+
+BOOL WINAPI SetNamedPipeHandleState(
+  _In_     HANDLE  hNamedPipe,
+  _In_opt_ LPDWORD lpMode,
+  _In_opt_ LPDWORD lpMaxCollectionCount,
+  _In_opt_ LPDWORD lpCollectDataTimeout
+);

ctypes_generation/definitions/functions/window.txt

@@ -0,0 +1,136 @@
+BOOL WINAPI GetCursorPos(
+  _Out_ LPPOINT lpPoint
+);
+
+HWND WINAPI WindowFromPoint(
+  _In_ POINT Point
+);
+
+BOOL WINAPI GetWindowRect(
+  _In_  HWND   hWnd,
+  _Out_ LPRECT lpRect
+);
+
+BOOL WINAPI EnumWindows(
+    __in WNDENUMPROC lpEnumFunc,
+    __in LPARAM lParam
+);
+
+
+INT WINAPI GetWindowTextA(
+    __in HWND hWnd,
+    __out LPSTR lpString,
+    __in INT nMaxCount
+);
+
+HWND WINAPI GetParent(
+  _In_ HWND hWnd
+);
+
+INT WINAPI GetWindowTextW(
+    __in HWND hWnd,
+    __out LPWSTR lpString,
+    __in INT nMaxCount
+);
+
+UINT WINAPI GetWindowModuleFileNameA(
+    __in HWND hwnd,
+    __out LPSTR pszFileName,
+    __in UINT cchFileNameMax);
+
+UINT WINAPI GetWindowModuleFileNameW(
+    __in HWND hwnd,
+    __out LPWSTR pszFileName,
+    __in UINT cchFileNameMax);
+
+
+BOOL WINAPI EnumChildWindows(
+  _In_opt_ HWND        hWndParent,
+  _In_     WNDENUMPROC lpEnumFunc,
+  _In_     LPARAM      lParam
+);
+
+BOOL WINAPI CloseWindow(
+  _In_ HWND hWnd
+);
+
+HWND WINAPI GetDesktopWindow();
+
+HWND WINAPI GetForegroundWindow();
+
+
+BOOL WINAPI BringWindowToTop(
+  _In_ HWND hWnd
+);
+
+BOOL WINAPI MoveWindow(
+  _In_ HWND hWnd,
+  _In_ INT  X,
+  _In_ INT  Y,
+  _In_ INT  nWidth,
+  _In_ INT  nHeight,
+  _In_ BOOL bRepaint
+);
+
+
+BOOL WINAPI SetWindowPos(
+  _In_     HWND hWnd,
+  _In_opt_ HWND hWndInsertAfter,
+  _In_     INT  X,
+  _In_     INT  Y,
+  _In_     INT  cx,
+  _In_     INT  cy,
+  _In_     UINT uFlags
+);
+
+BOOL WINAPI SetWindowTextA(
+  _In_     HWND    hWnd,
+  _In_opt_ LPCSTR lpString
+);
+
+BOOL WINAPI SetWindowTextW(
+  _In_     HWND    hWnd,
+  _In_opt_ LPWSTR lpString
+);
+
+UINT WINAPI RealGetWindowClassA(
+  _In_  HWND   hwnd,
+  _Out_ LPCSTR pszType,
+  _In_  UINT   cchType
+);
+
+UINT WINAPI RealGetWindowClassW(
+  _In_  HWND   hwnd,
+  _Out_ LPWSTR pszType,
+  _In_  UINT   cchType
+);
+
+BOOL WINAPI GetClassInfoExA(
+  _In_opt_ HINSTANCE    hinst,
+  _In_     LPCSTR      lpszClass,
+  _Out_    LPWNDCLASSEXA lpwcx
+);
+
+BOOL WINAPI GetClassInfoExW(
+  _In_opt_ HINSTANCE    hinst,
+  _In_     LPCWSTR      lpszClass,
+  _Out_    LPWNDCLASSEXW lpwcx
+);
+
+INT WINAPI GetClassNameA(
+  _In_  HWND   hWnd,
+  _Out_ LPCSTR lpClassName,
+  _In_  INT    nMaxCount
+);
+
+INT WINAPI GetClassNameW(
+  _In_  HWND   hWnd,
+  _Out_ LPWSTR lpClassName,
+  _In_  INT    nMaxCount
+);
+
+DWORD WINAPI GetWindowThreadProcessId(
+  _In_      HWND    hWnd,
+  _Out_opt_ LPDWORD lpdwProcessId
+);
+

ctypes_generation/definitions/functions/winfunc_alpc.txt

@@ -0,0 +1,158 @@
+NTSTATUS WINAPI NtAlpcCreatePort(
+    _Out_ PHANDLE PortHandle,
+    _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes,
+    _In_opt_ PALPC_PORT_ATTRIBUTES PortAttributes
+);
+
+NTSTATUS WINAPI NtAlpcQueryInformation(
+    _In_opt_ HANDLE PortHandle,
+    _In_ ALPC_PORT_INFORMATION_CLASS PortInformationClass,
+    _Inout_opt_ PVOID PortInformation,
+    _In_ ULONG Length,
+    _Out_opt_ PULONG ReturnLength
+);
+
+
+NTSTATUS WINAPI NtAlpcQueryInformationMessage(
+    _In_ HANDLE PortHandle,
+    _In_ PPORT_MESSAGE PortMessage,
+    _In_ ALPC_MESSAGE_INFORMATION_CLASS MessageInformationClass,
+    _Out_opt_ PVOID MessageInformation,
+    _In_ ULONG Length,
+    _Out_opt_ PULONG ReturnLength
+);
+
+NTSTATUS WINAPI NtAlpcConnectPort(
+    _Out_ PHANDLE PortHandle,
+    _In_ PUNICODE_STRING PortName,
+    _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes,
+    _In_opt_ PALPC_PORT_ATTRIBUTES PortAttributes,
+    _In_ ULONG Flags,
+    _In_opt_ PSID RequiredServerSid,
+    _Inout_opt_ PPORT_MESSAGE ConnectionMessage,
+    _Inout_opt_ PULONG BufferLength,
+    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES OutMessageAttributes,
+    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES InMessageAttributes,
+    _In_opt_ PLARGE_INTEGER Timeout
+);
+
+NTSTATUS WINAPI NtAlpcConnectPortEx(
+    _Out_ PHANDLE PortHandle,
+    _In_ POBJECT_ATTRIBUTES ConnectionPortObjectAttributes,
+    _In_opt_ POBJECT_ATTRIBUTES ClientPortObjectAttributes,
+    _In_opt_ PALPC_PORT_ATTRIBUTES PortAttributes,
+    _In_ ULONG Flags,
+    _In_opt_ PSECURITY_DESCRIPTOR ServerSecurityRequirements,
+    _Inout_opt_ PPORT_MESSAGE ConnectionMessage,
+    _Inout_opt_ PSIZE_T BufferLength,
+    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES OutMessageAttributes,
+    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES InMessageAttributes,
+    _In_opt_ PLARGE_INTEGER Timeout
+);
+
+
+NTSTATUS WINAPI NtAlpcAcceptConnectPort(
+    _Out_ PHANDLE PortHandle,
+    _In_ HANDLE ConnectionPortHandle,
+    _In_ ULONG Flags,
+    _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes,
+    _In_opt_ PALPC_PORT_ATTRIBUTES PortAttributes,
+    _In_opt_ PVOID PortContext,
+    _In_ PPORT_MESSAGE ConnectionRequest,
+    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES ConnectionMessageAttributes,
+    _In_ BOOLEAN AcceptConnection
+);
+
+NTSTATUS WINAPI AlpcInitializeMessageAttribute(
+    _In_ ULONG AttributeFlags,
+    _Out_opt_ PALPC_MESSAGE_ATTRIBUTES Buffer,
+    _In_ ULONG BufferSize,
+    _Out_ PULONG RequiredBufferSize
+);
+
+PVOID WINAPI AlpcGetMessageAttribute(
+    _In_ PALPC_MESSAGE_ATTRIBUTES Buffer,
+    _In_ ULONG AttributeFlag
+);
+
+NTSTATUS WINAPI NtAlpcSendWaitReceivePort(
+    _In_ HANDLE PortHandle,
+    _In_ ULONG Flags,
+    _In_opt_ PPORT_MESSAGE SendMessage,
+    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES SendMessageAttributes,
+    _Out_opt_ PPORT_MESSAGE ReceiveMessage,
+    _Inout_opt_ PSIZE_T BufferLength,
+    _Inout_opt_ PALPC_MESSAGE_ATTRIBUTES ReceiveMessageAttributes,
+    _In_opt_ PLARGE_INTEGER Timeout
+);
+
+NTSTATUS WINAPI NtAlpcDisconnectPort(
+    _In_ HANDLE PortHandle,
+    _In_ ULONG Flags
+);
+
+NTSTATUS WINAPI NtAlpcCreatePortSection(
+    _In_ HANDLE PortHandle,
+    _In_ ULONG Flags,
+    _In_opt_ HANDLE SectionHandle,
+    _In_ SIZE_T SectionSize,
+    _Out_ PALPC_HANDLE AlpcSectionHandle,
+    _Out_ PSIZE_T ActualSectionSize
+    );
+
+NTSTATUS WINAPI NtAlpcDeletePortSection(
+    _In_ HANDLE PortHandle,
+    _Reserved_ ULONG Flags,
+    _In_ ALPC_HANDLE SectionHandle
+    );
+
+
+
+NTSTATUS WINAPI NtAlpcCreateResourceReserve(
+    _In_ HANDLE PortHandle,
+    _Reserved_ ULONG Flags,
+    _In_ SIZE_T MessageSize,
+    _Out_ PALPC_HANDLE ResourceId
+    );
+
+
+NTSTATUS WINAPI NtAlpcDeleteResourceReserve(
+    _In_ HANDLE PortHandle,
+    _Reserved_ ULONG Flags,
+    _In_ ALPC_HANDLE ResourceId
+    );
+
+
+NTSTATUS WINAPI NtAlpcCreateSectionView(
+    _In_ HANDLE PortHandle,
+    _Reserved_ ULONG Flags,
+    _Inout_ PALPC_DATA_VIEW_ATTR ViewAttributes
+    );
+
+
+NTSTATUS WINAPI NtAlpcDeleteSectionView(
+    _In_ HANDLE PortHandle,
+    _Reserved_ ULONG Flags,
+    _In_ PVOID ViewBase
+    );
+
+
+NTSTATUS WINAPI NtAlpcCreateSecurityContext(
+    _In_ HANDLE PortHandle,
+    _Reserved_ ULONG Flags,
+    _Inout_ PALPC_SECURITY_ATTR SecurityAttribute
+    );
+
+
+NTSTATUS WINAPI NtAlpcDeleteSecurityContext(
+    _In_ HANDLE PortHandle,
+    _Reserved_ ULONG Flags,
+    _In_ ALPC_HANDLE ContextHandle
+    );
+
+
+NTSTATUS WINAPI NtAlpcRevokeSecurityContext(
+    _In_ HANDLE PortHandle,
+    _Reserved_ ULONG Flags,
+    _In_ ALPC_HANDLE ContextHandle
+    );

ctypes_generation/definitions/functions/winfunc_crypto.txt.ignore

@@ -0,0 +1,36 @@
+BOOL WINAPI CryptCATAdminCalcHashFromFileHandle(
+    __in HANDLE hFile,
+    __inout DWORD *pcbHash,
+    _Out_opt_ BYTE *pbHash,
+    __in DWORD dwFlags);
+
+HCATINFO WINAPI CryptCATAdminEnumCatalogFromHash(
+    __in HCATADMIN hCatAdmin,
+    __in BYTE *pbHash,
+    __in DWORD cbHash,
+    __in DWORD dwFlags,
+    __inout HCATINFO *phPrevCatInfo);
+
+BOOL WINAPI CryptCATAdminAcquireContext(
+  _Out_       HCATADMIN *phCatAdmin,
+  _In_        GUID      *pgSubsystem,
+  _In_        DWORD     dwFlags
+);
+
+BOOL WINAPI CryptCATCatalogInfoFromContext(
+  _In_    HCATINFO     hCatInfo,
+  _Inout_ CATALOG_INFO *psCatInfo,
+  _In_    DWORD        dwFlags
+);
+
+
+BOOL WINAPI CryptCATAdminReleaseCatalogContext(
+  _In_ HCATADMIN hCatAdmin,
+  _In_ HCATINFO  hCatInfo,
+  _In_ DWORD     dwFlags
+);
+
+BOOL WINAPI CryptCATAdminReleaseContext(
+  _In_ HCATADMIN hCatAdmin,
+  _In_ DWORD     dwFlags
+);

ctypes_generation/definitions/functions/winfunc_crypto_wintrust.txt

@@ -0,0 +1,381 @@
+BOOL WINAPI CryptCATAdminCalcHashFromFileHandle(
+    __in HANDLE hFile,
+    __inout DWORD *pcbHash,
+    _Out_opt_ BYTE *pbHash,
+    __in DWORD dwFlags);
+
+HCATINFO WINAPI CryptCATAdminEnumCatalogFromHash(
+    __in HCATADMIN hCatAdmin,
+    __in BYTE *pbHash,
+    __in DWORD cbHash,
+    __in DWORD dwFlags,
+    __inout HCATINFO *phPrevCatInfo);
+
+BOOL WINAPI CryptCATAdminAcquireContext(
+  _Out_       HCATADMIN *phCatAdmin,
+  _In_        GUID      *pgSubsystem,
+  _In_        DWORD     dwFlags
+);
+
+BOOL WINAPI CryptCATCatalogInfoFromContext(
+  _In_    HCATINFO     hCatInfo,
+  _Inout_ CATALOG_INFO *psCatInfo,
+  _In_    DWORD        dwFlags
+);
+
+
+BOOL WINAPI CryptCATAdminReleaseCatalogContext(
+  _In_ HCATADMIN hCatAdmin,
+  _In_ HCATINFO  hCatInfo,
+  _In_ DWORD     dwFlags
+);
+
+BOOL WINAPI CryptCATAdminReleaseContext(
+  _In_ HCATADMIN hCatAdmin,
+  _In_ DWORD     dwFlags
+);
+
+CRYPTCATATTRIBUTE* WINAPI CryptCATGetAttrInfo(
+  _In_ HANDLE         hCatalog,
+  _In_ CRYPTCATMEMBER *pCatMember,
+  _In_ LPWSTR         pwszReferenceTag
+);
+
+CRYPTCATMEMBER* WINAPI CryptCATGetMemberInfo(
+  _In_ HANDLE hCatalog,
+  _In_ LPWSTR pwszReferenceTag
+);
+
+CRYPTCATATTRIBUTE* WINAPI CryptCATGetAttrInfo(
+  _In_ HANDLE         hCatalog,
+  _In_ CRYPTCATMEMBER *pCatMember,
+  _In_ LPWSTR         pwszReferenceTag
+);
+
+CRYPTCATATTRIBUTE* WINAPI CryptCATEnumerateCatAttr(
+  _In_ HANDLE            hCatalog,
+  _In_ CRYPTCATATTRIBUTE *pPrevAttr
+);
+
+CRYPTCATATTRIBUTE* WINAPI CryptCATEnumerateAttr(
+  _In_ HANDLE            hCatalog,
+  _In_ CRYPTCATMEMBER    *pCatMember,
+  _In_ CRYPTCATATTRIBUTE *pPrevAttr
+);
+
+CRYPTCATMEMBER* WINAPI CryptCATEnumerateMember(
+  _In_ HANDLE         hCatalog,
+  _In_ CRYPTCATMEMBER *pPrevMember
+);
+
+BOOL WINAPI CryptQueryObject(
+  _In_        DWORD      dwObjectType,
+  _In_        VOID       *pvObject,
+  _In_        DWORD      dwExpectedContentTypeFlags,
+  _In_        DWORD      dwExpectedFormatTypeFlags,
+  _In_        DWORD      dwFlags,
+  _Out_       DWORD      *pdwMsgAndCertEncodingType,
+  _Out_       DWORD      *pdwContentType,
+  _Out_       DWORD      *pdwFormatType,
+  _Out_       HCERTSTORE *phCertStore,
+  _Out_       HCRYPTMSG  *phMsg,
+  _Out_       PVOID       *ppvContext
+);
+
+BOOL WINAPI CryptMsgGetParam(
+  _In_    HCRYPTMSG hCryptMsg,
+  _In_    DWORD     dwParamType,
+  _In_    DWORD     dwIndex,
+  _Out_   VOID      *pvData,
+  _Inout_ DWORD     *pcbData
+);
+
+
+BOOL WINAPI CryptDecodeObject(
+  _In_          DWORD  dwCertEncodingType,
+  _In_          LPCSTR lpszStructType,
+  _In_          BYTE   *pbEncoded,
+  _In_          DWORD  cbEncoded,
+  _In_          DWORD  dwFlags,
+  _Out_         VOID   *pvStructInfo,
+  _Inout_       DWORD  *pcbStructInfo
+);
+
+
+PCCERT_CONTEXT WINAPI CertFindCertificateInStore(
+  _In_       HCERTSTORE     hCertStore,
+  _In_       DWORD          dwCertEncodingType,
+  _In_       DWORD          dwFindFlags,
+  _In_       DWORD          dwFindType,
+  _In_       VOID           *pvFindPara,
+  _In_       PCCERT_CONTEXT pPrevCertContext
+);
+
+DWORD WINAPI CertGetNameStringA(
+  _In_  PCCERT_CONTEXT pCertContext,
+  _In_  DWORD          dwType,
+  _In_  DWORD          dwFlags,
+  _In_  VOID           *pvTypePara,
+  _Out_ LPCSTR         pszNameString,
+  _In_  DWORD          cchNameString
+);
+
+DWORD WINAPI CertGetNameStringW(
+  _In_  PCCERT_CONTEXT pCertContext,
+  _In_  DWORD          dwType,
+  _In_  DWORD          dwFlags,
+  _In_  VOID           *pvTypePara,
+  _Out_ LPWSTR         pszNameString,
+  _In_  DWORD          cchNameString
+);
+
+
+BOOL WINAPI CertGetCertificateChain(
+  _In_opt_ HCERTCHAINENGINE     hChainEngine,
+  _In_     PCCERT_CONTEXT       pCertContext,
+  _In_opt_ LPFILETIME           pTime,
+  _In_     HCERTSTORE           hAdditionalStore,
+  _In_     PCERT_CHAIN_PARA     pChainPara,
+  _In_     DWORD                dwFlags,
+  _In_     LPVOID               pvReserved,
+  _Out_    PCCERT_CHAIN_CONTEXT *ppChainContext
+);
+
+PCCERT_CONTEXT WINAPI CertCreateSelfSignCertificate(
+  _In_opt_ HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProvOrNCryptKey,
+  _In_     PCERT_NAME_BLOB                 pSubjectIssuerBlob,
+  _In_     DWORD                           dwFlags,
+  _In_opt_ PCRYPT_KEY_PROV_INFO            pKeyProvInfo,
+  _In_opt_ PCRYPT_ALGORITHM_IDENTIFIER     pSignatureAlgorithm,
+  _In_opt_ PSYSTEMTIME                     pStartTime,
+  _In_opt_ PSYSTEMTIME                     pEndTime,
+  _In_opt_ PCERT_EXTENSIONS                pExtensions
+);
+
+
+BOOL WINAPI CertStrToNameA(
+  _In_      DWORD   dwCertEncodingType,
+  _In_      LPCSTR  pszX500,
+  _In_      DWORD   dwStrType,
+  _In_opt_  VOID    *pvReserved,
+  _Out_     BYTE    *pbEncoded,
+  _Inout_   DWORD   *pcbEncoded,
+  _Out_opt_ LPCSTR *ppszError
+);
+
+BOOL WINAPI CertStrToNameW(
+  _In_      DWORD   dwCertEncodingType,
+  _In_      LPWSTR  pszX500,
+  _In_      DWORD   dwStrType,
+  _In_opt_  VOID    *pvReserved,
+  _Out_     BYTE    *pbEncoded,
+  _Inout_   DWORD   *pcbEncoded,
+  _Out_opt_ LPWSTR *ppszError
+);
+
+HCERTSTORE WINAPI CertOpenStore(
+  _In_       LPCSTR            lpszStoreProvider,
+  _In_       DWORD             dwMsgAndCertEncodingType,
+  _In_       HCRYPTPROV_LEGACY hCryptProv,
+  _In_       DWORD             dwFlags,
+  _In_       VOID              *pvPara
+);
+
+BOOL WINAPI CertAddCertificateContextToStore(
+  _In_      HCERTSTORE     hCertStore,
+  _In_      PCCERT_CONTEXT pCertContext,
+  _In_      DWORD          dwAddDisposition,
+  _Out_opt_ PCCERT_CONTEXT *ppStoreContext
+);
+
+BOOL WINAPI CertFreeCertificateContext(
+  _In_ PCCERT_CONTEXT pCertContext
+);
+
+
+BOOL WINAPI PFXExportCertStoreEx(
+  _In_    HCERTSTORE      hStore,
+  _Inout_ CRYPT_DATA_BLOB *pPFX,
+  _In_    LPCWSTR         szPassword,
+  _In_    VOID            *pvPara,
+  _In_    DWORD           dwFlags
+);
+
+HCERTSTORE WINAPI PFXImportCertStore(
+  _In_ CRYPT_DATA_BLOB *pPFX,
+  _In_ LPCWSTR         szPassword,
+  _In_ DWORD           dwFlags
+);
+
+
+BOOL WINAPI CryptGenKey(
+  _In_  HCRYPTPROV hProv,
+  _In_  ALG_ID     Algid,
+  _In_  DWORD      dwFlags,
+  _Out_ HCRYPTKEY  *phKey
+);
+
+BOOL WINAPI CryptDestroyKey(
+  _In_ HCRYPTKEY hKey
+);
+
+BOOL WINAPI CryptAcquireContextA(
+  _Out_ HCRYPTPROV *phProv,
+  _In_  LPCSTR    pszContainer,
+  _In_  LPCSTR    pszProvider,
+  _In_  DWORD      dwProvType,
+  _In_  DWORD      dwFlags
+);
+
+BOOL WINAPI CryptAcquireContextW(
+  _Out_ HCRYPTPROV *phProv,
+  _In_  LPWSTR    pszContainer,
+  _In_  LPWSTR    pszProvider,
+  _In_  DWORD      dwProvType,
+  _In_  DWORD      dwFlags
+);
+
+
+BOOL WINAPI CryptReleaseContext(
+  _In_ HCRYPTPROV hProv,
+  _In_ DWORD      dwFlags
+);
+
+BOOL WINAPI CryptExportKey(
+  _In_    HCRYPTKEY hKey,
+  _In_    HCRYPTKEY hExpKey,
+  _In_    DWORD     dwBlobType,
+  _In_    DWORD     dwFlags,
+  _Out_   BYTE      *pbData,
+  _Inout_ DWORD     *pdwDataLen
+);
+
+
+BOOL WINAPI CertGetCertificateContextProperty(
+  _In_    PCCERT_CONTEXT pCertContext,
+  _In_    DWORD          dwPropId,
+  _Out_   VOID           *pvData,
+  _Inout_ DWORD          *pcbData
+);
+
+DWORD WINAPI CertEnumCertificateContextProperties(
+  _In_ PCCERT_CONTEXT pCertContext,
+  _In_ DWORD          dwPropId
+);
+
+BOOL WINAPI CryptEncryptMessage(
+  _In_          PCRYPT_ENCRYPT_MESSAGE_PARA pEncryptPara,
+  _In_          DWORD                       cRecipientCert,
+  _In_          PCCERT_CONTEXT              *rgpRecipientCert,
+  _In_          BYTE                        *pbToBeEncrypted,
+  _In_          DWORD                       cbToBeEncrypted,
+  _Out_         BYTE                        *pbEncryptedBlob,
+  _Inout_       DWORD                       *pcbEncryptedBlob
+);
+
+BOOL WINAPI CryptDecryptMessage(
+  _In_              PCRYPT_DECRYPT_MESSAGE_PARA pDecryptPara,
+  _In_              BYTE                        *pbEncryptedBlob,
+  _In_              DWORD                       cbEncryptedBlob,
+  _Out_opt_         BYTE                        *pbDecrypted,
+  _Inout_opt_       DWORD                       *pcbDecrypted,
+  _Out_opt_         PCCERT_CONTEXT              *ppXchgCert
+);
+
+BOOL WINAPI CryptAcquireCertificatePrivateKey(
+  _In_     PCCERT_CONTEXT                  pCert,
+  _In_     DWORD                           dwFlags,
+  _In_opt_ VOID                            *pvParameters,
+  _Out_    HCRYPTPROV_OR_NCRYPT_KEY_HANDLE *phCryptProvOrNCryptKey,
+  _Out_    DWORD                           *pdwKeySpec,
+  _Out_    BOOL                            *pfCallerFreeProvOrNCryptKey
+);
+
+
+PCCERT_CONTEXT WINAPI CertDuplicateCertificateContext(
+  _In_ PCCERT_CONTEXT pCertContext
+);
+
+
+PCCERT_CONTEXT WINAPI CertEnumCertificatesInStore(
+  _In_ HCERTSTORE     hCertStore,
+  _In_ PCCERT_CONTEXT pPrevCertContext
+);
+
+BOOL WINAPI CryptEncodeObjectEx(
+  _In_          DWORD              dwCertEncodingType,
+  _In_          LPCSTR             lpszStructType,
+  _In_          VOID               *pvStructInfo,
+  _In_          DWORD              dwFlags,
+  _In_          PCRYPT_ENCODE_PARA pEncodePara,
+  _Out_         VOID               *pvEncoded,
+  _Inout_       DWORD              *pcbEncoded
+);
+
+PCCERT_CONTEXT WINAPI CertCreateCertificateContext(
+  _In_       DWORD dwCertEncodingType,
+  _In_       BYTE  *pbCertEncoded,
+  _In_       DWORD cbCertEncoded
+);
+
+BOOL WINAPI CertCompareCertificate(
+  _In_ DWORD      dwCertEncodingType,
+  _In_ PCERT_INFO pCertId1,
+  _In_ PCERT_INFO pCertId2
+);
+
+PCCTL_CONTEXT WINAPI CertEnumCTLsInStore(
+  _In_ HCERTSTORE    hCertStore,
+  _In_ PCCTL_CONTEXT pPrevCtlContext
+);
+
+PCCTL_CONTEXT WINAPI CertDuplicateCTLContext(
+  _In_ PCCTL_CONTEXT pCtlContext
+);
+
+BOOL WINAPI CertFreeCTLContext(
+  _In_ PCCTL_CONTEXT pCtlContext
+);
+
+
+BOOL WINAPI CryptUIDlgViewContext(
+  _In_       DWORD   dwContextType,
+  _In_       PVOID   pvContext,
+  _In_       HWND    hwnd,
+  _In_       LPCWSTR pwszTitle,
+  _In_       DWORD   dwFlags,
+  _In_       PVOID   pvReserved
+);
+
+BOOL WINAPI CryptMsgVerifyCountersignatureEncoded(
+  _In_ HCRYPTPROV_LEGACY hCryptProv,
+  _In_ DWORD             dwEncodingType,
+  _In_ PBYTE             pbSignerInfo,
+  _In_ DWORD             cbSignerInfo,
+  _In_ PBYTE             pbSignerInfoCountersignature,
+  _In_ DWORD             cbSignerInfoCountersignature,
+  _In_ PCERT_INFO        pciCountersigner
+);
+
+BOOL WINAPI CryptMsgVerifyCountersignatureEncodedEx(
+  _In_opt_   HCRYPTPROV_LEGACY hCryptProv,
+  _In_       DWORD             dwEncodingType,
+  _In_       PBYTE             pbSignerInfo,
+  _In_       DWORD             cbSignerInfo,
+  _In_       PBYTE             pbSignerInfoCountersignature,
+  _In_       DWORD             cbSignerInfoCountersignature,
+  _In_       DWORD             dwSignerType,
+  _In_       PVOID             pvSigner,
+  _Reserved_ DWORD             dwFlags,
+  _Reserved_ PVOID             pvExtra
+);
+
+BOOL WINAPI CryptHashCertificate(
+  _In_          HCRYPTPROV_LEGACY hCryptProv,
+  _In_          ALG_ID            Algid,
+  _In_          DWORD             dwFlags,
+  _In_          BYTE              *pbEncoded,
+  _In_          DWORD             cbEncoded,
+  _Out_         BYTE              *pbComputedHash,
+  _Inout_       DWORD             *pcbComputedHash
+);

ctypes_generation/definitions/functions/winfunc_evtlog.txt

@@ -0,0 +1,225 @@
+HANDLE WINAPI OpenEventLogA(
+  _In_ LPCSTR lpUNCServerName,
+  _In_ LPCSTR lpSourceName
+);
+
+HANDLE WINAPI OpenEventLogW(
+  _In_ LPWSTR lpUNCServerName,
+  _In_ LPWSTR lpSourceName
+);
+
+
+HANDLE WINAPI OpenBackupEventLogA(
+  _In_ LPCSTR lpUNCServerName,
+  _In_ LPCSTR lpSourceName
+);
+
+HANDLE WINAPI OpenBackupEventLogW(
+  _In_ LPWSTR lpUNCServerName,
+  _In_ LPWSTR lpSourceName
+);
+
+
+BOOL WINAPI ReadEventLogA(
+  _In_  HANDLE hEventLog,
+  _In_  DWORD  dwReadFlags,
+  _In_  DWORD  dwRecordOffset,
+  _Out_ LPVOID lpBuffer,
+  _In_  DWORD  nNumberOfBytesToRead,
+  _Out_ DWORD  *pnBytesRead,
+  _Out_ DWORD  *pnMinNumberOfBytesNeeded
+);
+
+BOOL WINAPI ReadEventLogW(
+  _In_  HANDLE hEventLog,
+  _In_  DWORD  dwReadFlags,
+  _In_  DWORD  dwRecordOffset,
+  _Out_ LPVOID lpBuffer,
+  _In_  DWORD  nNumberOfBytesToRead,
+  _Out_ DWORD  *pnBytesRead,
+  _Out_ DWORD  *pnMinNumberOfBytesNeeded
+);
+
+BOOL WINAPI GetEventLogInformation(
+  _In_  HANDLE  hEventLog,
+  _In_  DWORD   dwInfoLevel,
+  _Out_ LPVOID  lpBuffer,
+  _In_  DWORD   cbBufSize,
+  _Out_ LPDWORD pcbBytesNeeded
+);
+
+BOOL WINAPI GetNumberOfEventLogRecords(
+  _In_  HANDLE hEventLog,
+  _Out_ PDWORD NumberOfRecords
+);
+
+BOOL WINAPI CloseEventLog(
+  _Inout_ HANDLE hEventLog
+);
+
+
+/* Event logging */
+
+EVT_HANDLE WINAPI EvtOpenLog(
+  _In_ EVT_HANDLE Session,
+  _In_ LPCWSTR    Path,
+  _In_ DWORD      Flags
+);
+
+
+EVT_HANDLE WINAPI EvtQuery(
+  _In_ EVT_HANDLE Session,
+  _In_ LPCWSTR    Path,
+  _In_ LPCWSTR    Query,
+  _In_ DWORD      Flags
+);
+
+
+BOOL WINAPI EvtNext(
+  _In_  EVT_HANDLE  ResultSet,
+  _In_  DWORD       EventArraySize,
+  _In_  EVT_HANDLE* EventArray,
+  _In_  DWORD       Timeout,
+  _In_  DWORD       Flags,
+  _Out_ PDWORD      Returned
+);
+
+EVT_HANDLE WINAPI EvtCreateRenderContext(
+  _In_ DWORD   ValuePathsCount,
+  _In_ LPCWSTR *ValuePaths,
+  _In_ DWORD   Flags
+);
+
+BOOL WINAPI EvtRender(
+  _In_  EVT_HANDLE Context,
+  _In_  EVT_HANDLE Fragment,
+  _In_  DWORD      Flags,
+  _In_  DWORD      BufferSize,
+  _In_  PVOID      Buffer,
+  _Out_ PDWORD     BufferUsed,
+  _Out_ PDWORD     PropertyCount
+);
+
+
+BOOL WINAPI EvtClose(
+  _In_ EVT_HANDLE Object
+);
+
+
+EVT_HANDLE WINAPI EvtOpenChannelEnum(
+  _In_ EVT_HANDLE Session,
+  _In_ DWORD      Flags
+);
+
+BOOL WINAPI EvtNextChannelPath(
+  _In_  EVT_HANDLE ChannelEnum,
+  _In_  DWORD      ChannelPathBufferSize,
+  _In_  LPWSTR     ChannelPathBuffer,
+  _Out_ PDWORD     ChannelPathBufferUsed
+);
+
+EVT_HANDLE WINAPI EvtOpenPublisherEnum(
+  _In_ EVT_HANDLE Session,
+  _In_ DWORD      Flags
+);
+
+
+BOOL WINAPI EvtNextPublisherId(
+  _In_  EVT_HANDLE PublisherEnum,
+  _In_  DWORD      PublisherIdBufferSize,
+  _In_  LPWSTR     PublisherIdBuffer,
+  _Out_ PDWORD     PublisherIdBufferUsed
+);
+
+
+BOOL WINAPI EvtGetLogInfo(
+  _In_  EVT_HANDLE          Log,
+  _In_  EVT_LOG_PROPERTY_ID PropertyId,
+  _In_  DWORD               PropertyValueBufferSize,
+  _In_  PEVT_VARIANT        PropertyValueBuffer,
+  _Out_ PDWORD              PropertyValueBufferUsed
+);
+
+
+EVT_HANDLE WINAPI EvtOpenChannelConfig(
+  _In_ EVT_HANDLE Session,
+  _In_ LPCWSTR    ChannelPath,
+  _In_ DWORD      Flags
+);
+
+BOOL WINAPI EvtGetChannelConfigProperty(
+  _In_  EVT_HANDLE                     ChannelConfig,
+  _In_  EVT_CHANNEL_CONFIG_PROPERTY_ID PropertyId,
+  _In_  DWORD                          Flags,
+  _In_  DWORD                          PropertyValueBufferSize,
+  _In_  PEVT_VARIANT                   PropertyValueBuffer,
+  _Out_ PDWORD                         PropertyValueBufferUsed
+);
+
+EVT_HANDLE WINAPI EvtOpenPublisherMetadata(
+  _In_opt_ EVT_HANDLE Session,
+  _In_     LPCWSTR    PublisherIdentity,
+  _In_opt_ LPCWSTR    LogFilePath,
+  _In_     LCID       Locale,
+  _In_     DWORD      Flags
+);
+
+EVT_HANDLE WINAPI EvtOpenEventMetadataEnum(
+  _In_ EVT_HANDLE PublisherMetadata,
+  _In_ DWORD      Flags
+);
+
+EVT_HANDLE WINAPI EvtNextEventMetadata(
+  _In_ EVT_HANDLE EventMetadataEnum,
+  _In_ DWORD      Flags
+);
+
+BOOL WINAPI EvtGetEventMetadataProperty(
+  _In_  EVT_HANDLE                     EventMetadata,
+  _In_  EVT_EVENT_METADATA_PROPERTY_ID PropertyId,
+  _In_  DWORD                          Flags,
+  _In_  DWORD                          EventMetadataPropertyBufferSize,
+  _In_  PEVT_VARIANT                   EventMetadataPropertyBuffer,
+  _Out_ PDWORD                         EventMetadataPropertyBufferUsed
+);
+
+
+BOOL WINAPI EvtGetPublisherMetadataProperty(
+  _In_  EVT_HANDLE                         PublisherMetadata,
+  _In_  EVT_PUBLISHER_METADATA_PROPERTY_ID PropertyId,
+  _In_  DWORD                              Flags,
+  _In_  DWORD                              PublisherMetadataPropertyBufferSize,
+  _In_  PEVT_VARIANT                       PublisherMetadataPropertyBuffer,
+  _Out_ PDWORD                             PublisherMetadataPropertyBufferUsed
+);
+
+
+BOOL WINAPI EvtGetObjectArraySize(
+  _In_  EVT_OBJECT_ARRAY_PROPERTY_HANDLE ObjectArray,
+  _Out_ PDWORD                           ObjectArraySize
+);
+
+
+BOOL WINAPI EvtGetObjectArrayProperty(
+  _In_  EVT_OBJECT_ARRAY_PROPERTY_HANDLE ObjectArray,
+  _In_  DWORD                            PropertyId,
+  _In_  DWORD                            ArrayIndex,
+  _In_  DWORD                            Flags,
+  _In_  DWORD                            PropertyValueBufferSize,
+  _In_  PEVT_VARIANT                     PropertyValueBuffer,
+  _Out_ PDWORD                           PropertyValueBufferUsed
+);
+
+
+BOOL WINAPI EvtFormatMessage(
+  _In_  EVT_HANDLE   PublisherMetadata,
+  _In_  EVT_HANDLE   Event,
+  _In_  DWORD        MessageId,
+  _In_  DWORD        ValueCount,
+  _In_  PEVT_VARIANT Values,
+  _In_  DWORD        Flags,
+  _In_  DWORD        BufferSize,
+  _In_  LPWSTR       Buffer,
+  _Out_ PDWORD       BufferUsed
+);
+

ctypes_generation/definitions/functions/winfunc_notdoc.txt

@@ -0,0 +1,6 @@
+NTSTATUS WINAPI TpCallbackSendAlpcMessageOnCompletion(
+    _In_ HANDLE TpHandle,
+    _In_ HANDLE PortHandle,
+    _In_ ULONG Flags,
+    _In_opt_ PPORT_MESSAGE SendMessage,
+);

ctypes_generation/definitions/ntstatus_template.py

@@ -0,0 +1,29 @@
+import ctypes
+from flag import Flag
+
+class NtStatusException(WindowsError):
+    ALL_STATUS = {}
+    def __init__(self , code):
+        try:
+            x = self.ALL_STATUS[code]
+        except KeyError:
+            x = (code, 'UNKNOW_ERROR', 'Error non documented in ntstatus.py')
+        self.code = x[0]
+        self.name = x[1]
+        self.descr = x[2]
+        x =  ctypes.c_long(x[0]).value, x[1], x[2]
+        return super(NtStatusException, self).__init__(*x)
+
+    def __str__(self):
+        return "{e.name}(0x{e.code:x}): {e.descr}".format(e=self)
+
+    def __repr__(self):
+        return "{0}(0x{1:08x}, {2})".format(type(self).__name__, self.code, self.name)
+
+    @classmethod
+    def register_ntstatus(cls, code, name, descr):
+        if code in cls.ALL_STATUS:
+            return # Use the first def
+        cls.ALL_STATUS[code] = (code, name, descr)
+        return Flag(name, code)
+

ctypes_generation/definitions/simple_types.txt

@@ -0,0 +1,121 @@
+VOID = DWORD // This one is a 'cheat' to handle function returning void in ctypes
+BYTE = c_ubyte
+PWSTR = LPWSTR
+PCWSTR = LPWSTR
+SIZE_T = c_size_t
+PSIZE_T = POINTER(SIZE_T)
+PVOID = c_void_p
+NTSTATUS = DWORD
+SECURITY_INFORMATION = DWORD
+PSECURITY_INFORMATION = POINTER(SECURITY_INFORMATION)
+PULONG = POINTER(ULONG)
+PDWORD = POINTER(DWORD)
+LPDWORD = POINTER(DWORD)
+LPBYTE = POINTER(BYTE)
+ULONG_PTR = PVOID
+DWORD_PTR = ULONG_PTR
+KAFFINITY = ULONG_PTR
+KPRIORITY = LONG
+CHAR = c_char
+UCHAR = c_char
+CSHORT = c_short
+VARTYPE = c_ushort
+PUSHORT = POINTER(USHORT)
+PBOOL = POINTER(BOOL)
+PSTR = LPSTR
+PCSTR = LPSTR
+va_list = c_char_p
+BSTR = c_wchar_p
+OLECHAR = c_wchar
+POLECHAR = c_wchar_p
+PUCHAR = POINTER(UCHAR)
+double = c_double
+PSID = PVOID
+ULONGLONG = c_ulonglong
+LONGLONG = c_longlong
+ULONG64 = c_ulonglong
+UINT64 = ULONG64
+LONG64 = c_longlong
+PLARGE_INTEGER = POINTER(LARGE_INTEGER)
+DWORD64 = ULONG64
+SCODE = LONG
+CIMTYPE = LONG
+NET_IFINDEX = ULONG
+IF_INDEX = NET_IFINDEX
+IFTYPE = ULONG
+PULONG64 = POINTER(ULONG64)
+PBYTE = POINTER(BYTE)
+PUINT = POINTER(UINT)
+PHKEY = POINTER(HKEY)
+ACCESS_MASK = DWORD
+REGSAM = ACCESS_MASK
+PBOOLEAN = POINTER(BOOLEAN)
+SECURITY_CONTEXT_TRACKING_MODE = BOOLEAN
+HCRYPTPROV_LEGACY = PULONG
+HCRYPTKEY = PULONG
+HCRYPTPROV = PULONG
+HCRYPTHASH = PULONG
+ALG_ID = UINT
+DISPID = LONG
+MEMBERID = DISPID
+PSECURITY_DESCRIPTOR = PVOID
+
+LPUNKNOWN = POINTER(PVOID)
+LPFILETIME = POINTER(FILETIME)
+LPPOINT = POINTER(POINT)
+LPRECT = POINTER(RECT)
+SPC_UUID = BYTE * 16
+DEVICE_TYPE = DWORD
+PWINDBG_EXTENSION_APIS32 = PVOID
+PWINDBG_EXTENSION_APIS64 = PVOID
+
+/* INT sized*/
+
+INT8 = c_byte // signed | our BYTE is unsigned
+INT16 = SHORT
+INT32 = INT
+INT64 = LONGLONG
+
+UINT8 = BYTE
+UINT16 = USHORT
+UINT32 = UINT
+UINT64 = ULONGLONG
+
+/* HANDLES */
+
+PHANDLE = POINTER(HANDLE)
+HCATADMIN = HANDLE
+HCATINFO = HANDLE
+HCERTCHAINENGINE = HANDLE
+LPHANDLE = POINTER(HANDLE)
+ALPC_HANDLE = HANDLE
+PALPC_HANDLE = POINTER(ALPC_HANDLE)
+HCURSOR = HANDLE
+HBRUSH = HANDLE
+HCRYPTPROV_OR_NCRYPT_KEY_HANDLE = PULONG
+EVT_HANDLE = HANDLE
+EVT_OBJECT_ARRAY_PROPERTY_HANDLE = HANDLE
+
+/* COM STUFF */
+
+RPCOLEDATAREP = ULONG
+
+/* Function PTR */
+
+WNDPROC = PVOID
+LPPROC_THREAD_ATTRIBUTE_LIST = PVOID
+PPS_POST_PROCESS_INIT_ROUTINE = PVOID
+LPTHREAD_START_ROUTINE = PVOID
+WNDENUMPROC = PVOID
+PHANDLER_ROUTINE = PVOID
+FARPROC = PVOID
+PIO_APC_ROUTINE = PVOID
+PVECTORED_EXCEPTION_HANDLER = PVOID
+
+// Will be changed at import time
+
+LPCONTEXT = PVOID
+HCERTSTORE = PVOID
+HCRYPTMSG = PVOID
+PALPC_PORT_ATTRIBUTES = PVOID
+PPORT_MESSAGE = PVOID

ctypes_generation/definitions/structures/com.txt

@@ -0,0 +1,79 @@
+typedef struct tagMULTI_QI {
+  IID *pIID;
+  PVOID  *pItf;
+  HRESULT   hr;
+} MULTI_QI;
+
+
+typedef struct _COAUTHIDENTITY {
+  USHORT *User;
+  ULONG  UserLength;
+  USHORT *Domain;
+  ULONG  DomainLength;
+  USHORT *Password;
+  ULONG  PasswordLength;
+  ULONG  Flags;
+} COAUTHIDENTITY;
+
+typedef struct _COAUTHINFO {
+  DWORD          dwAuthnSvc;
+  DWORD          dwAuthzSvc;
+  LPWSTR         pwszServerPrincName;
+  DWORD          dwAuthnLevel;
+  DWORD          dwImpersonationLevel;
+  COAUTHIDENTITY *pAuthIdentityData;
+  DWORD          dwCapabilities;
+} COAUTHINFO;
+
+typedef struct _COSERVERINFO {
+  DWORD      dwReserved1;
+  LPWSTR     pwszName;
+  COAUTHINFO *pAuthInfo;
+  DWORD      dwReserved2;
+} COSERVERINFO;
+
+
+typedef struct _CALLFRAMEPARAMINFO{
+  BOOLEAN fIn;
+  BOOLEAN fOut;
+  ULONG   stackOffset;
+  ULONG   cbParam;
+} CALLFRAMEPARAMINFO;
+
+typedef struct _CALLFRAMEINFO{
+  ULONG iMethod;
+  BOOL  fHasInValues;
+  BOOL  fHasInOutValues;
+  BOOL  fHasOutValues;
+  BOOL  fDerivesFromIDispatch;
+  LONG  cInInterfacesMax;
+  LONG  cInOutInterfacesMax;
+  LONG  cOutInterfacesMax;
+  LONG  cTopLevelInInterfaces;
+  IID   iid;
+  ULONG cMethod;
+  ULONG cParams;
+} CALLFRAMEINFO;
+
+
+typedef struct _CALLFRAME_MARSHALCONTEXT{
+  BOOLEAN  fIn;
+  DWORD    dwDestContext;
+  LPVOID   pvDestContext;
+  PVOID *mshlmgr; // Was <IUnknown> how can I do for this circle dep ?
+  GUID     guidTransferSyntax;
+} CALLFRAME_MARSHALCONTEXT;
+
+
+typedef enum  _CALLFRAME_COPY{
+  CALLFRAME_COPY_NESTED       = 1,
+  CALLFRAME_COPY_INDEPENDENT  = 2
+} CALLFRAME_COPY;
+
+
+typedef enum tagMSHLFLAGS {
+  MSHLFLAGS_NORMAL       = 0,
+  MSHLFLAGS_TABLESTRONG  = 1,
+  MSHLFLAGS_TABLEWEAK    = 2,
+  MSHLFLAGS_NOPING       = 4
+} MSHLFLAGS;

ctypes_generation/definitions/structures/guid.txt

@@ -0,0 +1,8 @@
+/* I 'often' add typedef for GUID: so I put it in a specific file */
+
+typedef struct _GUID {
+    ULONG  Data1;
+    USHORT Data2;
+    USHORT Data3;
+    BYTE  Data4[ 8 ];
+} GUID, IID, CLSID, *REFIID, *REFCLSID, *LPGUID, *REFGUID;

ctypes_generation/definitions/structures/shell.txt

@@ -0,0 +1,11 @@
+typedef struct _SHITEMID {
+  USHORT cb;
+  BYTE   abID[1];
+} SHITEMID;
+
+
+/* MANUAL TYPEDEF see: https://msdn.microsoft.com/en-us/library/windows/desktop/bb773321(v=vs.85).aspx*/
+
+typedef struct _ITEMIDLIST {
+  SHITEMID mkid;
+} ITEMIDLIST, *PCIDLIST_ABSOLUTE, *PIDLIST_ABSOLUTE;

ctypes_generation/definitions/structures/template.py

@@ -0,0 +1,36 @@
+from ctypes import *
+from ctypes.wintypes import *
+
+from flag import Flag, FlagMapper
+
+class EnumValue(Flag):
+    def __new__(cls, enum_name, name, value):
+        return super(EnumValue, cls).__new__(cls, name, value)
+
+    def __init__(self, enum_name, name, value):
+        self.enum_name = enum_name
+        self.name = name
+
+    def __repr__(self):
+        return "{0}.{1}({2})".format(self.enum_name, self.name, hex(self))
+
+    # Fix pickling with protocol 2
+    def __getnewargs__(self, *args):
+        return self.enum_name, self.name, int(self)
+
+
+class EnumType(DWORD):
+    values = ()
+    mapper = {}
+
+    @property
+    def value(self):
+        raw_value = super(EnumType, self).value
+        return self.mapper.get(raw_value, raw_value)
+
+    def __repr__(self):
+        raw_value = super(EnumType, self).value
+        if raw_value in self.values:
+            value = self.value
+            return "<{0} {1}({2})>".format(type(self).__name__, value.name, hex(raw_value))
+        return "<{0}({1})>".format(type(self).__name__, hex(self.value))

ctypes_generation/definitions/structures/window.txt

@@ -0,0 +1,96 @@
+typedef struct tagRGBTRIPLE {
+        BYTE    rgbtBlue;
+        BYTE    rgbtGreen;
+        BYTE    rgbtRed;
+} RGBTRIPLE, *PRGBTRIPLE, *NPRGBTRIPLE, *LPRGBTRIPLE;
+
+PRAGMA_PACK 2
+typedef struct tagBITMAPFILEHEADER {
+        WORD    bfType;
+        DWORD   bfSize;
+        WORD    bfReserved1;
+        WORD    bfReserved2;
+        DWORD   bfOffBits;
+} BITMAPFILEHEADER, *LPBITMAPFILEHEADER, *PBITMAPFILEHEADER;
+PRAGMA_NOPACK
+
+typedef struct tagBITMAPCOREHEADER {
+        DWORD   bcSize;
+        WORD    bcWidth;
+        WORD    bcHeight;
+        WORD    bcPlanes;
+        WORD    bcBitCount;
+} BITMAPCOREHEADER, *LPBITMAPCOREHEADER, *PBITMAPCOREHEADER;
+
+
+typedef struct tagBITMAP
+{
+    LONG        bmType;
+    LONG        bmWidth;
+    LONG        bmHeight;
+    LONG        bmWidthBytes;
+    WORD        bmPlanes;
+    WORD        bmBitsPixel;
+    LPVOID      bmBits;
+} BITMAP, *PBITMAP, *NPBITMAP, *LPBITMAP;
+
+typedef struct tagBITMAPINFOHEADER{
+        DWORD      biSize;
+        LONG       biWidth;
+        LONG       biHeight;
+        WORD       biPlanes;
+        WORD       biBitCount;
+        DWORD      biCompression;
+        DWORD      biSizeImage;
+        LONG       biXPelsPerMeter;
+        LONG       biYPelsPerMeter;
+        DWORD      biClrUsed;
+        DWORD      biClrImportant;
+} BITMAPINFOHEADER, *LPBITMAPINFOHEADER, *PBITMAPINFOHEADER;
+
+typedef struct tagRGBQUAD {
+        BYTE    rgbBlue;
+        BYTE    rgbGreen;
+        BYTE    rgbRed;
+        BYTE    rgbReserved;
+} RGBQUAD;
+
+typedef struct tagBITMAPINFO {
+    BITMAPINFOHEADER    bmiHeader;
+    RGBQUAD             bmiColors[1];
+} BITMAPINFO, *LPBITMAPINFO, *PBITMAPINFO;
+
+typedef struct tagBITMAPCOREINFO {
+    BITMAPCOREHEADER    bmciHeader;
+    RGBTRIPLE           bmciColors[1];
+} BITMAPCOREINFO, *LPBITMAPCOREINFO, *PBITMAPCOREINFO;
+
+typedef struct tagWNDCLASSEXA {
+  UINT      cbSize;
+  UINT      style;
+  WNDPROC   lpfnWndProc;
+  INT       cbClsExtra;
+  INT       cbWndExtra;
+  HINSTANCE hInstance;
+  HICON     hIcon;
+  HCURSOR   hCursor;
+  HBRUSH    hbrBackground;
+  LPCSTR   lpszMenuName;
+  LPCSTR   lpszClassName;
+  HICON     hIconSm;
+} WNDCLASSEXA, *PWNDCLASSEXA, *LPWNDCLASSEXA;
+
+typedef struct tagWNDCLASSEXW {
+  UINT      cbSize;
+  UINT      style;
+  WNDPROC   lpfnWndProc;
+  INT       cbClsExtra;
+  INT       cbWndExtra;
+  HINSTANCE hInstance;
+  HICON     hIcon;
+  HCURSOR   hCursor;
+  HBRUSH    hbrBackground;
+  LPWSTR   lpszMenuName;
+  LPWSTR   lpszClassName;
+  HICON     hIconSm;
+} WNDCLASSEXW, *PWNDCLASSEXW, *LPWNDCLASSEXW;

ctypes_generation/definitions/structures/winstruct_alpc.txt

@@ -0,0 +1,276 @@
+
+typedef enum _ALPC_PORT_INFORMATION_CLASS
+{
+    AlpcBasicInformation,
+    AlpcPortInformation,
+    AlpcAssociateCompletionPortInformation,
+    AlpcConnectedSIDInformation,
+    AlpcServerInformation,
+    AlpcMessageZoneInformation,
+    AlpcRegisterCompletionListInformation,
+    AlpcUnregisterCompletionListInformation,
+    AlpcAdjustCompletionListConcurrencyCountInformation,
+    AlpcRegisterCallbackInformation,
+    AlpcCompletionListRundownInformation,
+    AlpcWaitForPortReferences,
+    MaxAlpcPortInfoClass
+} ALPC_PORT_INFORMATION_CLASS;
+
+typedef enum _ALPC_MESSAGE_INFORMATION_CLASS
+{
+    AlpcMessageSidInformation,
+    AlpcMessageTokenModifiedIdInformation,
+    MaxAlpcMessageInfoClass,
+    AlpcMessageHandleInformation,
+} ALPC_MESSAGE_INFORMATION_CLASS, *PALPC_MESSAGE_INFORMATION_CLASS;
+
+typedef struct _ALPC_PORT_ATTRIBUTES32
+{
+    ULONG Flags;
+    SECURITY_QUALITY_OF_SERVICE SecurityQos;
+    SIZE_T MaxMessageLength;
+    SIZE_T MemoryBandwidth;
+    SIZE_T MaxPoolUsage;
+    SIZE_T MaxSectionSize;
+    SIZE_T MaxViewSize;
+    SIZE_T MaxTotalSectionSize;
+    ULONG DupObjectTypes;
+} ALPC_PORT_ATTRIBUTES32, *PALPC_PORT_ATTRIBUTES32;
+
+
+typedef struct _ALPC_PORT_ATTRIBUTES64
+{
+    ULONG Flags;
+    SECURITY_QUALITY_OF_SERVICE SecurityQos;
+    SIZE_T MaxMessageLength;
+    SIZE_T MemoryBandwidth;
+    SIZE_T MaxPoolUsage;
+    SIZE_T MaxSectionSize;
+    SIZE_T MaxViewSize;
+    SIZE_T MaxTotalSectionSize;
+    ULONG DupObjectTypes;
+    ULONG Reserved;
+} ALPC_PORT_ATTRIBUTES64, *PALPC_PORT_ATTRIBUTES64;
+
+typedef struct _ALPC_MESSAGE_ATTRIBUTES
+{
+    ULONG AllocatedAttributes;
+    ULONG ValidAttributes;
+} ALPC_MESSAGE_ATTRIBUTES, *PALPC_MESSAGE_ATTRIBUTES;
+
+
+typedef union _PORT_MESSAGE32_TMP_UNION
+{
+        ULONG ClientViewSize;
+        ULONG CallbackId;
+} PORT_MESSAGE_TMP_UNION;
+
+typedef union _PORT_MESSAGE64_TMP_UNION
+{
+        ULONGLONG ClientViewSize;
+        ULONG CallbackId;
+} PORT_MESSAGE_TMP_UNION;
+
+
+typedef struct _PORT_MESSAGE_TMP_SUBSTRUCT_S1
+{
+    CSHORT DataLength;
+    CSHORT TotalLength;
+} _PORT_MESSAGE_TMP_SUBSTRUCT_S1;
+
+
+typedef union _PORT_MESSAGE_TMP_UNION_U1
+{
+    ULONG Length;
+    _PORT_MESSAGE_TMP_SUBSTRUCT_S1 s1;
+} _PORT_MESSAGE_TMP_UNION_U1;
+
+
+typedef struct _PORT_MESSAGE_TMP_SUBSTRUCT_S2
+{
+    CSHORT Type;
+    CSHORT DataInfoOffset;
+} _PORT_MESSAGE_TMP_SUBSTRUCT_S2;
+
+
+typedef union _PORT_MESSAGE_TMP_UNION_U2
+{
+        ULONG ZeroInit;
+        _PORT_MESSAGE_TMP_SUBSTRUCT_S2 s2;
+} _PORT_MESSAGE_TMP_UNION_U2;
+
+
+typedef struct _PORT_MESSAGE32
+{
+    _PORT_MESSAGE_TMP_UNION_U1 u1;
+    _PORT_MESSAGE_TMP_UNION_U2 u2;
+    CLIENT_ID32 ClientId;
+    ULONG MessageId;
+    _PORT_MESSAGE32_TMP_UNION tmp_union;
+} PORT_MESSAGE32, *PPORT_MESSAGE32;
+
+typedef struct _PORT_MESSAGE64
+{
+    _PORT_MESSAGE_TMP_UNION_U1 u1;
+    _PORT_MESSAGE_TMP_UNION_U2 u2;
+    CLIENT_ID64 ClientId;
+    ULONG MessageId;
+    _PORT_MESSAGE64_TMP_UNION tmp_union;
+} PORT_MESSAGE64, *PPORT_MESSAGE64;
+
+
+typedef struct _ALPC_SERVER_INFORMATION_TMP_IN
+{
+    HANDLE ThreadHandle;
+} ALPC_SERVER_INFORMATION_TMP_IN;
+
+typedef struct _ALPC_SERVER_INFORMATION_TMP_OUT
+{
+    BOOLEAN ThreadBlocked;
+    HANDLE ConnectedProcessId;
+    UNICODE_STRING ConnectionPortName;
+} ALPC_SERVER_INFORMATION_TMP_OUT;
+
+typedef union ALPC_SERVER_INFORMATION
+{
+    ALPC_SERVER_INFORMATION_TMP_IN In;
+    ALPC_SERVER_INFORMATION_TMP_OUT Out;
+} ALPC_SERVER_INFORMATION;
+
+
+typedef struct _ALPC_CONTEXT_ATTR
+{
+    PVOID PortContext;
+    PVOID MessageContext;
+    ULONG Sequence;
+    ULONG MessageId;
+    ULONG CallbackId;
+} ALPC_CONTEXT_ATTR, *PALPC_CONTEXT_ATTR;
+
+typedef struct _ALPC_CONTEXT_ATTR32
+{
+    ULONG PortContext;
+    ULONG MessageContext;
+    ULONG Sequence;
+    ULONG MessageId;
+    ULONG CallbackId;
+} ALPC_CONTEXT_ATTR32, *PALPC_CONTEXT_ATTR32;
+
+typedef struct _ALPC_CONTEXT_ATTR64
+{
+    ULONGLONG PortContext;
+    ULONGLONG MessageContext;
+    ULONG Sequence;
+    ULONG MessageId;
+    ULONG CallbackId;
+} ALPC_CONTEXT_ATTR64, *PALPC_CONTEXT_ATTR64;
+
+
+typedef struct _ALPC_HANDLE_ATTR
+{
+    ULONG Flags;
+    HANDLE Handle;
+    ULONG ObjectType;
+    ACCESS_MASK DesiredAccess;
+} ALPC_HANDLE_ATTR, *PALPC_HANDLE_ATTR;
+
+typedef struct _ALPC_HANDLE_ATTR32
+{
+    ULONG Flags;
+    ULONG Handle;
+    ULONG ObjectType;
+    ACCESS_MASK DesiredAccess;
+} ALPC_HANDLE_ATTR32, *PALPC_HANDLE_ATTR32;
+
+
+typedef struct _ALPC_HANDLE_ATTR64
+{
+    ULONG Flags;
+    ULONGLONG Handle;
+    ULONG ObjectType;
+    ACCESS_MASK DesiredAccess;
+} ALPC_HANDLE_ATTR64, *PALPC_HANDLE_ATTR64;
+
+
+typedef struct _ALPC_SECURITY_ATTR
+{
+    ULONG Flags;
+    PSECURITY_QUALITY_OF_SERVICE QoS;
+    ALPC_HANDLE ContextHandle;
+} ALPC_SECURITY_ATTR, *PALPC_SECURITY_ATTR;
+
+typedef struct _ALPC_SECURITY_ATTR32
+{
+    ULONG Flags;
+    ULONG QoS;
+    ULONG ContextHandle;
+} ALPC_SECURITY_ATTR32, *PALPC_SECURITY_ATTR32;
+
+
+typedef struct _ALPC_SECURITY_ATTR64
+{
+    ULONGLONG Flags;
+    ULONGLONG QoS;
+    ULONGLONG ContextHandle;
+} ALPC_SECURITY_ATTR64, *PALPC_SECURITY_ATTR64;
+
+typedef struct _ALPC_DATA_VIEW_ATTR
+{
+    ULONG Flags;
+    ALPC_HANDLE SectionHandle;
+    PVOID ViewBase;
+    PVOID ViewSize;
+} ALPC_DATA_VIEW_ATTR, *PALPC_DATA_VIEW_ATTR;
+
+typedef struct _ALPC_DATA_VIEW_ATTR32
+{
+    ULONG Flags;
+    ULONG SectionHandle;
+    ULONG ViewBase;
+    ULONG ViewSize;
+} ALPC_DATA_VIEW_ATTR32, *PALPC_DATA_VIEW_ATTR32;
+
+
+typedef struct _ALPC_DATA_VIEW_ATTR64
+{
+    ULONG Flags;
+    ULONGLONG SectionHandle;
+    ULONGLONG ViewBase;
+    ULONGLONG ViewSize;
+} ALPC_DATA_VIEW_ATTR64, *PALPC_DATA_VIEW_ATTR64;
+
+
+typedef struct _ALPC_TOKEN_ATTR
+{
+    ULONGLONG TokenId;
+    ULONGLONG AuthenticationId;
+    ULONGLONG ModifiedId;
+} ALPC_TOKEN_ATTR, *PALPC_TOKEN_ATTR;
+
+
+typedef struct _ALPC_DIRECT_ATTR
+{
+    HANDLE Event;
+} ALPC_DIRECT_ATTR, *PALPC_DIRECT_ATTR;
+
+typedef struct _ALPC_DIRECT_ATTR32
+{
+    ULONG Event;
+} ALPC_DIRECT_ATTR32, *PALPC_DIRECT_ATTR32;
+
+typedef struct _ALPC_DIRECT_ATTR64
+{
+    ULONGLONG Event;
+} ALPC_DIRECT_ATTR64, *PALPC_DIRECT_ATTR64;
+
+
+typedef struct _ALPC_WORK_ON_BEHALF_ATTR
+{
+    ULONGLONG Ticket;
+} ALPC_WORK_ON_BEHALF_ATTR, *PALPC_WORK_ON_BEHALF_ATTR;
+
+typedef struct _RPC_IF_ID {
+  IID           Uuid;
+  USHORT VersMajor;
+  USHORT VersMinor;
+} RPC_IF_ID;

ctypes_generation/definitions/structures/winstruct_apisetmap.txt

@@ -0,0 +1,108 @@
+// API SET MAP Stuff
+// From apiset.h
+
+
+// Used in V6
+typedef struct _API_SET_VALUE_ENTRY {
+    ULONG Flags;
+    ULONG NameOffset;
+    ULONG NameLength;
+    ULONG ValueOffset;
+    ULONG ValueLength;
+} API_SET_VALUE_ENTRY, *PAPI_SET_VALUE_ENTRY;
+
+typedef struct _API_SET_NAMESPACE_ENTRY {
+    ULONG Flags;
+    ULONG NameOffset;
+    ULONG NameLength;
+    ULONG AliasOffset;
+    ULONG AliasLength;
+    ULONG DataOffset;   // API_SET_VALUE_ARRAY
+} API_SET_NAMESPACE_ENTRY, *PAPI_SET_NAMESPACE_ENTRY;
+
+
+typedef struct _API_SET_NAMESPACE_ARRAY {
+    ULONG Version;
+    ULONG Size;
+    ULONG Flags;
+    ULONG Count;
+    API_SET_NAMESPACE_ENTRY Array[ANYSIZE_ARRAY];
+} API_SET_NAMESPACE_ARRAY, *PAPI_SET_NAMESPACE_ARRAY;
+
+
+// Version 2
+
+typedef struct _API_SET_VALUE_ENTRY_V2 {
+    ULONG NameOffset;
+    ULONG NameLength;
+    ULONG ValueOffset;
+    ULONG ValueLength;
+} API_SET_VALUE_ENTRY_V2, *PAPI_SET_VALUE_ENTRY_V2;
+
+typedef struct _API_SET_VALUE_ARRAY_V2 {
+    ULONG Count;
+    API_SET_VALUE_ENTRY_V2 Array[ANYSIZE_ARRAY];
+} API_SET_VALUE_ARRAY_V2,*PAPI_SET_VALUE_ARRAY_V2;
+
+typedef struct _API_SET_NAMESPACE_ENTRY_V2 {
+    ULONG NameOffset;
+    ULONG NameLength;
+    ULONG DataOffset;   // _API_SET_VALUE_ARRAY_V2
+} API_SET_NAMESPACE_ENTRY_V2, *PAPI_SET_NAMESPACE_ENTRY_V2;
+
+typedef struct _API_SET_NAMESPACE_ARRAY_V2 {
+    ULONG Version;
+    ULONG Count;
+    API_SET_NAMESPACE_ENTRY_V2 Array[ANYSIZE_ARRAY];
+} API_SET_NAMESPACE_ARRAY_V2, *PAPI_SET_NAMESPACE_ARRAY_V2;
+
+// Version 4
+
+typedef struct _API_SET_VALUE_ARRAY_V4 {
+    ULONG GuessFlags;
+    ULONG Count;
+    API_SET_VALUE_ENTRY_V2 Array[ANYSIZE_ARRAY];
+} API_SET_VALUE_ARRAY_V4,*PAPI_SET_VALUE_ARRAY_V2;
+
+typedef struct _API_SET_NAMESPACE_ARRAY_V4 {
+    ULONG Version;
+    ULONG Size;
+    ULONG Flags;
+    ULONG Count;
+    API_SET_NAMESPACE_ENTRY Array[ANYSIZE_ARRAY];
+} API_SET_NAMESPACE_ARRAY_V4, *PAPI_SET_NAMESPACE_ARRAY_V4;
+
+typedef struct _API_SET_NAMESPACE_ENTRY_V4 {
+    ULONG Flags;
+    ULONG NameOffset;
+    ULONG NameLength;
+    ULONG AliasOffset;
+    ULONG AliasLength;
+    ULONG DataOffset;
+} API_SET_NAMESPACE_ENTRY_V4, *PAPI_SET_NAMESPACE_ENTRY_V4;
+
+
+
+// Version 6
+
+typedef struct _API_SET_NAMESPACE_ENTRY_V6 {
+	ULONG Flags;
+	ULONG NameOffset;
+	ULONG NameLength;
+	ULONG HashedLength;
+	ULONG ValueOffset;
+	ULONG ValueCount;
+} API_SET_NAMESPACE_ENTRY_V6;
+
+
+typedef struct _API_SET_NAMESPACE_V6 {
+	ULONG Version;
+	ULONG Size;
+	ULONG Flags;
+	ULONG Count;
+	ULONG EntryOffset;
+	ULONG HashOffset;
+	ULONG HashFactor;
+} API_SET_NAMESPACE_V6;
+
+// STOP API-SET-MAP

ctypes_generation/definitions/structures/winstruct_bits.txt

@@ -0,0 +1,71 @@
+typedef enum  _BG_JOB_STATE{
+  BG_JOB_STATE_QUEUED,
+  BG_JOB_STATE_CONNECTING,
+  BG_JOB_STATE_TRANSFERRING,
+  BG_JOB_STATE_SUSPENDED,
+  BG_JOB_STATE_ERROR,
+  BG_JOB_STATE_TRANSIENT_ERROR,
+  BG_JOB_STATE_TRANSFERRED,
+  BG_JOB_STATE_ACKNOWLEDGED,
+  BG_JOB_STATE_CANCELLED
+} BG_JOB_STATE;
+
+
+typedef enum  _BG_JOB_PROXY_USAGE{
+  BG_JOB_PROXY_USAGE_PRECONFIG,
+  BG_JOB_PROXY_USAGE_NO_PROXY,
+  BG_JOB_PROXY_USAGE_OVERRIDE,
+  BG_JOB_PROXY_USAGE_AUTODETECT
+} BG_JOB_PROXY_USAGE;
+
+
+typedef enum  _BG_JOB_PRIORITY{
+  BG_JOB_PRIORITY_FOREGROUND,
+  BG_JOB_PRIORITY_HIGH,
+  BG_JOB_PRIORITY_NORMAL,
+  BG_JOB_PRIORITY_LOW
+} BG_JOB_PRIORITY;
+
+typedef enum  _BG_ERROR_CONTEXT{
+  BG_ERROR_CONTEXT_NONE                        = 0,
+  BG_ERROR_CONTEXT_UNKNOWN                     = 1,
+  BG_ERROR_CONTEXT_GENERAL_QUEUE_MANAGER       = 2,
+  BG_ERROR_CONTEXT_QUEUE_MANAGER_NOTIFICATION  = 3,
+  BG_ERROR_CONTEXT_LOCAL_FILE                  = 4,
+  BG_ERROR_CONTEXT_REMOTE_FILE                 = 5,
+  BG_ERROR_CONTEXT_GENERAL_TRANSPORT           = 6,
+  BG_ERROR_CONTEXT_REMOTE_APPLICATION          = 7
+} BG_ERROR_CONTEXT;
+
+typedef enum  _BG_JOB_TYPE{
+  BG_JOB_TYPE_DOWNLOAD,
+  BG_JOB_TYPE_UPLOAD,
+  BG_JOB_TYPE_UPLOAD_REPLY
+} BG_JOB_TYPE;
+
+typedef struct _BG_FILE_PROGRESS {
+  UINT64 BytesTotal;
+  UINT64 BytesTransferred;
+  BOOL   Completed;
+} BG_FILE_PROGRESS;
+
+
+typedef struct _BG_JOB_PROGRESS {
+  UINT64 BytesTotal;
+  UINT64 BytesTransferred;
+  ULONG  FilesTotal;
+  ULONG  FilesTransferred;
+} BG_JOB_PROGRESS;
+
+
+typedef struct _BG_FILE_INFO {
+  LPWSTR RemoteName;
+  LPWSTR LocalName;
+} BG_FILE_INFO;
+
+
+typedef struct _BG_JOB_TIMES {
+  FILETIME CreationTime;
+  FILETIME ModificationTime;
+  FILETIME TransferCompletionTime;
+} BG_JOB_TIMES;

ctypes_generation/definitions/structures/winstruct_evtlog.txt

@@ -0,0 +1,267 @@
+typedef struct _EVENTLOGRECORD {
+  DWORD Length;
+  DWORD Reserved;
+  DWORD RecordNumber;
+  DWORD TimeGenerated;
+  DWORD TimeWritten;
+  DWORD EventID;
+  WORD  EventType;
+  WORD  NumStrings;
+  WORD  EventCategory;
+  WORD  ReservedFlags;
+  DWORD ClosingRecordNumber;
+  DWORD StringOffset;
+  DWORD UserSidLength;
+  DWORD UserSidOffset;
+  DWORD DataLength;
+  DWORD DataOffset;
+} EVENTLOGRECORD, *PEVENTLOGRECORD;
+
+typedef struct _EVENTLOG_FULL_INFORMATION {
+  DWORD dwFull;
+} EVENTLOG_FULL_INFORMATION, *LPEVENTLOG_FULL_INFORMATION;
+
+
+typedef enum _EVT_VARIANT_TYPE {
+  EvtVarTypeNull        = 0,
+  EvtVarTypeString      = 1,
+  EvtVarTypeAnsiString  = 2,
+  EvtVarTypeSByte       = 3,
+  EvtVarTypeByte        = 4,
+  EvtVarTypeInt16       = 5,
+  EvtVarTypeUInt16      = 6,
+  EvtVarTypeInt32       = 7,
+  EvtVarTypeUInt32      = 8,
+  EvtVarTypeInt64       = 9,
+  EvtVarTypeUInt64      = 10,
+  EvtVarTypeSingle      = 11,
+  EvtVarTypeDouble      = 12,
+  EvtVarTypeBoolean     = 13,
+  EvtVarTypeBinary      = 14,
+  EvtVarTypeGuid        = 15,
+  EvtVarTypeSizeT       = 16,
+  EvtVarTypeFileTime    = 17,
+  EvtVarTypeSysTime     = 18,
+  EvtVarTypeSid         = 19,
+  EvtVarTypeHexInt32    = 20,
+  EvtVarTypeHexInt64    = 21,
+  EvtVarTypeEvtHandle   = 32,
+  EvtVarTypeEvtXml      = 35
+} EVT_VARIANT_TYPE;
+
+
+
+
+union _ANON_evt_variant_sub_union {
+    BOOL       BooleanVal;
+    INT8       SByteVal;
+    INT16      Int16Val;
+    INT32      Int32Val;
+    INT64      Int64Val;
+    UINT8      ByteVal;
+    UINT16     UInt16Val;
+    UINT32     UInt32Val;
+    UINT64     UInt64Val;
+    FLOAT      SingleVal;
+    DOUBLE     DoubleVal;
+    ULONGLONG  FileTimeVal;
+    SYSTEMTIME *SysTimeVal;
+    GUID       *GuidVal;
+    LPCWSTR    StringVal;
+    LPCSTR     AnsiStringVal;
+    PBYTE      BinaryVal;
+    PSID       SidVal;
+    SIZE_T     SizeTVal;
+    EVT_HANDLE EvtHandleVal;
+    BOOL       *BooleanArr;
+    INT8       *SByteArr;
+    INT16      *Int16Arr;
+    INT32      *Int32Arr;
+    INT64      *Int64Arr;
+    UINT8      *ByteArr;
+    UINT16     *UInt16Arr;
+    UINT32     *UInt32Arr;
+    UINT64     *UInt64Arr;
+    FLOAT      *SingleArr;
+    DOUBLE     *DoubleArr;
+    FILETIME   *FileTimeArr;
+    SYSTEMTIME *SysTimeArr;
+    GUID       *GuidArr;
+    LPWSTR     *StringArr;
+    LPSTR      *AnsiStringArr;
+    PSID       *SidArr;
+    SIZE_T     *SizeTArr;
+    LPCWSTR    XmlVal;
+    LPCWSTR*   XmlValArr;
+  };
+
+typedef struct _EVT_VARIANT {
+  _ANON_evt_variant_sub_union _VARIANT_VALUE;
+  DWORD Count;
+  DWORD Type;
+} EVT_VARIANT, *PEVT_VARIANT;
+
+
+typedef enum _EVT_RENDER_CONTEXT_FLAGS {
+  EvtRenderContextValues  = 0,
+  EvtRenderContextSystem  = 1,
+  EvtRenderContextUser    = 2
+} EVT_RENDER_CONTEXT_FLAGS;
+
+
+typedef enum  _EVT_SYSTEM_PROPERTY_ID {
+  EvtSystemProviderName,
+  EvtSystemProviderGuid,
+  EvtSystemEventID,
+  EvtSystemQualifiers,
+  EvtSystemLevel,
+  EvtSystemTask,
+  EvtSystemOpcode,
+  EvtSystemKeywords,
+  EvtSystemTimeCreated,
+  EvtSystemEventRecordId,
+  EvtSystemActivityID,
+  EvtSystemRelatedActivityID,
+  EvtSystemProcessID,
+  EvtSystemThreadID,
+  EvtSystemChannel,
+  EvtSystemComputer,
+  EvtSystemUserID,
+  EvtSystemVersion,
+  EvtSystemPropertyIdEND
+} EVT_SYSTEM_PROPERTY_ID;
+
+
+typedef enum _EVT_RENDER_FLAGS {
+  EvtRenderEventValues  = 0,
+  EvtRenderEventXml     = 1,
+  EvtRenderBookmark     = 2
+} EVT_RENDER_FLAGS;
+
+
+typedef enum _EVT_QUERY_FLAGS {
+  EvtQueryChannelPath          = 0x1,
+  EvtQueryFilePath             = 0x2,
+  EvtQueryForwardDirection     = 0x100,
+  EvtQueryReverseDirection     = 0x200,
+  EvtQueryTolerateQueryErrors  = 0x1000
+} EVT_QUERY_FLAGS;
+
+
+typedef enum _EVT_LOG_PROPERTY_ID {
+  EvtLogCreationTime        = 0,
+  EvtLogLastAccessTime      = 1,
+  EvtLogLastWriteTime       = 2,
+  EvtLogFileSize            = 3,
+  EvtLogAttributes          = 4,
+  EvtLogNumberOfLogRecords  = 5,
+  EvtLogOldestRecordNumber  = 6,
+  EvtLogFull                = 7
+} EVT_LOG_PROPERTY_ID;
+
+typedef enum _EVT_OPEN_LOG_FLAGS {
+  EvtOpenChannelPath  = 0x1,
+  EvtOpenFilePath     = 0x2
+} EVT_OPEN_LOG_FLAGS;
+
+
+typedef enum _EVT_CHANNEL_CONFIG_PROPERTY_ID {
+  EvtChannelConfigEnabled                = 0,
+  EvtChannelConfigIsolation              = 1,
+  EvtChannelConfigType                   = 2,
+  EvtChannelConfigOwningPublisher        = 3,
+  EvtChannelConfigClassicEventlog        = 4,
+  EvtChannelConfigAccess                 = 5,
+  EvtChannelLoggingConfigRetention       = 6,
+  EvtChannelLoggingConfigAutoBackup      = 7,
+  EvtChannelLoggingConfigMaxSize         = 8,
+  EvtChannelLoggingConfigLogFilePath     = 9,
+  EvtChannelPublishingConfigLevel        = 10,
+  EvtChannelPublishingConfigKeywords     = 11,
+  EvtChannelPublishingConfigControlGuid  = 12,
+  EvtChannelPublishingConfigBufferSize   = 13,
+  EvtChannelPublishingConfigMinBuffers   = 14,
+  EvtChannelPublishingConfigMaxBuffers   = 15,
+  EvtChannelPublishingConfigLatency      = 16,
+  EvtChannelPublishingConfigClockType    = 17,
+  EvtChannelPublishingConfigSidType      = 18,
+  EvtChannelPublisherList                = 19,
+  EvtChannelPublishingConfigFileMax      = 20,
+  EvtChannelConfigPropertyIdEND          = 21
+} EVT_CHANNEL_CONFIG_PROPERTY_ID;
+
+
+typedef enum  _EVT_CHANNEL_TYPE{
+  EvtChannelTypeAdmin        = 0,
+  EvtChannelTypeOperational  = 1,
+  EvtChannelTypeAnalytic     = 2,
+  EvtChannelTypeDebug        = 3
+} EVT_CHANNEL_TYPE;
+
+typedef enum  _EVT_CHANNEL_ISOLATION_TYPE{
+  EvtChannelIsolationTypeApplication  = 0,
+  EvtChannelIsolationTypeSystem       = 1,
+  EvtChannelIsolationTypeCustom       = 2
+} EVT_CHANNEL_ISOLATION_TYPE;
+
+
+typedef enum _EVT_EVENT_METADATA_PROPERTY_ID {
+  EventMetadataEventID           = 0,
+  EventMetadataEventVersion      = 1,
+  EventMetadataEventChannel      = 2,
+  EventMetadataEventLevel        = 3,
+  EventMetadataEventOpcode       = 4,
+  EventMetadataEventTask         = 5,
+  EventMetadataEventKeyword      = 6,
+  EventMetadataEventMessageID    = 7,
+  EventMetadataEventTemplate     = 8,
+  EvtEventMetadataPropertyIdEND  = 9
+} EVT_EVENT_METADATA_PROPERTY_ID;
+
+
+typedef enum _EVT_PUBLISHER_METADATA_PROPERTY_ID {
+  EvtPublisherMetadataPublisherGuid,
+  EvtPublisherMetadataResourceFilePath,
+  EvtPublisherMetadataParameterFilePath,
+  EvtPublisherMetadataMessageFilePath,
+  EvtPublisherMetadataHelpLink,
+  EvtPublisherMetadataPublisherMessageID,
+  EvtPublisherMetadataChannelReferences,
+  EvtPublisherMetadataChannelReferencePath,
+  EvtPublisherMetadataChannelReferenceIndex,
+  EvtPublisherMetadataChannelReferenceID,
+  EvtPublisherMetadataChannelReferenceFlags,
+  EvtPublisherMetadataChannelReferenceMessageID,
+  EvtPublisherMetadataLevels,
+  EvtPublisherMetadataLevelName,
+  EvtPublisherMetadataLevelValue,
+  EvtPublisherMetadataLevelMessageID,
+  EvtPublisherMetadataTasks,
+  EvtPublisherMetadataTaskName,
+  EvtPublisherMetadataTaskEventGuid,
+  EvtPublisherMetadataTaskValue,
+  EvtPublisherMetadataTaskMessageID,
+  EvtPublisherMetadataOpcodes,
+  EvtPublisherMetadataOpcodeName,
+  EvtPublisherMetadataOpcodeValue,
+  EvtPublisherMetadataOpcodeMessageID,
+  EvtPublisherMetadataKeywords,
+  EvtPublisherMetadataKeywordName,
+  EvtPublisherMetadataKeywordValue,
+  EvtPublisherMetadataKeywordMessageID,
+  EvtPublisherMetadataPropertyIdEND
+} EVT_PUBLISHER_METADATA_PROPERTY_ID;
+
+
+typedef enum _EVT_FORMAT_MESSAGE_FLAGS {
+  EvtFormatMessageEvent     = 1,
+  EvtFormatMessageLevel     = 2,
+  EvtFormatMessageTask      = 3,
+  EvtFormatMessageOpcode    = 4,
+  EvtFormatMessageKeyword   = 5,
+  EvtFormatMessageChannel   = 6,
+  EvtFormatMessageProvider  = 7,
+  EvtFormatMessageId        = 8,
+  EvtFormatMessageXml       = 9
+} EVT_FORMAT_MESSAGE_FLAGS;
+

ctypes_generation/definitions/structures/winstruct_file_info.txt

@@ -0,0 +1,166 @@
+typedef enum _FILE_INFORMATION_CLASS {
+  FakeFileInformationZero,
+  FileDirectoryInformation,
+  FileFullDirectoryInformation,
+  FileBothDirectoryInformation,
+  FileBasicInformation,
+  FileStandardInformation,
+  FileInternalInformation,
+  FileEaInformation,
+  FileAccessInformation,
+  FileNameInformation,
+  FileRenameInformation,
+  FileLinkInformation,
+  FileNamesInformation,
+  FileDispositionInformation,
+  FilePositionInformation,
+  FileFullEaInformation,
+  FileModeInformation,
+  FileAlignmentInformation,
+  FileAllInformation,
+  FileAllocationInformation,
+  FileEndOfFileInformation,
+  FileAlternateNameInformation,
+  FileStreamInformation,
+  FilePipeInformation,
+  FilePipeLocalInformation,
+  FilePipeRemoteInformation,
+  FileMailslotQueryInformation,
+  FileMailslotSetInformation,
+  FileCompressionInformation,
+  FileObjectIdInformation,
+  FileCompletionInformation,
+  FileMoveClusterInformation,
+  FileQuotaInformation,
+  FileReparsePointInformation,
+  FileNetworkOpenInformation,
+  FileAttributeTagInformation,
+  FileTrackingInformation,
+  FileIdBothDirectoryInformation,
+  FileIdFullDirectoryInformation,
+  FileValidDataLengthInformation,
+  FileShortNameInformation,
+  FileIoCompletionNotificationInformation,
+  FileIoStatusBlockRangeInformation,
+  FileIoPriorityHintInformation,
+  FileSfioReserveInformation,
+  FileSfioVolumeInformation,
+  FileHardLinkInformation,
+  FileProcessIdsUsingFileInformation,
+  FileNormalizedNameInformation,
+  FileNetworkPhysicalNameInformation,
+  FileIdGlobalTxDirectoryInformation,
+  FileIsRemoteDeviceInformation,
+  FileUnusedInformation,
+  FileNumaNodeInformation,
+  FileStandardLinkInformation,
+  FileRemoteProtocolInformation,
+  FileRenameInformationBypassAccessCheck,
+  FileLinkInformationBypassAccessCheck,
+  FileVolumeNameInformation,
+  FileIdInformation,
+  FileIdExtdDirectoryInformation,
+  FileReplaceCompletionInformation,
+  FileHardLinkFullIdInformation,
+  FileIdExtdBothDirectoryInformation,
+  FileDispositionInformationEx,
+  FileRenameInformationEx,
+  FileRenameInformationExBypassAccessCheck,
+  FileMaximumInformation
+} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
+
+typedef enum _IO_PRIORITY_HINT {
+  IoPriorityVeryLow   = 0,
+  IoPriorityLow       = 1,
+  IoPriorityNormal    = 2,
+  IoPriorityHigh      = 3,
+  IoPriorityCritical  = 4,
+  MaxIoPriorityTypes  = 5
+} IO_PRIORITY_HINT;
+
+
+typedef struct _FILE_INTERNAL_INFORMATION {
+  LARGE_INTEGER IndexNumber;
+} FILE_INTERNAL_INFORMATION, *PFILE_INTERNAL_INFORMATION;
+
+
+typedef struct _FILE_ALIGNMENT_INFORMATION {
+  ULONG AlignmentRequirement;
+} FILE_ALIGNMENT_INFORMATION, *PFILE_ALIGNMENT_INFORMATION;
+
+
+typedef struct _FILE_ATTRIBUTE_TAG_INFORMATION {
+  ULONG FileAttributes;
+  ULONG ReparseTag;
+} FILE_ATTRIBUTE_TAG_INFORMATION, *PFILE_ATTRIBUTE_TAG_INFORMATION;
+
+typedef struct _FILE_BASIC_INFORMATION {
+  LARGE_INTEGER CreationTime;
+  LARGE_INTEGER LastAccessTime;
+  LARGE_INTEGER LastWriteTime;
+  LARGE_INTEGER ChangeTime;
+  ULONG         FileAttributes;
+} FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
+
+typedef struct _FILE_EA_INFORMATION {
+  ULONG EaSize;
+} FILE_EA_INFORMATION, *PFILE_EA_INFORMATION;
+
+typedef struct _FILE_IO_PRIORITY_HINT_INFORMATION {
+  IO_PRIORITY_HINT PriorityHint;
+} FILE_IO_PRIORITY_HINT_INFORMATION, *PFILE_IO_PRIORITY_HINT_INFORMATION;
+
+
+typedef struct _FILE_MODE_INFORMATION {
+  ULONG Mode;
+} FILE_MODE_INFORMATION, *PFILE_MODE_INFORMATION;
+
+typedef struct _FILE_NAME_INFORMATION {
+  ULONG FileNameLength;
+  WCHAR FileName[1];
+} FILE_NAME_INFORMATION, *PFILE_NAME_INFORMATION;
+
+
+typedef struct _FILE_NETWORK_OPEN_INFORMATION {
+  LARGE_INTEGER CreationTime;
+  LARGE_INTEGER LastAccessTime;
+  LARGE_INTEGER LastWriteTime;
+  LARGE_INTEGER ChangeTime;
+  LARGE_INTEGER AllocationSize;
+  LARGE_INTEGER EndOfFile;
+  ULONG         FileAttributes;
+} FILE_NETWORK_OPEN_INFORMATION, *PFILE_NETWORK_OPEN_INFORMATION;
+
+typedef struct _FILE_STANDARD_INFORMATION {
+  LARGE_INTEGER AllocationSize;
+  LARGE_INTEGER EndOfFile;
+  ULONG         NumberOfLinks;
+  BOOLEAN       DeletePending;
+  BOOLEAN       Directory;
+} FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION;
+
+typedef struct _FILE_ACCESS_INFORMATION {
+  ACCESS_MASK AccessFlags;
+} FILE_ACCESS_INFORMATION, *PFILE_ACCESS_INFORMATION;
+
+typedef struct _FILE_POSITION_INFORMATION {
+  LARGE_INTEGER CurrentByteOffset;
+} FILE_POSITION_INFORMATION, *PFILE_POSITION_INFORMATION;
+
+typedef struct _FILE_IS_REMOTE_DEVICE_INFORMATION {
+  BOOLEAN IsRemote;
+} FILE_IS_REMOTE_DEVICE_INFORMATION, *PFILE_IS_REMOTE_DEVICE_INFORMATION;
+
+
+
+typedef struct _FILE_ALL_INFORMATION {
+  FILE_BASIC_INFORMATION     BasicInformation;
+  FILE_STANDARD_INFORMATION  StandardInformation;
+  FILE_INTERNAL_INFORMATION  InternalInformation;
+  FILE_EA_INFORMATION        EaInformation;
+  FILE_ACCESS_INFORMATION    AccessInformation;
+  FILE_POSITION_INFORMATION  PositionInformation;
+  FILE_MODE_INFORMATION      ModeInformation;
+  FILE_ALIGNMENT_INFORMATION AlignmentInformation;
+  FILE_NAME_INFORMATION      NameInformation;
+} FILE_ALL_INFORMATION, *PFILE_ALL_INFORMATION;

ctypes_generation/dummy_wintypes.py

@@ -1 +1 @@
-names = ['ATOM', 'BOOL', 'BOOLEAN', 'BYTE', 'COLORREF', 'DOUBLE', 'DWORD', 'FILETIME', 'FLOAT', 'HACCEL', 'HANDLE', 'HBITMAP', ' HBRUSH', 'HCOLORSPACE', 'HDC', 'HDESK', 'HDWP', 'HENHMETAFILE', 'HFONT', 'HGDIOBJ', 'HGLOBAL', 'HHOOK', 'HICON', 'HINSTA NCE', 'HKEY', 'HKL', 'HLOCAL', 'HMENU', 'HMETAFILE', 'HMODULE', 'HMONITOR', 'HPALETTE', 'HPEN', 'HRGN', 'HRSRC', 'HSTR', 'HTASK', 'HWINSTA', 'HWND', 'INT', 'LANGID', 'LARGE_INTEGER', 'LCID', 'LCTYPE', 'LGRPID', 'LONG', 'LPARAM', 'LPCOLESTR' , 'LPCSTR', 'LPCVOID', 'LPCWSTR', 'LPOLESTR', 'LPSTR', 'LPVOID', 'LPWSTR', 'MAX_PATH', 'MSG', 'OLESTR', 'POINT', 'POINTL ', 'RECT', 'RECTL', 'RGB', 'SC_HANDLE', 'SERVICE_STATUS_HANDLE', 'SHORT', 'SIZE', 'SIZEL', 'SMALL_RECT', 'UINT', 'ULARGE _INTEGER', 'ULONG', 'USHORT', 'VARIANT_BOOL', 'WCHAR', 'WIN32_FIND_DATAA', 'WIN32_FIND_DATAW', 'WORD', 'WPARAM', '_COORD ', '_FILETIME', '_LARGE_INTEGER', '_POINTL', '_RECTL', '_SMALL_RECT', '_ULARGE_INTEGER', 'tagMSG', 'tagPOINT', 'tagRECT' , 'tagSIZE']
+names = ['HINSTANCE', 'HRESULT', 'ATOM', 'BOOL', 'BOOLEAN', 'BYTE', 'COLORREF', 'DOUBLE', 'DWORD', 'FILETIME', 'FLOAT', 'HACCEL', 'HANDLE', 'HBITMAP', ' HBRUSH', 'HCOLORSPACE', 'HDC', 'HDESK', 'HDWP', 'HENHMETAFILE', 'HFONT', 'HGDIOBJ', 'HGLOBAL', 'HHOOK', 'HICON', 'HINSTA NCE', 'HKEY', 'HKL', 'HLOCAL', 'HMENU', 'HMETAFILE', 'HMODULE', 'HMONITOR', 'HPALETTE', 'HPEN', 'HRGN', 'HRSRC', 'HSTR', 'HTASK', 'HWINSTA', 'HWND', 'INT', 'LANGID', 'LARGE_INTEGER', 'LCID', 'LCTYPE', 'LGRPID', 'LONG', 'LPARAM', 'LPCOLESTR' , 'LPCSTR', 'LPCVOID', 'LPCWSTR', 'LPOLESTR', 'LPSTR', 'LPVOID', 'LPWSTR', 'MAX_PATH', 'MSG', 'OLESTR', 'POINT', 'POINTL ', 'RECT', 'RECTL', 'RGB', 'SC_HANDLE', 'SERVICE_STATUS_HANDLE', 'SHORT', 'SIZE', 'SIZEL', 'SMALL_RECT', 'UINT', 'ULARGE _INTEGER', 'ULONG', 'USHORT', 'VARIANT_BOOL', 'WCHAR', 'WIN32_FIND_DATAA', 'WIN32_FIND_DATAW', 'WORD', 'WPARAM', '_COORD ', '_FILETIME', '_LARGE_INTEGER', '_POINTL', '_RECTL', '_SMALL_RECT', '_ULARGE_INTEGER', "ULARGE_INTEGER", 'tagMSG', 'tagPOINT', 'tagRECT' , 'tagSIZE']

ctypes_generation/extended_structs/_CRYPTOAPI_BLOB.py

@@ -0,0 +1,11 @@
+class _CRYPTOAPI_BLOB(_CRYPTOAPI_BLOB):
+    @classmethod
+    def from_string(cls, buf):
+        self = cls()
+        self.cbData = len(buf)
+        self.pbData = (BYTE * self.cbData)(*bytearray(buf))
+        return self
+
+    @property
+    def data(self):
+        return bytearray(self.pbData[:self.cbData])

ctypes_generation/extended_structs/_GUID.py

@@ -0,0 +1,53 @@
+INITIAL_GUID = _GUID
+class _GUID(INITIAL_GUID):
+    def __init__(self, Data1=None, Data2=None, Data3=None, Data4=None, name=None, strid=None):
+        data_tuple = (Data1, Data2, Data3, Data4)
+        self.name = name
+        self.strid = strid
+        if all(data is None for data in data_tuple):
+            return super(_GUID, self).__init__()
+        if any(data is None for data in data_tuple):
+            raise ValueError("All or none of (Data1, Data2, Data3, Data4) should be None")
+        super(_GUID, self).__init__(Data1, Data2, Data3, Data4)
+
+    def __repr__(self):
+        notpresent = object()
+        # Handle IID created without '__init__' (like ctypes-ptr deref)
+        if getattr(self, "strid", notpresent) is notpresent:
+            self.strid = self.to_string()
+        if self.strid is None:
+            return super(_GUID, self).__repr__()
+
+        if getattr(self, "name", notpresent) is notpresent:
+            self.name = None
+        if self.name is None:
+            return '<IID "{0}">'.format(self.strid.upper())
+        return '<IID "{0}({1})">'.format(self.strid.upper(), self.name)
+
+    def to_string(self):
+        data4_format = "{0:02X}{1:02X}-" + "".join("{{{i}:02X}}".format(i=i + 2) for i in range(6))
+        data4_str = data4_format.format(*self.Data4)
+        return "{0:08X}-{1:04X}-{2:04X}-".format(self.Data1, self.Data2, self.Data3) + data4_str
+
+    def update_strid(self):
+       new_strid = self.to_string()
+       self.strid = new_strid
+
+    @classmethod
+    def from_string(cls, iid):
+        part_iid = iid.split("-")
+        datas = [int(x, 16) for x in part_iid[:3]]
+        datas.append(int(part_iid[3][:2], 16))
+        datas.append(int(part_iid[3][2:], 16))
+        for i in range(6):
+            datas.append(int(part_iid[4][i * 2:(i + 1) * 2], 16))
+        return cls.from_raw(*datas, strid=iid)
+
+    @classmethod
+    def from_raw(cls, Data1, Data2, Data3, Data41, Data42, Data43, Data44, Data45, Data46, Data47, Data48, **kwargs):
+        return cls(Data1, Data2, Data3,  (BYTE*8)(Data41, Data42, Data43, Data44, Data45, Data46, Data47, Data48), **kwargs)
+
+    def __eq__(self, other):
+        if not isinstance(other, (_GUID, INITIAL_GUID)):
+            return NotImplemented
+        return (self.Data1, self.Data2, self.Data3, self.Data4[:]) == (other.Data1, other.Data2, other.Data3, other.Data4[:])

ctypes_generation/extended_structs/_LSA_UNICODE_STRING.py

@@ -0,0 +1,24 @@
+INITIAL_LSA_UNICODE_STRING = _LSA_UNICODE_STRING
+
+class _LSA_UNICODE_STRING(INITIAL_LSA_UNICODE_STRING):
+    @property
+    def str(self):
+        """The python string of the LSA_UNICODE_STRING object
+
+        :type: :class:`unicode`
+        """
+        if not self.Length:
+            return ""
+        if getattr(self, "_target", None) is not None: #remote ctypes :D -> TRICKS OF THE YEAR
+            raw_data = self._target.read_memory(self.Buffer, self.Length)
+            return raw_data.decode("utf16")
+        size = self.Length / 2
+        return (ctypes.c_wchar * size).from_address(self.Buffer)[:]
+
+    @classmethod
+    def from_string(cls, s):
+        utf16_len = len(s) * 2
+        return cls(utf16_len, utf16_len, ctypes.cast(PWSTR(s), PVOID))
+
+    def __repr__(self):
+        return """<{0} "{1}" at {2}>""".format(type(self).__name__, self.str, hex(id(self)))

ctypes_generation/extended_structs/_MEMORY_BASIC_INFORMATION32.py

@@ -0,0 +1,31 @@
+INITIAL_MEMORY_BASIC_INFORMATION32 = _MEMORY_BASIC_INFORMATION32
+
+class _MEMORY_BASIC_INFORMATION32(INITIAL_MEMORY_BASIC_INFORMATION32):
+    STATE_MAPPER = FlagMapper(MEM_COMMIT, MEM_FREE, MEM_RESERVE)
+    TYPE_MAPPER = FlagMapper(MEM_IMAGE, MEM_MAPPED, MEM_PRIVATE)
+    PROTECT_MAPPER = FlagMapper(PAGE_NOACCESS, PAGE_READONLY, PAGE_READWRITE,
+                                    PAGE_WRITECOPY, PAGE_EXECUTE, PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE,
+                                    PAGE_EXECUTE_WRITECOPY)
+
+
+    @property
+    def State(self):
+        raw_state = super(_MEMORY_BASIC_INFORMATION32, self).State
+        # Finally make a chooser somewhere ?
+        return self.STATE_MAPPER[raw_state]
+
+    @property
+    def Type(self):
+        raw_type = super(_MEMORY_BASIC_INFORMATION32, self).Type
+        # Finally make a chooser somewhere ?
+        return self.TYPE_MAPPER[raw_type]
+
+    @property
+    def Protect(self):
+        raw_protect = super(_MEMORY_BASIC_INFORMATION32, self).Protect
+        # Finally make a chooser somewhere ?
+        return self.PROTECT_MAPPER[raw_protect]
+
+    def __repr__(self):
+        return "<MEMORY_BASIC_INFORMATION32 BaseAddress={0:#08x} RegionSize={1:#08x} State={2} Type={3} Protect={4}>".format(
+            self.BaseAddress, self.RegionSize, self.State, self.Type, self.Protect)

ctypes_generation/extended_structs/_MEMORY_BASIC_INFORMATION64.py

@@ -0,0 +1,31 @@
+INITIAL_MEMORY_BASIC_INFORMATION64 = _MEMORY_BASIC_INFORMATION64
+
+class _MEMORY_BASIC_INFORMATION64(INITIAL_MEMORY_BASIC_INFORMATION64):
+    STATE_MAPPER = FlagMapper(MEM_COMMIT, MEM_FREE, MEM_RESERVE)
+    TYPE_MAPPER = FlagMapper(MEM_IMAGE, MEM_MAPPED, MEM_PRIVATE)
+    PROTECT_MAPPER = FlagMapper(PAGE_NOACCESS, PAGE_READONLY, PAGE_READWRITE,
+                                    PAGE_WRITECOPY, PAGE_EXECUTE, PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE,
+                                    PAGE_EXECUTE_WRITECOPY)
+
+
+    @property
+    def State(self):
+        raw_state = super(_MEMORY_BASIC_INFORMATION64, self).State
+        # Finally make a chooser somewhere ?
+        return self.STATE_MAPPER[raw_state]
+
+    @property
+    def Type(self):
+        raw_type = super(_MEMORY_BASIC_INFORMATION64, self).Type
+        # Finally make a chooser somewhere ?
+        return self.TYPE_MAPPER[raw_type]
+
+    @property
+    def Protect(self):
+        raw_protect = super(_MEMORY_BASIC_INFORMATION64, self).Protect
+        # Finally make a chooser somewhere ?
+        return self.PROTECT_MAPPER[raw_protect]
+
+    def __repr__(self):
+        return "<MEMORY_BASIC_INFORMATION64 BaseAddress={0:#08x} RegionSize={1:#08x} State={2} Type={3} Protect={4}>".format(
+            self.BaseAddress, self.RegionSize, self.State, self.Type, self.Protect)

ctypes_generation/extended_structs/_RPC_IF_ID.py

@@ -0,0 +1,5 @@
+INITIAL_RPC_IF_ID = RPC_IF_ID
+
+class _RPC_IF_ID(INITIAL_RPC_IF_ID):
+    def __repr__(self):
+        return '<RPC_IF_ID "{0}" ({1}, {2})>'.format(self.Uuid.to_string(), self.VersMajor, self.VersMinor)

ctypes_generation/func_parser.py

@@ -16,19 +16,27 @@ class WinFunc(object):
 
     def generate_ctypes(self):
         return self.generate_comment_ctypes() + "\n" + self.generate_prototype_ctypes() + "\n" + self.generate_paramflags_ctypes() + "\n"
-    
+
     def generate_comment_ctypes(self):
-        model = "# {0}({1}):"
+        model = "#def {0}({1}):\n#    return {0}.ctypes_function({1})"
         ctypes_param = [name for type, name in self.params]
         ctypes_param_str = ", ".join(ctypes_param)
         return model.format(self.name, ctypes_param_str)
-    
+
     def generate_prototype_ctypes(self):
         model = "{0} = WINFUNCTYPE({1})"
-        ctypes_param = [self.return_type] + [type for type, name in self.params]
+        if isinstance(self.return_type, tuple) and self.return_type[0] == "PTR":
+            ctypes_param = ["POINTER({0})".format(self.return_type[1])]
+        else:
+            ctypes_param = [self.return_type]
+        for type, name in self.params:
+            if type.upper() == "POINTER(VOID)":
+                type = "PVOID"
+            ctypes_param.append(type)
+        #ctypes_param = [self.return_type] + [type for type, name in self.params]
         ctypes_param_str = ", ".join(ctypes_param)
         return model.format(self.name + "Prototype", ctypes_param_str)
-        
+
     def generate_paramflags_ctypes(self):
         model =  "{0} = {1}"
         ctypes_paramflags = tuple([(1, name) for type, name in self.params])
@@ -37,14 +45,14 @@ class WinFunc(object):
 
 class WinFuncParser(Parser):
 
-    known_io_info_type = ["__in", "__in_opt", "_In_", "_In_opt_", "_Inout_", "_Out_opt_", "_Out_", "_Reserved_", "_Inout_opt_", "__inout_opt", "__out", "__inout"]
+    known_io_info_type = ["__in", "__in_opt", "_In_", "_In_opt_", "_Inout_", "_Out_opt_", "_Out_", "_Reserved_", "_Inout_opt_", "__inout_opt", "__out", "__inout", "__deref_out"]
 
     def assert_argument_io_info(self):
         io_info = self.assert_token_type(NameToken)
         if io_info.value not in self.known_io_info_type:
             raise ParsingError("Was expection IO_INFO got {0} instead".format(io_info))
         return io_info
-        
+
     def parse_func_arg(self, has_winapi):
         type_ptr = False
         if has_winapi:
@@ -52,23 +60,23 @@ class WinFuncParser(Parser):
         arg_type = self.assert_token_type(NameToken)
         if arg_type.value.upper() == "CONST":
             arg_type = self.assert_token_type(NameToken)
-            
+
         if type(self.peek()) == StarToken:
             type_ptr = True
-            self.assert_token_type(StarToken)  
+            self.assert_token_type(StarToken)
         arg_name = self.assert_token_type(NameToken)
         if not type(self.peek()) == CloseParenthesisToken:
             self.assert_token_type(CommaToken)
         if not type_ptr:
             return (arg_type.value, arg_name.value)
         return ("POINTER({0})".format(arg_type.value), arg_name.value)
-        
+
     def assert_winapi_token(self):
         winapi = self.assert_token_type(NameToken)
         if winapi.value != "WINAPI":
             raise ParsingError("Was expection NameToken(WINAPI) got {0} instead".format(winapi))
-        return winapi    
-        
+        return winapi
+
     def parse_winfunc(self):
         has_winapi = False
         try:
@@ -76,11 +84,15 @@ class WinFuncParser(Parser):
         except StopIteration:
             raise NormalParsingTerminaison()
 
+        if type(self.peek()) == StarToken:
+            self.assert_token_type(StarToken)
+            return_type = ("PTR", return_type)
+
         func_name = self.assert_token_type(NameToken).value
         if func_name.upper() == "WINAPI":
             has_winapi = True
             func_name = self.assert_token_type(NameToken).value
-            
+
         self.assert_token_type(OpenParenthesisToken)
 
         params = []
@@ -96,9 +108,9 @@ class WinFuncParser(Parser):
         while self.peek() is not None:
             res.append(self.parse_winfunc())
         return res
-            
-            
-           
+
+
+
 
 def dbg_lexer(data):
     for i in Lexer(data).token_generation():
@@ -109,11 +121,11 @@ def dbg_parser(data):
 
 def dbg_validate(data):
     return validate_structs(Parser(data).parse())
-    
-       
+
+
 
 if __name__ == "__main__":
     import sys
     data = open(sys.argv[1], 'r').read()
     funcs = generate_ctypes(data)
-    print(funcs) 
+    print(funcs)

ctypes_generation/generate.py

@@ -1,212 +1,687 @@
 import sys
 import os
 import os.path
+import re
+import glob
+import textwrap
+import StringIO
+
+import shutil
 
 import dummy_wintypes
 import struct_parser
 import func_parser
 import def_parser
+import com_parser
 
+pjoin = os.path.join
+pexists = os.path.exists
+dedent = textwrap.dedent
 
-TYPE_EQUIVALENCE = [
-    ('PWSTR', 'LPWSTR'),
-    ('SIZE_T', 'c_ulong'),
-    ('PSIZE_T', 'POINTER(SIZE_T)'),
-    ('PVOID', 'c_void_p'),
-    ('PPS_POST_PROCESS_INIT_ROUTINE', 'PVOID'),
-    ('NTSTATUS', 'DWORD'),
-    ('PULONG', 'POINTER(ULONG)'),
-    ('PDWORD', 'POINTER(DWORD)'),
-    ('LPDWORD', 'POINTER(DWORD)'),
-    ('LPTHREAD_START_ROUTINE', 'PVOID'),
-    ('PHANDLER_ROUTINE', 'PVOID'),
-    ('LPBYTE', 'POINTER(BYTE)'),
-    ('ULONG_PTR','PULONG'),
-    ('CHAR', 'c_char'),
-    ('UCHAR', 'c_char'),
-    ('FARPROC', 'PVOID'),
-    ('HGLOBAL', 'PVOID'),
-    ('PVECTORED_EXCEPTION_HANDLER', 'PVOID'),
-    #('HRESULT', 'c_long'), # VERY BAD : real HRESULT raise by itself -> way better
-    ('ULONGLONG', 'c_ulonglong'),
-    ('LONGLONG', 'c_longlong'),
-    ('ULONG64', 'c_ulonglong'),
-    ('DWORD64', 'ULONG64'),
-    ('PULONG64', 'POINTER(ULONG64)'),
-    ('PHANDLE', 'POINTER(HANDLE)'),
-    ('HKEY', 'HANDLE'),
-    ('PHKEY', 'POINTER(HKEY)'),
-    ('ACCESS_MASK', 'DWORD'),
-    ('REGSAM', 'ACCESS_MASK'),
-    # Will be changed at import time
-    ('LPCONTEXT', 'PVOID'),
-    ('HCERTSTORE', 'PVOID'),
-    ('HCRYPTMSG', 'PVOID'),
-    ]
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+print(SCRIPT_DIR)
+from_here = lambda path: pjoin(SCRIPT_DIR, path)
 
-# For functions returning void
-TYPE_EQUIVALENCE.append(('VOID', 'DWORD'))
+DEST_DIR = from_here(r"..\windows\generated_def")
+to_dest = lambda path: pjoin(DEST_DIR, path)
 
-known_type = dummy_wintypes.names + list([x[0] for x in TYPE_EQUIVALENCE])
+class ParsedFile(object):
+    def __init__(self, filename):
+        self.filename = filename
+        self.data = self.PARSER(open(filename).read()).parse()
+        self.exports = set()
+        self.imports = set()
+        self.compute_imports_exports(self.data)
 
-FUNC_FILE = "winfunc.txt"
-STRUCT_FILE = "winstruct.txt"
-DEF_FILE = "windef.txt"
+    def add_exports(self, *names):
+        self.exports.update(names)
 
-GENERATED_STRUCT_FILE = "winstructs"
-GENERATED_FUNC_FILE = "winfuncs"
-GENERATED_DEF_FILE = "windef"
+    def add_imports(self, *names):
+        self.imports.update(names)
 
-OUT_DIRS = ["..\windows\generated_def"]
-if len(sys.argv) > 1:
-    OUT_DIRS.append(sys.argv[1])
-
-def get_all_struct_name(structs, enums):
-    res = []
-    for s in structs + enums:
-        res.append(s.name)
-        res.extend(s.typedef)
-    return res
-
-def generate_type_equiv_code(type_equiv):
-    ctypes_str = ""
-    for type_equiv in type_equiv:
-        ctypes_str += "{0} = {1}\n".format(*type_equiv)
-    ctypes_str += "\n"
-    return ctypes_str
-
-def verif_funcs_type(funcs, structs, enums):
-    all_struct_name = get_all_struct_name(structs, enums)
-    for f in funcs:
-        ret_type = f.return_type
-        if ret_type not in known_type and ret_type not in all_struct_name:
-            import pdb; pdb.set_trace()
-            raise ValueError("UNKNOW RET TYPE {0}".format(ret_type))
-
-        for param_type, _ in f.params:
-            # Crappy but fuck it !
-            if param_type.startswith("POINTER(") and param_type.endswith(")"):
-                param_type = param_type[len("POINTER("): -1]
-            if param_type not in known_type and param_type not in all_struct_name:
-                import pdb; pdb.set_trace()
-                raise ValueError("UNKNOW PARAM TYPE {0}".format(param_type))
-
-def check_in_define(name, defs):
-    return any(name == d.name for d in defs)
-
-def validate_structs(structs, enums, defs):
-    all_struct_name = get_all_struct_name(structs, enums)
-    for struct in structs:
-        for field_type, field_name, nb_rep in struct.fields:
-            if field_type.name not in known_type + all_struct_name:
-                import pdb; pdb.set_trace()
-                raise ValueError("UNKNOW TYPE {0}".format(field_type))
-            try:
-                int(nb_rep)
-            except ValueError:
-                if not check_in_define(nb_rep, defs):
-                    raise ValueError("UNKNOW DEFINE {0}".format(nb_rep))
-
-common_header = "#Generated file\n"
-
-defs_header = common_header + """
-import sys
-if sys.version_info.major == 3:
-    long = int
-
-class Flag(long):
-    def __new__(cls, name, value):
-        return super(Flag, cls).__new__(cls, value)
-
-    def __init__(self, name, value):
-        self.name = name
+    def compute_imports_exports(self):
+        raise NotImplementedError("compute_imports_exports")
 
     def __repr__(self):
-        return "{0}({1})".format(self.name, hex(self))
+        return '<{clsname} "{0}">'.format(self.filename, clsname=type(self).__name__)
 
-    __str__ = __repr__
+class StructureParsedFile(ParsedFile):
+    PARSER = struct_parser.WinStructParser
+
+    def compute_imports_exports(self, data):
+        structs, enums = data
+        for enum in enums:
+            self.add_exports(enum.name)
+            self.add_exports(*enum.typedef)
+        for struct in structs:
+            self.add_exports(struct.name)
+            self.add_exports(*struct.typedef)
+            for field_type, field_name, nb_rep in struct.fields:
+                if field_type.name not in self.exports:
+                    self.add_imports(field_type.name)
+                try:
+                    int(nb_rep)
+                except:
+                    self.add_imports(nb_rep)
+
+class SimpleTypeParsedFile(ParsedFile):
+    PARSER = struct_parser.SimpleTypesParser
+
+    def compute_imports_exports(self, data):
+        for simple_type in data:
+            self.add_exports(simple_type.lvalue) # No dependancy check on rvalue for now
+
+
+class DefinitionParsedFile(ParsedFile):
+    PARSER = def_parser.WinDefParser
+
+    def compute_imports_exports(self, data):
+        for windef in data:
+            self.add_exports(windef.name) # No dependancy check on rvalue for now
+
+class NtStatusParsedFile(ParsedFile):
+    PARSER = def_parser.NtStatusParser
+
+    def compute_imports_exports(self, data):
+        for ntstatus in data:
+            self.add_exports(ntstatus[1])
+
+class FunctionParsedFile(ParsedFile):
+    PARSER = func_parser.WinFuncParser
+
+    def compute_imports_exports(self, data):
+        for func in data:
+            if isinstance(func.return_type, tuple) and func.return_type[0] == "PTR":
+                self.add_imports(func.return_type[1])
+            else:
+                self.add_imports(func.return_type)
+            for param_type, _ in func.params:
+                if param_type.startswith("POINTER(") and param_type.endswith(")"):
+                    param_type = param_type[len("POINTER("): -1]
+                self.add_imports(param_type)
+            self.add_exports(func.name)
+
+
+class COMParsedFile(ParsedFile):
+    PARSER = com_parser.WinComParser
+    IGNORED_INTERFACE = set(["ITypeInfo"])
+
+    def compute_imports_exports(self, cominterface):
+        self.add_exports(cominterface.name)
+        if cominterface.typedefptr:
+            self.add_exports(cominterface.typedefptr)
+
+        for  method in cominterface.methods:
+            self.compute_method_imports_exports(cominterface, method)
+
+
+    def compute_method_imports_exports(self, interface, method):
+        self.add_imports(method.ret_type)
+        for arg in method.args[1:]: # First one is 'this'
+            if arg.byreflevel > 0:
+                if arg.type == "void":
+                    continue # PVOID DEP: don't care
+            if arg.type in self.IGNORED_INTERFACE:
+                continue # Will be replaced by "PVOID" at generation: ignore dep
+            if arg.type == interface.name:
+                continue # Do not add dependence to our own COM interface
+
+            self.add_imports(arg.type)
+
+
+
+class ParsedFileGraph(object):
+    def __init__(self, nodes, depnodes): # depnodes: nodes that we dont have to handle but want can take export from
+        self.nodes = nodes
+        self.depnodes = depnodes
+        self.exports_database = {}
+        self.depandances_database = {node: set() for node in nodes}
+        self.build_export_database(self.nodes)
+        self.build_depandance_database()
+
+    def build_dependancy_graph(self):
+        todo = set(self.nodes)
+        start = self.find_starting_node()
+        print("Starting node is {0}".format(start))
+        todo.remove(start)
+        flatten = [start]
+        depdone = set(flatten) | set(self.depnodes)
+        while todo:
+            for node in todo:
+                if self.depandances_database[node].issubset(depdone):
+                    break
+            else:
+                raise ValueError("Could not find a next node for dep flattening")
+
+            flatten.append(node)
+            depdone.add(node)
+            todo.remove(node)
+            print("Next is <{0}>".format(node))
+        return flatten
+
+
+    def build_depandance_database(self):
+        for node in self.nodes:
+            for import_ in node.imports:
+                try:
+                    self.depandances_database[node].add(self.exports_database[import_])
+                except KeyError as e:
+                    raise ValueError("Missing dependancy <{0}> of {1}".format(import_, node))
+
+
+    def build_export_database(self, nodes):
+        for node in self.nodes + self.depnodes:
+            for export in node.exports:
+                if export in self.exports_database:
+                    raise ValueError("{0} IN {1} but  already exported by {2}".format(export, self.exports_database[export], node))
+                self.exports_database[export] = node
+
+    def find_starting_node(self):
+        for node in self.nodes:
+            if self.depandances_database[node].issubset(set(self.depnodes)):
+                return node
+        raise ValueError("Could not find a starting NODE without dependancy")
+
+
+class BasicTypeNodes(object):
+    @property
+    def exports(self):
+        # Let allow ourself to redefine the bugged BYTE define & MAX_PATH which is NOT A TYPE !
+        return set(dummy_wintypes.names) - set(["BYTE", "MAX_PATH"])
+
+class FakeExporter(object):
+    def __init__(self, exports):
+        self.exports = exports
+
+class ParsedDirectory(object):
+    def __init__(self, filetype, directory):
+        self.nodes = [filetype(f) for f in glob.glob(directory)]
+
+
+### Generation Class ###
+
+class CtypesGenerator(object):
+    def __init__(self, parsed_files, template):
+        self.files = parsed_files # Already in generation order
+        self.template = template # MAKE BETTER
+        self.result = StringIO.StringIO()
+        self.imported_name = set([])
+
+    def add_import_name(self, name):
+        self.imported_name.add(name)
+
+    def emit(self, str):
+        self.result.write(str)
+
+    def emitline(self, str):
+        self.emit(str)
+        self.emit("\n")
+
+    def before_emit_template(self):
+        pass
+
+    def after_emit_template(self):
+        pass
+
+    def emit_import_dependancies(self):
+        for name in self.imported_name:
+            self.emitline("from {0} import *".format(name))
+
+    def copy_template(self):
+        with open(self.template) as f:
+            self.emit(f.read())
+
+    def generate(self):
+        self.emit_import_dependancies()
+        self.before_emit_template()
+        self.copy_template()
+        self.after_emit_template()
+        self.generate_files(self.files)
+
+    def generate_files(self, files):
+        for file in files:
+            self.generate_for_file(file)
+
+    def generate_for_file(self, file):
+        pass
+
+    def generate_into(self, filename):
+        self.generate()
+        print("Writing generated code into {0}".format(filename))
+        with open(filename, "w") as f:
+            f.write(self.result.getvalue())
+
+class NoTemplatedGenerator(CtypesGenerator):
+   def __init__(self, parsed_files):
+       self.files = parsed_files # Already in generation order
+       self.result = StringIO.StringIO()
+       self.imported_name = set([])
+
+   def copy_template(self):
+       pass
+
+NTSTATUS_MODULE = "ntstatus"
+
+class DefineCtypesGenerator(CtypesGenerator):
+    def after_emit_template(self):
+        self.emitline("from {0} import *".format(NTSTATUS_MODULE))
+
+    def generate_for_file(self, file):
+        for define in file.data:
+            self.emitline(define.generate_ctypes())
+
+
+# TEST Documentation generator
+class DefineDocGenerator(NoTemplatedGenerator):
+    def copy_template(self):
+        self.emitline(".. currentmodule:: windows.generated_def")
+        self.emitline("")
+        self.emitline("Windef")
+        self.emitline("------")
+
+    def generate_for_file(self, file):
+        for define in file.data:
+            self.emitline(".. autodata:: {define.name}".format(define=define))
+
+
+class NtStatusCtypesGenerator(CtypesGenerator):
+    def generate_for_file(self, file):
+        for value, name, descr in file.data:
+            value = "{:#x}".format(value)
+            line = '{1} = NtStatusException.register_ntstatus({0}, "{1}", "{2}")'.format(value, name, descr)
+            self.emitline(line)
+
+
+class NtStatusDocGenerator(NoTemplatedGenerator):
+    def copy_template(self):
+        self.emitline(".. currentmodule:: windows.generated_def")
+        self.emitline("")
+        self.emitline("Ntstatus")
+        self.emitline("--------")
+
+    def generate_for_file(self, file):
+        for value, name, descr in file.data:
+            self.emitline(".. autodata:: {name}".format(name=name))
+
+class COMCtypesGenerator(CtypesGenerator):
+    IGNORED_INTERFACE = set(COMParsedFile.IGNORED_INTERFACE)
+    def __init__(self, *args, **kwargs):
+        super(COMCtypesGenerator, self).__init__(*args, **kwargs)
+        self.iids_def = {}
+        self.generated_interfaces_names = set(self.IGNORED_INTERFACE)
+        for file in self.files:
+            self.generated_interfaces_names.update(file.exports)
+
+
+    def parse_iid_file(self, filename):
+        data = open(filename).read()
+        for line in data.split("\n"):
+            name, iid = line.split("|")
+            self.iids_def[name] = self.parse_iid(iid), iid
+
+    def generate_files(self, files):
+        # We generate COM interface in 2 step
+        # 1) The Class intself with the IDD
+        # 2) The function list after all class we generated
+        #    - This allow COM function to refer the interface in their def :)
+        for file in files:
+            self.generate_com_interface_class_iid(file.data)
+        for file in files:
+            self.generate_com_interface_functions(file.data)
+
+    def generate_com_interface_class_iid(self, cominterface):
+        name = cominterface.name
+        if cominterface.iid is not None:
+            iid_str = cominterface.iid
+            iid_python = self.parse_iid(iid_str)
+        else:
+            print("Lookup of IID for <{0}>".format(cominterface.name))
+            iid_python, iid_str = self.iids_def[cominterface.name]
+        cls_format_param = {"name": name, "iid_python" : iid_python, "iid_str": iid_str}
+
+        self.emitline("class {name}(COMInterface):".format(**cls_format_param))
+        self.emitline('    IID = generate_IID({iid_python}, name="{name}", strid="{iid_str}")'.format(**cls_format_param))
+        self.emitline('')
+
+    def generate_com_interface_functions(self, cominterface):
+        name = cominterface.name
+        self.emitline("{name}._functions_ = {{".format(name=name))
+        self.emit_com_interface_functions(cominterface)
+        self.emitline('    }')
+        self.emitline('')
+
+    def emit_com_interface_functions(self, cominterface):
+        indent = " " * 8
+        for method_nb, method in enumerate(cominterface.methods):
+            args_to_define = method.args[1:] # ctypes doesnt not need the This
+            name = method.name
+            params = ", ".join([arg.name +":"+ ("*"* arg.byreflevel) +arg.type for arg in args_to_define])
+            self.emitline(indent + "# {name} -> {params}".format(name=name, params=params))
+
+            str_args = []
+            for arg in args_to_define:
+                if arg.type == "void" and arg.byreflevel > 0:
+                    arg = type(arg)("PVOID", arg.byreflevel - 1, arg.name)
+                atype = arg.type
+                byreflevel = arg.byreflevel
+                if atype in self.generated_interfaces_names:
+                    # If the parameter is a COM interface, remove a *
+                    # (as PFW ComInterface are PVOID)
+                    byreflevel = arg.byreflevel - 1
+                    if atype in self.IGNORED_INTERFACE:
+                        # If the interface if ignored -> replace by a raw pointer
+                        atype = "PVOID"
+
+                for i in range(byreflevel):
+                    atype = "POINTER({0})".format(atype)
+                str_args.append(atype)
+
+            params = ", ".join([method.ret_type] + str_args)
+            ctypes_functype = 'WINFUNCTYPE' if method.functype == 'stdcall' else 'CFUNCTYPE'
+            self.emitline(indent + '"{0}": ctypes.{functype}({1})({2}, "{0}"),'.format(name, params, method_nb, functype=ctypes_functype))
+        return
+
+
+    def parse_iid(self, iid_str):
+        part_iid = iid_str.split("-")
+        str_iid = []
+        str_iid.append("0x" + part_iid[0])
+        str_iid.append("0x" + part_iid[1])
+        str_iid.append("0x" + part_iid[2])
+        str_iid.append("0x" + part_iid[3][:2])
+        str_iid.append("0x" + part_iid[3][2:])
+        for i in range(6): str_iid.append("0x" + part_iid[4][i * 2:(i + 1) * 2])
+        return ", ".join(str_iid)
+
+#TODO: subclass NOTEMPLATE
+class FunctionCtypesGenerator(NoTemplatedGenerator):
+    def generate_for_file(self, file):
+        for item in file.data:
+            self.emitline(item.generate_ctypes())
+
+
+
+EXTENDED_STRUCT_FILE = glob.glob(pjoin(SCRIPT_DIR, "extended_structs", "*.py"))
+EXTENDED_STRUCT = [os.path.basename(filename)[:-len(".py")] for filename in EXTENDED_STRUCT_FILE]
+
+class StructureCtypesGenerator(CtypesGenerator):
+    def generate_for_simple_type_file(self, file):
+        for simple_type in file.data:
+            self.emitline(simple_type.generate_ctypes())
+
+    def generate_for_file(self, file):
+        if isinstance(file, SimpleTypeParsedFile):
+            return self.generate_for_simple_type_file(file)
+        structs, enums = file.data
+        for definition in [d for l in (enums, structs) for d in l]:
+            self.emitline(definition.generate_ctypes())
+            if definition.name in EXTENDED_STRUCT:
+                print("Including extended definition for <{0}>".format(definition.name))
+                extended_struct_filename = from_here(os.path.join("extended_structs", "{0}.py".format(definition.name)))
+                with open(extended_struct_filename) as f:
+                    self.emitline(f.read())
+                    # RE-generate the typedef to apply them to the extended definition
+                    self.emitline(definition.generate_typedef_ctypes())
+
+
+class StructureDocGenerator(NoTemplatedGenerator):
+    STRUCT_NAME_SEPARATOR = "'"
+
+    def copy_template(self):
+        self.emitline(".. currentmodule:: windows.generated_def.winstructs")
+        self.emitline("")
+
+    def generate(self):
+        self.copy_template()
+
+        self.emitline("Winstructs")
+        self.emitline("----------")
+        for file in self.files:
+            self.generate_structures_for_file(file)
+
+        self.emitline("WinEnums")
+        self.emitline("--------")
+        for file in self.files:
+            self.generate_enums_for_file(file)
+
+    def generate_doc_simple_type_file(self, file):
+        # TODO !
+        return
+
+    def generate_structures_for_file(self, file):
+        if isinstance(file, SimpleTypeParsedFile):
+            return self.generate_doc_simple_type_file(file)
+
+        structs, enums = file.data
+        for struct in structs:
+            self.emitline(struct.name)
+            self.emitline(self.STRUCT_NAME_SEPARATOR * len(struct.name))
+            # Emit typedef
+            for name, type in  struct.typedef.items():
+                self.emitline(".. class:: {0}".format(name))
+                self.emitline("")
+                if hasattr(type, "type"):
+                    self.emitline("    Pointer to :class:`{0}`".format(type.type.name))
+                else:
+                    self.emitline("    Alias for :class:`{0}`".format(type.name))
+                self.emitline("")
+            # Emit struct Definition
+            self.emitline(".. class:: {0}".format(struct.name))
+            for ftype, fname, nb in struct.fields:
+                array_str = " ``[{nb}]``".format(nb=nb) if nb > 1 else ""
+                self.emitline("")
+                self.emitline("    .. attribute:: {fname}".format(fname=fname))
+                self.emitline("")
+                self.emitline("        :class:`{ftype.name}`{array_str}".format(ftype=ftype, array_str=array_str))
+                self.emitline("")
+
+    def generate_enums_for_file(self, file):
+        if isinstance(file, SimpleTypeParsedFile):
+            return
+        structs, enums = file.data
+        for enum in enums:
+            self.emitline(enum.name)
+            self.emitline(self.STRUCT_NAME_SEPARATOR * len(enum.name))
+             # Emit typedef
+            for name, type in  enum.typedef.items():
+                self.emitline(".. class:: {0}".format(name))
+                self.emitline("")
+                if hasattr(type, "type"):
+                    self.emitline("    Pointer to :class:`{0}`\n\n".format(type.type.name))
+                else:
+                    self.emitline("    Alias for :class:`{0}`\n\n".format(type.name))
+            # Emit enum Definition
+            self.emitline(".. class:: {0}".format(enum.name))
+            self.emitline("")
+            for enum_value, enum_name in enum.fields:
+                self.emitline("")
+                self.emitline("    .. attribute:: {0}({1})".format(enum_name, enum_value))
+                self.emitline("")
+
+META_WALKER = """
+def generate_walker(namelist, target_module):
+    def my_walker():
+        for name in namelist:
+            yield name, getattr(target_module, name)
+    return my_walker
 """
 
-def generate_defs_ctypes(defs):
-    ctypes_lines = [defs_header] + [d.generate_ctypes() for d in defs]
-    ctypes_code = "\n".join(ctypes_lines)
-    return ctypes_code
+class MetaFileGenerator(NoTemplatedGenerator):
+    def __init__(self):
+       self.result = StringIO.StringIO()
+       self.modules = []
+
+    def add_exportlist(self, name, modname, exports):
+        self.modules.append((name, modname, exports))
+
+    def add_export_module(self, module):
+        self.add_exportlist(module.name, module.name, module.modules_exports())
+
+    def generate(self):
+
+        for name, modname, exports in self.modules:
+            self.emitline("{0} = {1}".format(name, exports))
+
+        self.emitline(META_WALKER)
+
+        for name, modname, exports in self.modules:
+                self.emitline("import {0} as {0}_module".format(modname))
+                self.emitline("{0}_walker = generate_walker({0}, {1}_module)".format(name, modname))
 
 
-funcs_header = common_header + """
-from ctypes import *
-from ctypes.wintypes import *
-from .{0} import *
+class ModuleGenerator(object):
+    def __init__(self, name, filetype, ctypesgenerator, docgenerator, src):
+        self.name = name
+        self.filetype = filetype
+        self.ctypesgenerator = ctypesgenerator
+        self.docgenerator = docgenerator
+        self.src = src
+        self.parsed_dir = None
+        self.nodes = []
+        self.dependances_modules = set([])
 
-"""[1:].format(GENERATED_STRUCT_FILE)
+    def add_module_dependancy(self, module):
+        self.dependances_modules.add(module)
 
-def generate_funcs_ctypes(funcs):
-    ctypes_code = funcs_header
+    def parse_directory(self, globdir):
+        self.nodes += ParsedDirectory(self.filetype, globdir).nodes
 
-    all_funcs_name = [f.name for f in funcs]
-    ctypes_code += "functions = {0}\n\n".format(str(all_funcs_name))
-    for func in funcs:
-        ctypes_code += func.generate_ctypes() + "\n"
-    return ctypes_code
+    def get_template_filename(self):
+        return pjoin(self.src, "template.py")
 
-structs_header = common_header + """
-from ctypes import *
-from ctypes.wintypes import *
-from .windef import *
+    def parse_source_directory(self):
+        if os.path.isdir(self.src):
+            srcglob = pjoin(self.src, "*.txt")
+        else:
+            srcglob = self.src
+        self.parse_directory(srcglob)
 
-"""[1:]
+    def resolve_dependancies(self, depnodes=[]):
+        g = ParsedFileGraph(self.nodes, depnodes=depnodes)
+        return g.build_dependancy_graph()
 
-def generate_struct_ctypes(structs, enums):
-    ctypes_str  = structs_header
-    ctypes_str += generate_type_equiv_code(TYPE_EQUIVALENCE)
+    def check_dependancies_without_flattening(self, depnodes):
+        g = ParsedFileGraph(self.nodes, depnodes=depnodes) # init check for missing dependance
+        return g.nodes
 
-    all_struct_name = [s.name for s in structs]
-    ctypes_str += "structs = {0}\n\n".format(str(all_struct_name))
+    def generate(self):
+        self.parse_source_directory()
+        # Flatten the graph
+        flatten_nodes = self.resolve_dependancies()
+        self.generate_from_nodelist(flatten_nodes)
+        self.nodes = flatten_nodes
 
-    all_enum_name = [e.name for e in enums]
-    ctypes_str += "enums = {0}\n\n".format(str(all_enum_name))
+    def resolve_dep_and_generate(self, depnodes=[]):
+        depnodes = list(depnodes)
+        # Add module dependancies nodes to the finals depnodes
+        for moddep in self.dependances_modules:
+            depnodes += moddep.nodes
+        flatten_nodes = self.resolve_dependancies(depnodes=depnodes)
+        self.generate_from_nodelist(flatten_nodes)
 
-    # Enums declarations
-    for enum in enums:
-        ctypes_str += "# Enum {0} definitions\n".format(enum.name)
-        ctypes_str += enum.generate_ctypes() + "\n"
+    def after_ctypes_generator_init(self, ctypesgen):
+        pass
 
-    # Struct declarations
+    def generate_from_nodelist(self, nodelist):
+        template = self.get_template_filename()
+        if template is not None:
+            ctypesgen = self.ctypesgenerator(nodelist, template)
+        else:
+            ctypesgen = self.ctypesgenerator(nodelist)
+        for moddep in self.dependances_modules:
+            ctypesgen.add_import_name(moddep.name)
+
+        self.after_ctypes_generator_init(ctypesgen)
+        finalfilename = "{0}.py".format(self.name)
+        ctypesgen.generate_into(to_dest(finalfilename)) # Need to handle dest != PythonForWindows
+
+    def generate_doc(self, filename):
+        nodelist = self.nodes
+        self.docgenerator(nodelist).generate_into(filename)
+
+
+    def modules_exports(self):
+        res = set([])
+        for node in self.nodes:
+            res = res | node.exports
+        return res
+
+
+# Copy Flag code
+shutil.copy(from_here(r"definitions\flag.py"), DEST_DIR)
+
+print("== Generating defines ==")
+# Generate defines
+definemodulegenerator = ModuleGenerator("windef", DefinitionParsedFile, DefineCtypesGenerator, DefineDocGenerator, from_here(r"definitions\defines"))
+definemodulegenerator.generate()
+definemodulegenerator.generate_doc(from_here(r"..\docs\source\windef_generated.rst"))
+
+print("== Generating NTSTATUS ==")
+# Generate Ntstatus
+ntstatus_module_generator = ModuleGenerator("ntstatus", NtStatusParsedFile, NtStatusCtypesGenerator, NtStatusDocGenerator, from_here(r"definitions\ntstatus.txt"))
+# Hardcoded template file (no dir for ntstatus) -- Need one dir ?
+ntstatus_module_generator.get_template_filename = lambda : from_here(r"definitions\ntstatus_template.py")
+ntstatus_module_generator.generate()
+ntstatus_module_generator.generate_doc(from_here(r"..\docs\source\ntstatus_generated.rst"))
+
+print("== Generating structures ==")
+# Parse the simple type file
+stfilename = from_here(r"definitions\simple_types.txt")
+struct_parser.SimpleTypesParser(open(stfilename).read()).parse()
+ss = SimpleTypeParsedFile(stfilename)
+# Generate struct + simple types
+structure_module_generator = ModuleGenerator("winstructs", StructureParsedFile, StructureCtypesGenerator, StructureDocGenerator, from_here(r"definitions\structures"))
+structure_module_generator.parse_source_directory()
+# Add the simple type file to the know structures (for dep resolve + generation)
+structure_module_generator.nodes.append(ss)
+structure_module_generator.add_module_dependancy(definemodulegenerator)
+structure_module_generator.resolve_dep_and_generate([BasicTypeNodes()])
+structure_module_generator.generate_doc(from_here(r"..\docs\source\winstructs_generated.rst"))
+
+print("== Generating COM interfaces ==")
+# Generate COM interfaces
+com_module_generator = ModuleGenerator("interfaces", COMParsedFile, COMCtypesGenerator, None, from_here(r"definitions\com"))
+# Load the interface_to_iid file needed by the 'COMCtypesGenerator'
+com_module_generator.after_ctypes_generator_init = lambda cgen: cgen.parse_iid_file(from_here("definitions\\interface_to_iid.txt"))
+com_module_generator.parse_source_directory()
+com_module_generator.add_module_dependancy(structure_module_generator)
+com_module_generator.resolve_dependancies = com_module_generator.check_dependancies_without_flattening # No real flattening as we have circular dep in Interfaces VTBL
+com_module_generator.resolve_dep_and_generate([BasicTypeNodes()])
+
+print("== Generating functions ==")
+# Generate function
+functions_module_generator = ModuleGenerator("winfuncs", FunctionParsedFile, FunctionCtypesGenerator, None, from_here(r"definitions\functions"))
+# no template file
+functions_module_generator.get_template_filename = lambda : None
+functions_module_generator.parse_source_directory()
+functions_module_generator.add_module_dependancy(structure_module_generator)
+functions_module_generator.add_module_dependancy(com_module_generator)
+functions_module_generator.resolve_dep_and_generate([BasicTypeNodes()])
+
+
+print("== Generating META file ==")
+# Meta-file generator
+enums_exports = set()
+structs_exports = set()
+# Extract enums export & structures exports
+for node in structure_module_generator.nodes:
+    if isinstance(node, SimpleTypeParsedFile):
+        continue # Generate META for simple type ?
+    structs, enums = node.data
     for struct in structs:
-        ctypes_str += "# Struct {0} definitions\n".format(struct.name)
-        ctypes_str += struct.generate_ctypes() + "\n"
+        structs_exports.add(struct.name)
+        structs_exports.update(struct.typedef)
+    for enum in enums:
+        enums_exports.add(enum.name)
+        enums_exports.update(enum.typedef)
 
-    return ctypes_str
+meta = MetaFileGenerator()
+meta.add_exportlist("windef", definemodulegenerator.name, definemodulegenerator.modules_exports() | ntstatus_module_generator.modules_exports())
+# Add structs / enums as 2 differents lists
+meta.add_exportlist("structs", structure_module_generator.name, structs_exports)
+meta.add_exportlist("enums", structure_module_generator.name, enums_exports)
+meta.add_exportlist("functions", functions_module_generator.name, functions_module_generator.modules_exports())
+meta.add_exportlist("interfaces", com_module_generator.name, com_module_generator.modules_exports())
+meta.generate_into(to_dest("meta.py"))
 
-def write_to_out_file(name, data):
-    for out_dir in OUT_DIRS:
-        f = open("{0}/{1}.py".format(out_dir, name), 'w')
-        f.write(data)
-        f.close()
-
-def_code  = open(DEF_FILE, 'r').read()
-funcs_code = open(FUNC_FILE, 'r').read()
-structs_code = open(STRUCT_FILE, 'r').read()
-
-defs = def_parser.WinDefParser(def_code).parse()
-funcs = func_parser.WinFuncParser(funcs_code).parse()
-structs, enums = struct_parser.WinStructParser(structs_code).parse()
-
-
-validate_structs(structs, enums, defs)
-verif_funcs_type(funcs, structs, enums)
-
-defs_ctypes = generate_defs_ctypes(defs)
-funcs_ctypes = generate_funcs_ctypes(funcs)
-structs_ctypes = generate_struct_ctypes(structs, enums)
-
-for out_dir in OUT_DIRS:
-    if not os.path.exists(out_dir):
-        os.mkdir(out_dir)
-
-write_to_out_file(GENERATED_DEF_FILE, defs_ctypes)
-write_to_out_file(GENERATED_FUNC_FILE, funcs_ctypes)
-write_to_out_file(GENERATED_STRUCT_FILE, structs_ctypes)
-
-for out_dir in OUT_DIRS:
-    print("Files generated in <{0}>".format(os.path.abspath(out_dir)))
+print("DONE !")

ctypes_generation/oldgen.py

@@ -0,0 +1,918 @@
+import sys
+import os
+import os.path
+import re
+import glob
+import textwrap
+
+import dummy_wintypes
+import struct_parser
+import func_parser
+import def_parser
+import com_parser
+
+pjoin = os.path.join
+pexists = os.path.exists
+dedent = textwrap.dedent
+
+
+TYPE_EQUIVALENCE = [
+    # BYTE is defined in ctypes.wintypes as c_byte but who wants
+    # BYTE to be signed ? (from MSDN: <typedef unsigned char BYTE;>)
+    ('BYTE', 'c_ubyte'),
+    ('PWSTR', 'LPWSTR'),
+    ('PCWSTR', 'LPWSTR'),
+    ('SIZE_T', 'c_size_t'),
+    ('PSIZE_T', 'POINTER(SIZE_T)'),
+    ('PVOID', 'c_void_p'),
+    ('PPS_POST_PROCESS_INIT_ROUTINE', 'PVOID'),
+    ('NTSTATUS', 'DWORD'),
+    ('SECURITY_INFORMATION', 'DWORD'),
+    ('PSECURITY_INFORMATION', 'POINTER(SECURITY_INFORMATION)'),
+    ('PULONG', 'POINTER(ULONG)'),
+    ('PDWORD', 'POINTER(DWORD)'),
+    ('LPDWORD', 'POINTER(DWORD)'),
+    ('LPTHREAD_START_ROUTINE', 'PVOID'),
+    ('WNDENUMPROC', 'PVOID'),
+    ('PHANDLER_ROUTINE', 'PVOID'),
+    ('LPBYTE', 'POINTER(BYTE)'),
+    ('ULONG_PTR','PVOID'),
+    ('DWORD_PTR','ULONG_PTR'),
+    ('KAFFINITY','ULONG_PTR'),
+    ('KPRIORITY','LONG'),
+    ('CHAR', 'c_char'),
+    ('INT', 'c_int'),
+    ('UCHAR', 'c_char'),
+    ('CSHORT', 'c_short'),
+    ('VARTYPE', 'c_ushort'),
+    ('PBOOL', 'POINTER(BOOL)'),
+    ('PSTR', 'LPSTR'),
+    ('PCSTR', 'LPSTR'),
+    ('va_list', 'c_char_p'),
+    ('BSTR', 'c_wchar_p'),
+    ('OLECHAR', 'c_wchar'),
+    ('POLECHAR', 'c_wchar_p'),
+    ('PUCHAR', 'POINTER(UCHAR)'),
+    ('double', 'c_double'),
+    ('FARPROC', 'PVOID'),
+    ('HGLOBAL', 'PVOID'),
+    ('PSID', 'PVOID'),
+    ('PVECTORED_EXCEPTION_HANDLER', 'PVOID'),
+    #('HRESULT', 'c_long'), # VERY BAD : real HRESULT raise by itself -> way better
+    ('ULONGLONG', 'c_ulonglong'),
+    ('LONGLONG', 'c_longlong'),
+    ('ULONG64', 'c_ulonglong'),
+    ('UINT64', 'ULONG64'),
+    ('LONG64', 'c_longlong'),
+    ('LARGE_INTEGER', 'LONGLONG'),
+    ('PLARGE_INTEGER', 'POINTER(LARGE_INTEGER)'),
+    ('DWORD64', 'ULONG64'),
+    ('SCODE', 'LONG'),
+    ('CIMTYPE', 'LONG'),
+    ('NET_IFINDEX', 'ULONG'),
+    ('IF_INDEX', 'NET_IFINDEX'),
+    ('IFTYPE', 'ULONG'),
+    ('PULONG64', 'POINTER(ULONG64)'),
+    ('LPFILETIME', 'POINTER(FILETIME)'),
+    ('LPPOINT', 'POINTER(POINT)'),
+    ('LPRECT', 'POINTER(RECT)'),
+    ('PBYTE', 'POINTER(BYTE)'),
+    ('PUINT', 'POINTER(UINT)'),
+    ('PHANDLE', 'POINTER(HANDLE)'),
+    ('HKEY', 'HANDLE'),
+    ('HCATADMIN', 'HANDLE'),
+    ('HCATINFO', 'HANDLE'),
+    ('HDC', 'HANDLE'),
+    ('HBITMAP', 'HANDLE'),
+    ('SC_HANDLE', 'HANDLE'),
+    ('HCERTCHAINENGINE', 'HANDLE'),
+    ('LPHANDLE', 'POINTER(HANDLE)'),
+    ('ALPC_HANDLE', 'HANDLE'),
+    ('PALPC_HANDLE', 'POINTER(ALPC_HANDLE)'),
+    ('PHKEY', 'POINTER(HKEY)'),
+    ('ACCESS_MASK', 'DWORD'),
+    ('REGSAM', 'ACCESS_MASK'),
+    ('PBOOLEAN', 'POINTER(BOOLEAN)'),
+    ('SECURITY_CONTEXT_TRACKING_MODE', 'BOOLEAN'),
+    ('HCRYPTPROV_OR_NCRYPT_KEY_HANDLE', 'PULONG'),
+    ('HCRYPTPROV_LEGACY', 'PULONG'),
+    ('HCRYPTKEY', 'PULONG'),
+    ('HCRYPTPROV', 'PULONG'),
+    ('HCRYPTHASH', 'PULONG'),
+    ('ALG_ID', 'UINT'),
+    ("DISPID", "LONG"),
+    ("MEMBERID", "DISPID"),
+    ('PSECURITY_DESCRIPTOR', 'PVOID'),
+    ('LPPROC_THREAD_ATTRIBUTE_LIST', 'PVOID'),
+    ('LPUNKNOWN', 'POINTER(PVOID)'),
+    ('SPC_UUID', 'BYTE * 16'),
+    ('PIO_APC_ROUTINE', 'PVOID'),
+    ('DEVICE_TYPE', 'DWORD'),
+    #STUFF FOR COM (will be replace at runtime
+    # real def in com_interface_header
+    # ('GUID', 'PVOID'),
+    #('REFGUID', 'PVOID'),
+    #('LPGUID', 'PVOID'),
+    # STUFF FOR DBGENGINE
+    ('PWINDBG_EXTENSION_APIS32', 'PVOID'),
+    ('PWINDBG_EXTENSION_APIS64', 'PVOID'),
+    #('PDEBUG_SYMBOL_PARAMETERS', 'PVOID'),
+    # Will be changed at import time
+    ('LPCONTEXT', 'PVOID'),
+    ('HCERTSTORE', 'PVOID'),
+    ('HCRYPTMSG', 'PVOID'),
+    ('PALPC_PORT_ATTRIBUTES', 'PVOID'),
+    ]
+
+TYPE_EQUIVALENCE.append(('VOID', 'DWORD'))
+# TRICHE
+BASIC_TYPE = dummy_wintypes.names + list([x[0] for x in TYPE_EQUIVALENCE])
+
+class CtypesGenerator(object):
+    common_header = "#Generated file\n"
+
+    PARSER = None
+    IMPORT_HEADER = "{deps}"
+
+    def __init__(self, indirname, outfilename, dependances=()):
+        self.indirname = indirname
+        self.outfilename = outfilename
+        # self.infile = open(self.infilename)
+        self.data = None
+        self.dependances = dependances
+
+        self.exports = set([])
+        self.imports = set([])
+
+        self.parse()
+        self.analyse(self.data)
+        self.check_dependances()
+
+    # def parse(self):
+        # if self.data is None:
+            # print("Parsing <{0}>".format(self.infilename))
+            # self.data = self.PARSER(self.infile.read()).parse()
+        # return self.data
+
+    def parse(self):
+        if self.data is not None:
+            return self.data
+        data = []
+        for filename in glob.glob(self.indirname):
+            print("Parsing <{0}>".format(filename))
+            # data.append(self.PARSER(open(filename).read()).parse())
+            data += self.PARSER(open(filename).read()).parse()
+        self.data = data
+        return data
+
+    def analyse(self, data):
+        raise NotImplementedError("<{0}> doest not implement <analyse>".format(type(self).__name__))
+
+    def check_dependances(self):
+        missing = self.imports
+        for dep in self.dependances:
+            missing -= dep.exports
+        if missing:
+            # raise ValueError("Missing dependance <{0}> in <{1}>".format(missing, self.infilename))
+            print ValueError("Missing dependance <{0}>".format(missing))
+
+    def generate_import(self):
+        deps = "\n".join(["from {0} import *".format(os.path.basename(dep.outfilename).rsplit(".")[0]) for dep in self.dependances])
+        return self.IMPORT_HEADER.format(deps = deps)
+
+    def add_imports(self, *names):
+        self.imports.update(names)
+
+    def add_exports(self, *names):
+        self.exports.update(names)
+
+    def generate(self):
+        raise NotImplementedError("<{0}> doest not implement <generate>".format(type(self).__name__))
+
+    def append_input_file(self, filename):
+        print("Adding file <{0}>".format(filename))
+        self.parse()
+        self.data +=  self.PARSER(open(filename).read()).parse()
+        self.analyse(self.data)
+        self.check_dependances()
+
+class InitialDefGenerator(CtypesGenerator):
+    PARSER = def_parser.WinDefParser
+    HEADER = dedent("""
+        import sys
+        import platform
+        if sys.version_info.major == 3:
+            long = int
+
+        bits = platform.architecture()[0]
+        bitness =  int(bits[:2])
+
+        NATIVE_WORD_MAX_VALUE = 0xffffffff if bitness == 32 else 0xffffffffffffffff
+
+        class Flag(long):
+            def __new__(cls, name, value):
+                return super(Flag, cls).__new__(cls, value)
+
+            def __init__(self, name, value):
+                self.name = name
+
+            def __repr__(self):
+                return "{0}({1})".format(self.name, hex(self))
+
+            __str__ = __repr__
+
+           # Fix pickling with protocol 2
+            def __getnewargs__(self, *args):
+                return self.name, long(self)
+
+        class StrFlag(str):
+            def __new__(cls, name, value):
+                if isinstance(value, cls):
+                    return value
+                return super(StrFlag, cls).__new__(cls, value)
+
+            def __init__(self, name, value):
+                self.name = name
+
+            def __repr__(self):
+                return "{0}({1})".format(self.name, str.__repr__(self))
+
+            # __str__ = __repr__
+
+            # Fix pickling with protocol 2
+            def __getnewargs__(self, *args):
+                return self.name, str.__str__(self)
+
+        def make_flag(name, value):
+            if isinstance(value, (int, long)):
+                return Flag(name, value)
+            return StrFlag(name, value)
+
+        class FlagMapper(dict):
+            def __init__(self, *values):
+                self.update({x:x for x in values})
+
+            def __missing__(self, key):
+                return key
+        """)
+
+    IMPORT_HEADER = "{deps}"
+
+    def analyse(self, data):
+        self.add_exports("Flag")
+        self.add_exports("NATIVE_WORD_MAX_VALUE")
+        for defin in data:
+            self.add_exports(defin.name)
+
+    def generate(self):
+        ctypes_lines = [self.common_header, self.HEADER]
+        #deps = "\n".join(["from {0} import *".format(os.path.basename(dep.outfilename).rsplit(".")[0]) for dep in self.dependances])
+        ctypes_lines += [self.generate_import()]
+        ctypes_lines += [d.generate_ctypes() for d in self.parse()]
+        ctypes_code = "\n".join(ctypes_lines)
+        with open(self.outfilename, "w") as f:
+            f.write(ctypes_code)
+        print("<{0}> generated".format(self.outfilename))
+        return ctypes_code
+
+    def generate_doc(self, target_file):
+        all_lines = [".. currentmodule:: windows.generated_def\n\n"
+                     "Windef\n"
+                     "------\n"]
+        all_lines += [".. autodata:: {windef.name}\n".format(windef=windef) for windef in self.parse()]
+        with open(target_file, "w") as f:
+            f.writelines(all_lines)
+
+class StructGenerator(CtypesGenerator):
+    PARSER = struct_parser.WinStructParser
+    IMPORT_HEADER = dedent ("""
+        from ctypes import *
+        from ctypes.wintypes import *
+        {deps}
+    """)
+    TYPES_HEADER = dedent("""
+        class EnumValue(Flag):
+            def __new__(cls, enum_name, name, value):
+                return super(EnumValue, cls).__new__(cls, name, value)
+
+            def __init__(self, enum_name, name, value):
+                self.enum_name = enum_name
+                self.name = name
+
+            def __repr__(self):
+                return "{0}.{1}({2})".format(self.enum_name, self.name, hex(self))
+
+            # Fix pickling with protocol 2
+            def __getnewargs__(self, *args):
+                return self.enum_name, self.name, int(self)
+
+
+        class EnumType(DWORD):
+            values = ()
+            mapper = {}
+
+            @property
+            def value(self):
+                raw_value = super(EnumType, self).value
+                return self.mapper.get(raw_value, raw_value)
+
+            def __repr__(self):
+                raw_value = super(EnumType, self).value
+                if raw_value in self.values:
+                    value = self.value
+                    return "<{0} {1}({2})>".format(type(self).__name__, value.name, hex(raw_value))
+                return "<{0}({1})>".format(type(self).__name__, hex(self.value))
+
+        """)
+
+    def __init__(self, *args, **kwargs):
+        self.export_enums = set([])
+        self.export_structs = set([])
+        super(StructGenerator, self).__init__(*args, **kwargs)
+
+
+    def analyse(self, data):
+        structs, enums = data
+        for btype in BASIC_TYPE:
+            self.add_exports(btype)
+        for enum in enums:
+            self.add_exports(enum.name)
+            self.add_exports(*enum.typedef)
+            self.export_enums.update([enum.name] + enum.typedef.keys())
+        for struct in structs:
+            self.add_exports(struct.name)
+            self.add_exports(*struct.typedef)
+            self.export_structs.update([struct.name] + struct.typedef.keys())
+            for field_type, field_name, nb_rep in struct.fields:
+                if field_type.name not in self.exports:
+                    self.add_imports(field_type.name)
+                try:
+                    int(nb_rep)
+                except:
+                    self.add_imports(nb_rep)
+
+        # We have PPORT_MESSAGE32 and PPORT_MESSAGE64 and PPORT_MESSAGE is choosed at runtime
+        self.add_exports("PPORT_MESSAGE")
+
+
+    def generate(self):
+        type_equivalences = "\n".join(["{0} = {1}".format(*x) for x in TYPE_EQUIVALENCE])
+        HEADER = self.generate_import()
+        HEADER += type_equivalences
+        HEADER += self.TYPES_HEADER
+
+        structs, enums = self.data
+        ctypes_lines = [self.common_header, HEADER]
+        for definition in [d for l in (enums, structs) for d in l]:
+            ctypes_lines.append(definition.generate_ctypes())
+            if definition.name in EXTENDED_STRUCT:
+                print("Including extended definition for <{0}>".format(definition.name))
+                extended_struct_filename = from_here(os.path.join("extended_structs", "{0}.py".format(definition.name)))
+                with open(extended_struct_filename) as f:
+                    ctypes_lines.append(f.read())
+                    # import pdb;pdb.set_trace()
+                    ctypes_lines.append(definition.generate_typedef_ctypes() + "\n")
+
+        ctypes_code = "\n".join(ctypes_lines)
+        with open(self.outfilename, "w") as f:
+            f.write(ctypes_code)
+        print("<{0}> generated".format(self.outfilename))
+        return ctypes_code
+
+    def parse(self):
+        if self.data is not None:
+            return self.data
+        data = [[], []]
+        for filename in glob.glob(self.indirname):
+            print("Parsing <{0}>".format(filename))
+            # data.append(self.PARSER(open(filename).read()).parse())
+            new_data = self.PARSER(open(filename).read()).parse()
+            data[0].extend(new_data[0])
+            data[1].extend(new_data[1])
+        self.data = data
+        return data
+
+    def append_input_file(self, filename):
+        print("Adding file <{0}>".format(filename))
+        self.parse()
+        new_data = self.PARSER(open(filename).read()).parse()
+        self.data[0].extend(new_data[0])
+        self.data[1].extend(new_data[1])
+        self.analyse(self.data)
+        self.check_dependances()
+
+    def generate_doc(self, target_file):
+        all_lines = [".. currentmodule:: windows.generated_def\n\n"
+                     "Winstructs\n"
+                     "----------\n"]
+        struct_separator = "'"
+        structs, enums = self.parse()
+        for struct in structs:
+            all_lines.append("{0}\n{1}\n".format(struct.name, struct_separator * len(struct.name)))
+            for name, type in  struct.typedef.items():
+                all_lines.append(".. class:: {0}\n\n".format(name))
+                if hasattr(type, "type"):
+                    all_lines.append("    Pointer to :class:`{0}`\n\n".format(type.type.name))
+                else:
+                    all_lines.append("    Alias for :class:`{0}`\n\n".format(type.name))
+
+            all_lines.append(".. class:: {0}\n".format(struct.name))
+            for ftype, fname, nb in struct.fields:
+                array_str = " ``[{nb}]``".format(nb=nb) if nb > 1 else ""
+                all_lines.append("\n    .. attribute:: {0}\n\n        :class:`{1}`{2}\n\n".format(fname, ftype.name, array_str))
+
+        all_lines += ["WinEnums\n--------\n"]
+        for enum in enums:
+            all_lines.append("{0}\n{1}\n".format(enum.name, struct_separator * len(enum.name)))
+            for name, type in  enum.typedef.items():
+                all_lines.append(".. class:: {0}\n\n".format(name))
+                if hasattr(type, "type"):
+                    all_lines.append("    Pointer to :class:`{0}`\n\n".format(type.type.name))
+                else:
+                    all_lines.append("    Alias for :class:`{0}`\n\n".format(type.name))
+            all_lines.append(".. class:: {0}\n\n".format(enum.name))
+            for enum_value, enum_name in enum.fields:
+                all_lines.append("\n    .. attribute:: {0}({1})\n\n".format(enum_name, enum_value))
+
+        with open(target_file, "w") as f:
+            f.writelines(all_lines)
+
+
+class FuncGenerator(CtypesGenerator):
+    PARSER = func_parser.WinFuncParser
+    IMPORT_HEADER = dedent ("""
+        from ctypes import *
+        from ctypes.wintypes import *
+        {deps}
+
+        """)
+
+    def analyse(self, data):
+        for func in data:
+            if isinstance(func.return_type, tuple) and func.return_type[0] == "PTR":
+                self.add_imports(func.return_type[1])
+            else:
+                self.add_imports(func.return_type)
+            for param_type, _ in func.params:
+                if param_type.startswith("POINTER(") and param_type.endswith(")"):
+                    param_type = param_type[len("POINTER("): -1]
+                self.add_imports(param_type)
+            self.add_exports(func.name)
+
+
+    def generate(self):
+        deps = "\n".join(["from {0} import *".format(os.path.basename(dep.outfilename).rsplit(".")[0]) for dep in self.dependances])
+        HEADER = self.generate_import()
+
+        func_list = "functions = {0}\n\n".format(str([f.name for f in self.data]))
+
+        ctypes_lines = [self.common_header, HEADER, func_list] + [d.generate_ctypes() for d in self.parse()]
+        ctypes_code = "\n".join(ctypes_lines)
+        with open(self.outfilename, "w") as f:
+            f.write(ctypes_code)
+        print("<{0}> generated".format(self.outfilename))
+        return ctypes_code
+
+class NtStatusGenerator(CtypesGenerator):
+    IMPORT_HEADER = dedent("""
+    import ctypes
+    {deps}
+    """)
+    HEADER = dedent("""
+    class NtStatusException(WindowsError):
+        ALL_STATUS = {}
+        def __init__(self , code):
+            try:
+                x = self.ALL_STATUS[code]
+            except KeyError:
+                x = (code, 'UNKNOW_ERROR', 'Error non documented in ntstatus.py')
+            self.code = x[0]
+            self.name = x[1]
+            self.descr = x[2]
+            x =  ctypes.c_long(x[0]).value, x[1], x[2]
+            return super(NtStatusException, self).__init__(*x)
+
+        def __str__(self):
+            return "{e.name}(0x{e.code:x}): {e.descr}".format(e=self)
+
+        def __repr__(self):
+            return "{0}(0x{1:08x}, {2})".format(type(self).__name__, self.code, self.name)
+
+        @classmethod
+        def register_ntstatus(cls, code, name, descr):
+            if code in cls.ALL_STATUS:
+                return # Use the first def
+            cls.ALL_STATUS[code] = (code, name, descr)
+            return Flag(name, code)
+    """)
+
+    def __init__(self, infilename, outfilename, dependances=()):
+        self.infilename = infilename
+        self.outfilename = outfilename
+        self.infile = open(self.infilename)
+        self.data = None
+        self.dependances = dependances
+
+        self.exports = set([])
+        self.imports = set([])
+
+        self.parse()
+        self.analyse(self.data)
+        self.check_dependances()
+
+    def parse_ntstatus(self, content):
+        nt_status_defs = []
+        for line in content.split("\n"):
+            if not line:
+                continue
+            code, name, descr = line.split("|", 2)
+            code = int(code, 0)
+            descr = re.sub(" +", " ", descr[:-1]) # remove \n
+            descr = descr.replace('"', "'")
+            nt_status_defs.append((code, name, descr))
+        self.data = nt_status_defs
+        return self
+
+    # Hack for PARSER
+    def parse(self):
+        if self.data is None:
+            print("Parsing <{0}>".format(self.infilename))
+            self.parse_ntstatus(self.infile.read())
+        return self.data
+
+
+    def analyse(self, data):
+        self.add_imports("Flag")
+
+    def generate(self):
+        #deps = "\n".join(["from {0} import *".format(os.path.basename(dep.outfilename).rsplit(".")[0]) for dep in self.dependances])
+        HEADER = self.generate_import() + self.HEADER
+        ctypes_lines = [HEADER]
+        for code, name, descr in self.parse():
+            ctypes_lines.append('{1} = NtStatusException.register_ntstatus({0}, "{1}", "{2}")'.format(hex(code).strip("L"), name, descr))
+        ctypes_code = "\n".join(ctypes_lines)
+        with open(self.outfilename, "w") as f:
+            f.write(ctypes_code)
+        print("<{0}> generated".format(self.outfilename))
+        return ctypes_code
+
+    def generate_doc(self, target_file):
+        all_lines = [".. currentmodule:: windows.generated_def\n\n"
+                     "Ntstatus\n"
+                     "--------\n"]
+        all_lines += [".. autodata:: {nstatus_name}\n".format(nstatus_name=nstatus[1]) for nstatus in self.parse()]
+        with open(target_file, "w") as f:
+            f.writelines(all_lines)
+
+
+class InitialCOMGenerator(CtypesGenerator):
+    PARSER = com_parser.WinComParser
+    IGNORE_INTERFACE = ["ITypeInfo"]
+    IMPORT_HEADER = dedent("""
+    import functools
+    import ctypes
+
+
+    {deps}
+
+    """)
+    HEADER = dedent("""
+    generate_IID = IID.from_raw
+
+    class COMInterface(ctypes.c_void_p):
+        _functions_ = {
+        }
+
+        def __getattr__(self, name):
+            if name in self._functions_:
+                return functools.partial(self._functions_[name], self)
+            return super(COMInterface, self).__getattribute__(name)
+
+    class COMImplementation(object):
+        IMPLEMENT = None
+
+        def get_index_of_method(self, method):
+            # This code is horrible but not totally my fault
+            # the PyCFuncPtrObject->index is not exposed to Python..
+            # repr is: '<COM method offset 2: WinFunctionType at 0x035DDBE8>'
+            rpr = repr(method)
+            if not rpr.startswith("<COM method offset ") or ":" not in rpr:
+                raise ValueError("Could not extract offset of {0}".format(rpr))
+            return int(rpr[len("<COM method offset "): rpr.index(":")])
+
+        def extract_methods_order(self, interface):
+            index_and_method = sorted((self.get_index_of_method(m),name, m) for name, m in interface._functions_.items())
+            return index_and_method
+
+        def verify_implem(self, interface):
+            for func_name in interface._functions_:
+                implem = getattr(self, func_name, None)
+                if implem is None:
+                    raise ValueError("<{0}> implementing <{1}> has no method <{2}>".format(type(self).__name__, self.IMPLEMENT.__name__, func_name))
+                if not callable(implem):
+                    raise ValueError("{0} implementing <{1}>: <{2}> is not callable".format(type(self).__name__, self.IMPLEMENT.__name__, func_name))
+            return True
+
+        def _create_vtable(self, interface):
+            implems = []
+            names = []
+            for index, name, method in self.extract_methods_order(interface):
+                func_implem = getattr(self, name)
+                #PVOID is 'this'
+                types = [method.restype, PVOID] + list(method.argtypes)
+                implems.append(ctypes.WINFUNCTYPE(*types)(func_implem))
+                names.append(name)
+            class Vtable(ctypes.Structure):
+                _fields_ = [(name, ctypes.c_void_p) for name in names]
+            return Vtable(*[ctypes.cast(x, ctypes.c_void_p) for x in implems]), implems
+
+        def __init__(self):
+            self.verify_implem(self.IMPLEMENT)
+            vtable, implems = self._create_vtable(self.IMPLEMENT)
+            self.vtable = vtable
+            self.implems = implems
+            self.vtable_pointer = ctypes.pointer(self.vtable)
+            self._as_parameter_ = ctypes.addressof(self.vtable_pointer)
+
+        def QueryInterface(self, this, piid, result):
+            if piid[0] in (IUnknown.IID, self.IMPLEMENT.IID):
+                result[0] = this
+                return 1
+            return E_NOINTERFACE
+
+        def AddRef(self, *args):
+            return 1
+
+        def Release(self, *args):
+            return 0
+    """)
+
+    def __init__(self, indirname, iiddef, outfilename, dependances=()):
+        self.indirname = indirname
+        self.infilename = indirname
+        self.outfilename = outfilename
+        self.data = None
+        self.dependances = dependances
+
+        data = open(iiddef).read()
+        self.iids_def = {}
+        for line in data.split("\n"):
+            name, iid = line.split("|")
+            self.iids_def[name] = self.parse_iid(iid), iid
+
+        self.exports = set([])
+        self.imports = set([])
+
+        self.parse()
+        self.analyse(self.data)
+        self.check_dependances()
+
+    def parse(self):
+        if self.data is not None:
+            return self.data
+        data = []
+        for filename in glob.glob(self.indirname):
+            print("Parsing <{0}>".format(filename))
+            data.append(self.PARSER(open(filename).read()).parse())
+        self.data = data
+        return data
+
+    def analyse(self, data):
+        self.real_type = {}
+        # self.add_exports("IID")
+        # self.add_exports("GUID")
+        # self.add_exports("LPGUID")  # setup in InitialCOMGenerator.HEADER
+        # self.add_exports("REFGUID") # setup in InitialCOMGenerator.HEADER
+        self.add_exports("COMInterface")
+        self.add_exports("COMImplementation")
+        for cominterface in data:
+            #import pdb;pdb.set_trace()
+            self.add_exports(cominterface.name)
+            if cominterface.typedefptr:
+                self.add_exports(cominterface.typedefptr)
+        for cominterface in data:
+            for method in cominterface.methods:
+                self.add_imports(method.ret_type)
+                for pos, arg in enumerate(method.args):
+                    initial_arg = arg
+                    if arg.type in self.exports or arg.type in self.IGNORE_INTERFACE:
+                        # GUID type ?
+                        if arg.type in ["GUID", "REFGUID", "LPGUID", "IID"]:
+                            continue
+                        # COM Interface ? -> PVOID !
+                        atype = "PVOID"
+                        byreflevel = arg.byreflevel - 1
+                        method.args[pos] = arg = type(arg)(atype, byreflevel, arg.name)
+                        self.real_type[arg] = initial_arg
+
+                    elif arg.type == "void" and arg.byreflevel > 0:
+                        # **void -> *PVOID
+                        atype = "PVOID"
+                        byreflevel = arg.byreflevel - 1
+                        method.args[pos] = arg = type(arg)(atype, byreflevel, arg.name)
+                        self.real_type[arg] = initial_arg
+                    self.add_imports(arg.type)
+
+    com_interface_comment_template = """ #{0} -> {1}"""
+    com_interface_method_template = """ "{0}": ctypes.WINFUNCTYPE({1})({2}, "{0}"),"""
+    com_interface_template = dedent("""
+    class {0}(COMInterface):
+        IID = generate_IID({2}, name="{0}", strid="{3}")
+
+        _functions_ = {{
+    {1}
+        }}
+    """)
+
+    def generate(self):
+        define = []
+        for cominterface in self.data:
+            methods_string = []
+            for method_nb, method in enumerate(cominterface.methods):
+                args_to_define = method.args[1:] #ctypes doesnt not need the This
+                args_for_comment = [self.real_type.get(arg, arg) for arg in args_to_define]
+                #import pdb;pdb.set_trace()
+                str_args = []
+                methods_string.append(self.com_interface_comment_template.format(method.name, ", ".join([arg.name +":"+ ("*"* arg.byreflevel) +arg.type for arg in args_for_comment])))
+                for arg in args_to_define:
+                    type = arg.type
+                    for i in range(arg.byreflevel):
+                        type = "POINTER({0})".format(type)
+                    str_args.append(type)
+
+                methods_string.append(self.com_interface_method_template.format(method.name, ", ".join([method.ret_type] + str_args), method_nb))
+            #import pdb;pdb.set_trace()
+            if cominterface.iid is not None:
+                iid_str = cominterface.iid
+                iid_python = self.parse_iid(iid_str)
+            else:
+                print("Lookup of IID for <{0}>".format(cominterface.name))
+                iid_python, iid_str = self.iids_def[cominterface.name]
+            define.append((self.com_interface_template.format(cominterface.name, "\n".join(methods_string), iid_python, iid_str)))
+
+        deps = "\n".join(["from {0} import *".format(os.path.basename(dep.outfilename).rsplit(".")[0]) for dep in self.dependances])
+
+        ctypes_code =  self.generate_import() + "\n" + self.HEADER + "\n".join(define)
+        with open(self.outfilename, "w") as f:
+            f.write(ctypes_code)
+        print("<{0}> generated".format(self.outfilename))
+        return ctypes_code
+
+    def parse_iid(self, iid_str):
+        part_iid = iid_str.split("-")
+        str_iid = []
+        str_iid.append("0x" + part_iid[0])
+        str_iid.append("0x" + part_iid[1])
+        str_iid.append("0x" + part_iid[2])
+        str_iid.append("0x" + part_iid[3][:2])
+        str_iid.append("0x" + part_iid[3][2:])
+        for i in range(6): str_iid.append("0x" + part_iid[4][i * 2:(i + 1) * 2])
+        return ", ".join(str_iid)
+
+
+
+        com_interface_template = dedent("""
+    class {0}(COMInterface):
+        IID = generate_IID({2}, name="{0}", strid="{3}")
+
+        _functions_ = {{
+    {1}
+        }}
+    """)
+
+
+class COMGenerator(InitialCOMGenerator):
+    IMPORT_HEADER = "{deps}"
+    HEADER = ""
+
+class DefGenerator(InitialDefGenerator):
+    IMPORT_HEADER = "{deps}"
+    HEADER = ""
+
+class MetafileGenerator(object):
+    walker_generator = dedent("""
+    def generate_walker(namelist, target_module):
+        def my_walker():
+            for name in namelist:
+                yield name, getattr(target_module, name)
+        return my_walker
+    """)
+    def __init__(self, filename):
+        self.lol = {}
+        self.filename = filename
+
+    def add_exports(self, name, module, exports):
+        self.lol[(name, module)] = exports
+
+    def generate(self):
+        with open(self.filename, "w") as f:
+            # Generate lists
+            for (name, module), exports in self.lol.items():
+                f.write("{0} = {1}".format(name, exports))
+                # f.write(str(y))
+                f.write("\n")
+            f.write(self.walker_generator)
+            # Generate walkers
+            for (name, module) in self.lol:
+                f.write("import {0} as {0}_module\n".format(module))
+                f.write("{0}_walker = generate_walker({0}, {1}_module)\n".format(name, module))
+
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+print(SCRIPT_DIR)
+from_here = lambda path: pjoin(SCRIPT_DIR, path)
+
+
+EXTENDED_STRUCT_FILE = glob.glob(pjoin(SCRIPT_DIR, "extended_structs", "*.py"))
+EXTENDED_STRUCT = [os.path.basename(filename)[:-len(".py")] for filename in EXTENDED_STRUCT_FILE]
+
+DEFAULT_INTERFACE_TO_IID = from_here("definitions\\interface_to_iid.txt")
+
+# A partial define without the dependance to ntstatus defintion
+# BOOTSTRAP!!
+non_generated_def = InitialDefGenerator(from_here("definitions\\defines\\windef.txt"), from_here(r"..\windows\generated_def\\windef.py"))
+ntstatus = NtStatusGenerator(from_here("definitions\\ntstatus.txt"), from_here(r"..\windows\generated_def\\ntstatus.py"), dependances=[non_generated_def])
+# Not a real circular def (import not at the begin of file
+defs_with_ntstatus = InitialDefGenerator(from_here("definitions\\defines\\*.txt"), from_here(r"..\windows\generated_def\\windef.py"), dependances=[ntstatus])
+
+# YOLO HACK FOR NOW :DD
+# import pdb;pdb.set_trace()
+
+
+# for filename in [f for f in glob.glob(from_here("definitions\\defines\\*.txt")) if not f.endswith("\\windef.txt")]:
+    # defs_with_ntstatus.append_input_file(from_here("definitions\\wintrust_crypt_def.txt"))
+    # defs_with_ntstatus.append_input_file(from_here("definitions\\windef_error.txt"))
+    # defs_with_ntstatus.append_input_file(from_here("definitions\\custom_rpc_windef.txt"))
+    # defs_with_ntstatus.append_input_file(from_here("definitions\\windef_evtlog.txt"))
+    # defs_with_ntstatus.append_input_file(filename)
+
+
+structs = StructGenerator(from_here("definitions\\structures\\*.txt"), from_here(r"..\windows\generated_def\\winstructs.py"), dependances=[defs_with_ntstatus])
+
+# for filename in [f for f in glob.glob(from_here("definitions\\structures\\*.txt")) if not f.endswith("\\winstruct.txt")]:
+    # structs.append_input_file(filename)
+
+# structs.append_input_file(from_here("definitions\\winstruct_apisetmap.txt"))
+# structs.append_input_file(from_here("definitions\\display_struct.txt"))
+# structs.append_input_file(from_here("definitions\\winstruct_bits.txt"))
+# structs.append_input_file(from_here("definitions\\winstruct_alpc.txt"))
+# structs.append_input_file(from_here("definitions\\winstruct_evtlog.txt"))
+# structs.append_input_file(from_here("definitions\\winstruct_file_info.txt"))
+
+functions = FuncGenerator(from_here("definitions\\functions\\*.txt"), from_here(r"..\windows\generated_def\\winfuncs.py"), dependances=[structs])
+
+# for filename in [f for f in glob.glob(from_here("definitions\\functions\\*.txt")) if not f.endswith("\\winfunc.txt")]:
+    # functions.append_input_file(filename)
+
+# functions.append_input_file(from_here("definitions\\winfunc_crypto_wintrust.txt"))
+# functions.append_input_file(from_here("definitions\\winfunc_notdoc.txt"))
+# functions.append_input_file(from_here("definitions\\winfunc_evtlog.txt"))
+
+com = InitialCOMGenerator(from_here("definitions\\com\\*.txt"), DEFAULT_INTERFACE_TO_IID, from_here(r"..\windows\generated_def\\interfaces.py"), dependances=[structs, defs_with_ntstatus])
+
+# check for collision between ntstatus and defs_with_ntstatus
+
+# Check for multiple define in defs_with_ntstatus
+import collections
+
+all_defs_names = [x.name for x in defs_with_ntstatus.parse()]
+
+for name, nb in collections.Counter(all_defs_names).most_common():
+    if nb > 1:
+        print("Duplicated windef define: {0} ({1} defines)".format(name, nb))
+    if nb == 1:
+        break
+
+all_ntstatus_names = [x[1] for x in ntstatus.parse()]
+
+# Check for multiple define in ntstatus
+for name, nb in collections.Counter(all_ntstatus_names).most_common():
+    if nb > 1:
+        print("Duplicated ntstatus define: {0} ({1} defines)".format(name, nb))
+    if nb == 1:
+        break
+
+for collision_name in set(all_defs_names) & set(all_ntstatus_names):
+    print("Duplicated ntstatus + windef define: {0}".format(collision_name))
+
+meta = MetafileGenerator(from_here(r"..\windows\generated_def\\meta.py"))
+meta.add_exports("windef", module="windef", exports=defs_with_ntstatus.exports - set(["Flag", "NATIVE_WORD_MAX_VALUE"]))
+meta.add_exports("structs", module="winstructs", exports=structs.export_structs)
+meta.add_exports("enums", module="winstructs", exports=structs.export_enums)
+meta.add_exports("functions", module="winfuncs", exports=functions.exports)
+meta.add_exports("interfaces", module="interfaces", exports=com.exports)
+
+
+if __name__ == "__main__":
+    ntstatus.generate()
+    defs_with_ntstatus.generate()
+    structs.generate()
+    functions.generate()
+    com.generate()
+    print("Generating meta file")
+    meta.generate()
+    print("Generating documentation")
+    ntstatus.generate_doc(from_here(r"..\docs\source\ntstatus_generated.rst"))
+    defs_with_ntstatus.generate_doc(from_here(r"..\docs\source\windef_generated.rst"))
+    structs.generate_doc(from_here(r"..\docs\source\winstructs_generated.rst"))
+

ctypes_generation/simpleparser.py

@@ -1,4 +1,5 @@
 import collections
+import StringIO
 
 TupleToken = collections.namedtuple('Token', ['value'])
 
@@ -64,17 +65,20 @@ class SharpToken(NoValueToken):
 
 class EqualToken(NoValueToken):
     value = "="
-    pass
+
+class NewLineToken(NoValueToken):
+    value = "\n"
 
 class Lexer(object):
-    keywords = ["typedef", "struct", "enum", "union"]
+    keywords = ["typedef", "struct", "enum", "union", "const"]
 
     token_chr = {"*" : StarToken, "[" : OpenSquareBracketToken, "]" : CloseSquareBracketToken,
                     "{" : OpenBracketToken, "}" : CloseBracketToken, ";" : ColonToken,
                     "," : CommaToken, "(" : OpenParenthesisToken, ")" :  CloseParenthesisToken, "#" : SharpToken, "=" : EqualToken}
 
-    def __init__(self, code):
+    def __init__(self, code, newlinetoken=False):
         self.code = code
+        self.newlinetoken = newlinetoken
 
     def split_line(self, line):
         return line.strip().split()
@@ -105,6 +109,8 @@ class Lexer(object):
                     continue
                 for tok in self.split_word(word):
                     yield tok
+            if self.newlinetoken:
+                yield NewLineToken()
 
 
 
@@ -112,9 +118,8 @@ class ParsingError(Exception):
     pass
 
 class Parser(object):
-
     def __init__(self, data):
-        self.lexer = iter(Lexer(data))
+        self.lexer = iter(Lexer(self.initial_processing(data)))
         self.peek_token = None
 
     def assert_keyword(self, expected_keyword, n=None):
@@ -163,6 +168,54 @@ class Parser(object):
     def parse(self):
         raise NotImplementedError("Parser.parse()")
 
+    def initial_processing(self, data):
+        #  https://gcc.gnu.org/onlinedocs/cpp/Initial-processing.html#Initial-processing
+        # Step 1 -> use correct end of line + add last \n if not existing
+        data = data.replace("\r\n", "\n")
+        if not data.endswith("\n"):
+            data = data + "\n"
+        # Step 2: Trigraph : fuck it
+        pass
+        # Step 3: Line merge !
+        data = data.replace("\\\n", "")
+        # Step 4 Remove comments:
+
+        ins = StringIO.StringIO(data)
+        outs = StringIO.StringIO()
+
+        in_str = False
+        res = []
+        while ins.tell() != len(data):
+            c = ins.read(1)
+            if ins.tell() == len(data):
+                outs.write(c)
+                break
+            if not in_str and c == "/":
+                nc = ins.read(1)
+                if nc  == "/":
+                    while c != "\n":
+                        c = ins.read(1)
+                    outs.write(c)
+                    continue
+                elif nc == "*":
+                    while c != "*" or nc != "/":
+                        c = nc
+                        nc = ins.read(1)
+                        if not nc:
+                            raise ValueError("Unmatched */")
+                    outs.write(" ")
+                    continue
+                else:
+                    outs.write(c)
+                    ins.seek(ins.tell() - 1)
+                    continue
+            # TODO: escape in str
+            elif c == '"':
+                in_str = not in_str
+            outs.write(c)
+        outs.seek(0)
+        return outs.read()
+
 
 #KNOWN_TYPE = ["BYTE", "USHORT", "DWORD", "PVOID", "ULONG", "HANDLE", "PWSTR"]
 #

ctypes_generation/struct_parser.py

@@ -4,6 +4,9 @@ from winstruct import WinStruct, WinUnion, WinStructType, Ptr, WinEnum
 from simpleparser import *
 
 class WinStructParser(Parser):
+    def __init__(self, *args, **kwargs):
+        super(WinStructParser, self).__init__(*args, **kwargs)
+        self.pack = None
 
     def parse_array(self, ):
         self.assert_token_type(OpenSquareBracketToken)
@@ -14,7 +17,7 @@ class WinStructParser(Parser):
     def parse_def(self):
         if self.peek() == KeywordToken("struct"):
             discard = self.next_token()
-            
+
         def_type_tok  = self.assert_token_type(NameToken)
         def_type = WinStructType(def_type_tok.value)
         if type(self.peek()) == StarToken:
@@ -26,12 +29,15 @@ class WinStructParser(Parser):
         if type(self.peek()) == ColonToken:
             self.next_token()
             return (def_type, def_name, 1)
-        
+
         number_rep = self.parse_array()
         self.assert_token_type(ColonToken)
         return (def_type, def_name, number_rep)
 
     def parse_typedef(self, struct):
+        if type(self.peek()) == ColonToken: # Just a ; no typedef
+            self.next_token()
+            return
         sep = CommaToken()
         while type(sep) == CommaToken:
             add_to_typedef = struct.add_typedef
@@ -65,7 +71,7 @@ class WinStructParser(Parser):
             else:
                 if assigned_value:
                     raise ParsingError("Enum {0} mix def with and without equal".format(enum_name))
-                
+
             res_enum.add_enum_entry(i, name.value)
             if not type(self.peek()) == CloseBracketToken:
                 self.assert_token_type(CommaToken)
@@ -75,13 +81,17 @@ class WinStructParser(Parser):
         #other_name = self.assert_token_type(NameToken).value
         #res_enum.add_typedef(other_name)
         #self.assert_token_type(ColonToken)
-        return res_enum    
-        
-        
-        
+        return res_enum
+
+
+
     def parse_winstruct(self):
-        self.assert_keyword("typedef")
-        
+        is_typedef = False
+        peeked = self.peek()
+        if peeked == KeywordToken("typedef"):
+            self.assert_keyword("typedef")
+            is_typedef = True
+
         def_type = self.assert_token_type(KeywordToken)
         if def_type.value == "enum":
             return self.parse_enum()
@@ -93,21 +103,38 @@ class WinStructParser(Parser):
             raise ParsingError("Expecting union or struct got <{0}> instead".format(def_type.value))
         struct_name = self.assert_token_type(NameToken)
         self.assert_token_type(OpenBracketToken)
-    
-        result = WinDefType(struct_name.value)
+
+        result = WinDefType(struct_name.value, self.pack)
 
         while type(self.peek()) != CloseBracketToken:
             tok_type, tok_name, nb_rep = self.parse_def()
             result.add_field((tok_type, tok_name.value, nb_rep))
         self.assert_token_type(CloseBracketToken)
-        self.parse_typedef(result)
+        if is_typedef:
+            self.parse_typedef(result)
+        else:
+            self.assert_token_type(ColonToken)
         return result
 
     def parse(self):
         strucs = []
         enums = []
         while self.peek() is not None:
+            # HANDLE PRAGMA_PACK / PRAGMA_NOPACK
+            if type(self.peek()) == NameToken:
+                pragma = self.next_token().value
+                if pragma == "PRAGMA_NOPACK":
+                    self.pack = None
+                    continue
+                if pragma != "PRAGMA_PACK":
+                    raise ValueError("Expected struct/union def or PRAGMA_[NO]PACK")
+                pack_value = self.promote_to_int(self.next_token())
+                self.pack = pack_value
+
             x = self.parse_winstruct()
+            #x.packing = self.pack
+            #if x.packing != None:
+            #    print("{0} pack = {1}".format(x.name, x.packing))
             if type(x) == WinStruct or type(x) == WinUnion:
                 strucs.append(x)
             elif type(x) == WinEnum:
@@ -115,7 +142,33 @@ class WinStructParser(Parser):
             else:
                 raise ValueError("Unknow returned type {0}".format(x))
         return strucs, enums
-            
+
+class SimpleTypeDefine(object):
+    def __init__(self, lvalue,  rvalue):
+        self.lvalue = lvalue
+        self.rvalue = rvalue
+
+    def generate_ctypes(self):
+        return "{self.lvalue} = {self.rvalue}".format(self=self)
+
+class SimpleTypesParser(Parser):
+    def __init__(self, data):
+        self.lexer = iter(Lexer(self.initial_processing(data), newlinetoken=True))
+        self.peek_token = None
+
+    def parse(self):
+        results = []
+        while self.peek() is not None:
+            lvalue = self.assert_token_type(NameToken).value
+            self.assert_token_type(EqualToken)
+            rvalue = ""
+            while type(self.peek()) is not NewLineToken:
+                rvalue += self.next_token().value
+            results.append(SimpleTypeDefine(lvalue, rvalue))
+            while type(self.peek()) is NewLineToken: # discard the NewLineToken(s)
+                self.next_token()
+        return results
+
 def dbg_lexer(data):
     for i in Lexer(data).token_generation():
         print i
@@ -125,9 +178,9 @@ def dbg_parser(data):
 
 def dbg_validate(data):
     return validate_structs(Parser(data).parse())
-    
-       
+
+
 if __name__ == "__main__":
     import sys
-    data = open(sys.argv[1], 'r').read()
-    ctypes_code = generate_ctypes(data)
+    #data = open(sys.argv[1], 'r').read()
+    #ctypes_code = generate_ctypes(data)

ctypes_generation/windef.txt

@@ -1,558 +0,0 @@
-#define NULL    0
-#define MAX_PATH          260
-#define ANYSIZE_ARRAY 1
-#define ANY_SIZE 1
-#define IMAGE_SIZEOF_SHORT_NAME 8
-#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES    16
-#define INFINITE            0xFFFFFFFF
-
-#define STD_INPUT_HANDLE  -10
-#define STD_OUTPUT_HANDLE -11
-#define STD_ERROR_HANDLE -12
-
-#define WARMING_NOT_SAME_FLAG_FOR_WINXP 0
-#define PROCESS_ALL_ACCESS  0x001F0FFF
-#define THREAD_ALL_ACCESS  0x001F03FF
-
-
-#define STARTF_USESHOWWINDOW    0x00000001
-#define STARTF_USESIZE          0x00000002
-#define STARTF_USEPOSITION      0x00000004
-#define STARTF_USECOUNTCHARS    0x00000008
-#define STARTF_USEFILLATTRIBUTE 0x00000010
-#define STARTF_RUNFULLSCREEN    0x00000020
-#define STARTF_FORCEONFEEDBACK  0x00000040
-#define STARTF_FORCEOFFFEEDBACK 0x00000080
-#define STARTF_USESTDHANDLES    0x00000100
-
-#define SW_HIDE             0
-#define SW_SHOWNORMAL       1
-#define SW_NORMAL           1
-#define SW_SHOWMINIMIZED    2
-#define SW_SHOWMAXIMIZED    3
-#define SW_MAXIMIZE         3
-#define SW_SHOWNOACTIVATE   4
-#define SW_SHOW             5
-#define SW_MINIMIZE         6
-#define SW_SHOWMINNOACTIVE  7
-#define SW_SHOWNA           8
-#define SW_RESTORE          9
-#define SW_SHOWDEFAULT      10
-#define SW_FORCEMINIMIZE    11
-#define SW_MAX              11
-
-
-#define DEBUG_PROCESS                     0x00000001
-#define DEBUG_ONLY_THIS_PROCESS           0x00000002
-#define CREATE_SUSPENDED                  0x00000004
-#define DETACHED_PROCESS                  0x00000008
-
-#define CREATE_NEW_CONSOLE                0x00000010
-#define NORMAL_PRIORITY_CLASS             0x00000020
-#define IDLE_PRIORITY_CLASS               0x00000040
-#define HIGH_PRIORITY_CLASS               0x00000080
-
-#define REALTIME_PRIORITY_CLASS           0x00000100
-#define CREATE_NEW_PROCESS_GROUP          0x00000200
-#define CREATE_UNICODE_ENVIRONMENT        0x00000400
-#define CREATE_SEPARATE_WOW_VDM           0x00000800
-
-#define CREATE_SHARED_WOW_VDM             0x00001000
-#define CREATE_FORCEDOS                   0x00002000
-#define BELOW_NORMAL_PRIORITY_CLASS       0x00004000
-#define ABOVE_NORMAL_PRIORITY_CLASS       0x00008000
-
-#define INHERIT_PARENT_AFFINITY           0x00010000
-#define INHERIT_CALLER_PRIORITY           0x00020000
-#define CREATE_PROTECTED_PROCESS          0x00040000
-#define EXTENDED_STARTUPINFO_PRESENT      0x00080000
-
-#define PROCESS_MODE_BACKGROUND_BEGIN     0x00100000
-#define PROCESS_MODE_BACKGROUND_END       0x00200000
-
-#define CREATE_BREAKAWAY_FROM_JOB         0x01000000
-#define CREATE_PRESERVE_CODE_AUTHZ_LEVEL  0x02000000
-#define CREATE_DEFAULT_ERROR_MODE         0x04000000
-#define CREATE_NO_WINDOW                  0x08000000
-
-#define PROFILE_USER                      0x10000000
-#define PROFILE_KERNEL                    0x20000000
-#define PROFILE_SERVER                    0x40000000
-#define CREATE_IGNORE_SYSTEM_DEFAULT      0x80000000
-
-
-#define STATUS_WAIT_0                    (0x00000000L)
-#define STATUS_ABANDONED_WAIT_0          (0x00000080L)
-#define STATUS_USER_APC                  (0x000000C0L)
-#define STATUS_TIMEOUT                   (0x00000102L)
-#define STATUS_PENDING                   (0x00000103L)
-#define DBG_EXCEPTION_HANDLED            (0x00010001L)
-#define DBG_CONTINUE                     (0x00010002L)
-#define STATUS_SEGMENT_NOTIFICATION      (0x40000005L)
-#define DBG_TERMINATE_THREAD             (0x40010003L)
-#define DBG_TERMINATE_PROCESS            (0x40010004L)
-#define DBG_CONTROL_C                    (0x40010005L)
-#define DBG_PRINTEXCEPTION_C             (0x40010006L)
-#define DBG_RIPEXCEPTION                 (0x40010007L)
-#define DBG_CONTROL_BREAK                (0x40010008L)
-#define DBG_COMMAND_EXCEPTION            (0x40010009L)
-#define STATUS_GUARD_PAGE_VIOLATION      (0x80000001L)
-#define STATUS_DATATYPE_MISALIGNMENT     (0x80000002L)
-#define STATUS_BREAKPOINT                (0x80000003L)
-#define STATUS_SINGLE_STEP               (0x80000004L)
-#define STATUS_LONGJUMP                  (0x80000026L)
-#define STATUS_UNWIND_CONSOLIDATE        (0x80000029L)
-#define DBG_EXCEPTION_NOT_HANDLED        (0x80010001L)
-#define STATUS_ACCESS_VIOLATION          (0xC0000005L)
-#define STATUS_IN_PAGE_ERROR             (0xC0000006L)
-#define STATUS_INVALID_HANDLE            (0xC0000008L)
-#define STATUS_INVALID_PARAMETER         (0xC000000DL)
-#define STATUS_NO_MEMORY                 (0xC0000017L)
-#define STATUS_ILLEGAL_INSTRUCTION       (0xC000001DL)
-#define STATUS_NONCONTINUABLE_EXCEPTION  (0xC0000025L)
-#define STATUS_INVALID_DISPOSITION       (0xC0000026L)
-#define STATUS_ARRAY_BOUNDS_EXCEEDED     (0xC000008CL)
-#define STATUS_FLOAT_DENORMAL_OPERAND    (0xC000008DL)
-#define STATUS_FLOAT_DIVIDE_BY_ZERO      (0xC000008EL)
-#define STATUS_FLOAT_INEXACT_RESULT      (0xC000008FL)
-#define STATUS_FLOAT_INVALID_OPERATION   (0xC0000090L)
-#define STATUS_FLOAT_OVERFLOW            (0xC0000091L)
-#define STATUS_FLOAT_STACK_CHECK         (0xC0000092L)
-#define STATUS_FLOAT_UNDERFLOW           (0xC0000093L)
-#define STATUS_INTEGER_DIVIDE_BY_ZERO    (0xC0000094L)
-#define STATUS_INTEGER_OVERFLOW          (0xC0000095L)
-#define STATUS_PRIVILEGED_INSTRUCTION    (0xC0000096L)
-#define STATUS_STACK_OVERFLOW            (0xC00000FDL)
-#define STATUS_DLL_NOT_FOUND             (0xC0000135L)
-#define STATUS_ORDINAL_NOT_FOUND         (0xC0000138L)
-#define STATUS_ENTRYPOINT_NOT_FOUND      (0xC0000139L)
-#define STATUS_CONTROL_C_EXIT            (0xC000013AL)
-#define STATUS_DLL_INIT_FAILED           (0xC0000142L)
-#define STATUS_FLOAT_MULTIPLE_FAULTS     (0xC00002B4L)
-#define STATUS_FLOAT_MULTIPLE_TRAPS      (0xC00002B5L)
-#define STATUS_REG_NAT_CONSUMPTION       (0xC00002C9L)
-#define STATUS_STACK_BUFFER_OVERRUN      (0xC0000409L)
-#define STATUS_INVALID_CRUNTIME_PARAMETER (0xC0000417L)
-#define STATUS_ASSERTION_FAILURE         (0xC0000420L)
-#define STATUS_POSSIBLE_DEADLOCK        (0xC0000194)
-
-
-#define WAIT_IO_COMPLETION                  STATUS_USER_APC
-#define STILL_ACTIVE                        STATUS_PENDING
-#define EXCEPTION_ACCESS_VIOLATION          STATUS_ACCESS_VIOLATION
-#define EXCEPTION_DATATYPE_MISALIGNMENT     STATUS_DATATYPE_MISALIGNMENT
-#define EXCEPTION_BREAKPOINT                STATUS_BREAKPOINT
-#define EXCEPTION_SINGLE_STEP               STATUS_SINGLE_STEP
-#define EXCEPTION_ARRAY_BOUNDS_EXCEEDED     STATUS_ARRAY_BOUNDS_EXCEEDED
-#define EXCEPTION_FLT_DENORMAL_OPERAND      STATUS_FLOAT_DENORMAL_OPERAND
-#define EXCEPTION_FLT_DIVIDE_BY_ZERO        STATUS_FLOAT_DIVIDE_BY_ZERO
-#define EXCEPTION_FLT_INEXACT_RESULT        STATUS_FLOAT_INEXACT_RESULT
-#define EXCEPTION_FLT_INVALID_OPERATION     STATUS_FLOAT_INVALID_OPERATION
-#define EXCEPTION_FLT_OVERFLOW              STATUS_FLOAT_OVERFLOW
-#define EXCEPTION_FLT_STACK_CHECK           STATUS_FLOAT_STACK_CHECK
-#define EXCEPTION_FLT_UNDERFLOW             STATUS_FLOAT_UNDERFLOW
-#define EXCEPTION_INT_DIVIDE_BY_ZERO        STATUS_INTEGER_DIVIDE_BY_ZERO
-#define EXCEPTION_INT_OVERFLOW              STATUS_INTEGER_OVERFLOW
-#define EXCEPTION_PRIV_INSTRUCTION          STATUS_PRIVILEGED_INSTRUCTION
-#define EXCEPTION_IN_PAGE_ERROR             STATUS_IN_PAGE_ERROR
-#define EXCEPTION_ILLEGAL_INSTRUCTION       STATUS_ILLEGAL_INSTRUCTION
-#define EXCEPTION_NONCONTINUABLE_EXCEPTION  STATUS_NONCONTINUABLE_EXCEPTION
-#define EXCEPTION_STACK_OVERFLOW            STATUS_STACK_OVERFLOW
-#define EXCEPTION_INVALID_DISPOSITION       STATUS_INVALID_DISPOSITION
-#define EXCEPTION_GUARD_PAGE                STATUS_GUARD_PAGE_VIOLATION
-#define EXCEPTION_INVALID_HANDLE            STATUS_INVALID_HANDLE
-#define EXCEPTION_POSSIBLE_DEADLOCK         STATUS_POSSIBLE_DEADLOCK
-#define CONTROL_C_EXIT                      STATUS_CONTROL_C_EXIT
-
-#define EXCEPTION_DEBUG_EVENT       1
-#define CREATE_THREAD_DEBUG_EVENT   2
-#define CREATE_PROCESS_DEBUG_EVENT  3
-#define EXIT_THREAD_DEBUG_EVENT     4
-#define EXIT_PROCESS_DEBUG_EVENT    5
-#define LOAD_DLL_DEBUG_EVENT        6
-#define UNLOAD_DLL_DEBUG_EVENT      7
-#define OUTPUT_DEBUG_STRING_EVENT   8
-#define RIP_EVENT                   9
-
-
-#define TH32CS_SNAPHEAPLIST 0x00000001
-#define TH32CS_SNAPPROCESS  0x00000002
-#define TH32CS_SNAPTHREAD   0x00000004
-#define TH32CS_SNAPMODULE   0x00000008
-#define TH32CS_SNAPMODULE32 0x00000010
-#define TH32CS_SNAPALL      (TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE)
-#define TH32CS_INHERIT      0x80000000
-
-#define CONTEXT_I386    0x00010000
-
-#define CONTEXT_CONTROL             0x00000001L
-#define CONTEXT_INTEGER             0x00000002L
-#define CONTEXT_SEGMENTS            0x00000004L
-#define CONTEXT_FLOATING_POINT      0x00000008L
-#define CONTEXT_DEBUG_REGISTERS     0x00000010L
-#define CONTEXT_EXTENDED_REGISTERS  0x00000020L
-#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS)
-#define CONTEXT_ALL (CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS | CONTEXT_EXTENDED_REGISTERS)
-
-#define CONTEXT_FULL CONTEXT_I386 | CONTEXT_FULL
-#define CONTEXT_ALL  CONTEXT_I386 | CONTEXT_ALL
-
-
-#define PAGE_NOACCESS          0x01
-#define PAGE_READONLY          0x02
-#define PAGE_READWRITE         0x04
-#define PAGE_WRITECOPY         0x08
-#define PAGE_EXECUTE           0x10
-#define PAGE_EXECUTE_READ      0x20
-#define PAGE_EXECUTE_READWRITE 0x40
-#define PAGE_EXECUTE_WRITECOPY 0x80
-#define PAGE_GUARD            0x100
-#define PAGE_NOCACHE          0x200
-#define PAGE_WRITECOMBINE     0x400
-#define MEM_COMMIT           0x1000
-#define MEM_RESERVE          0x2000
-#define MEM_DECOMMIT         0x4000
-#define MEM_RELEASE          0x8000
-#define MEM_FREE            0x10000
-#define MEM_PRIVATE         0x20000
-#define MEM_MAPPED          0x40000
-#define MEM_RESET           0x80000
-#define MEM_TOP_DOWN       0x100000
-#define MEM_WRITE_WATCH    0x200000
-#define MEM_PHYSICAL       0x400000
-#define MEM_ROTATE         0x800000
-#define MEM_LARGE_PAGES  0x20000000
-#define MEM_4MB_PAGES    0x80000000
-
-#define SEC_FILE           0x800000
-#define SEC_IMAGE         0x1000000
-#define SEC_PROTECTED_IMAGE  0x2000000
-#define SEC_RESERVE       0x4000000
-#define SEC_COMMIT        0x8000000
-#define SEC_NOCACHE      0x10000000
-#define SEC_WRITECOMBINE 0x40000000
-#define SEC_LARGE_PAGES  0x80000000
-#define MEM_IMAGE         SEC_IMAGE
-#define WRITE_WATCH_FLAG_RESET 0x01
-
-#define DELETE                           (0x00010000L)
-#define READ_CONTROL                     (0x00020000L)
-#define WRITE_DAC                        (0x00040000L)
-#define WRITE_OWNER                      (0x00080000L)
-#define SYNCHRONIZE                      (0x00100000L)
-#define STANDARD_RIGHTS_REQUIRED         (0x000F0000L)
-#define STANDARD_RIGHTS_READ             (READ_CONTROL)
-#define STANDARD_RIGHTS_WRITE            (READ_CONTROL)
-#define STANDARD_RIGHTS_EXECUTE          (READ_CONTROL)
-
-#define STANDARD_RIGHTS_ALL              (0x001F0000L)
-
-#define SPECIFIC_RIGHTS_ALL              (0x0000FFFFL)
-
-#define TOKEN_ASSIGN_PRIMARY    (0x0001)
-#define TOKEN_DUPLICATE         (0x0002)
-#define TOKEN_IMPERSONATE       (0x0004)
-#define TOKEN_QUERY             (0x0008)
-#define TOKEN_QUERY_SOURCE      (0x0010)
-#define TOKEN_ADJUST_PRIVILEGES (0x0020)
-#define TOKEN_ADJUST_GROUPS     (0x0040)
-#define TOKEN_ADJUST_DEFAULT    (0x0080)
-#define TOKEN_ADJUST_SESSIONID  (0x0100)
-
-#define TOKEN_ALL_ACCESS_P (STANDARD_RIGHTS_REQUIRED | TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE | TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_QUERY_SOURCE | TOKEN_ADJUST_PRIVILEGES | TOKEN_ADJUST_GROUPS | TOKEN_ADJUST_DEFAULT)
-
-
-#define TOKEN_ALL_ACCESS  (TOKEN_ALL_ACCESS_P | TOKEN_ADJUST_SESSIONID )
-
-#define SE_PRIVILEGE_ENABLED_BY_DEFAULT (0x00000001L)
-#define SE_PRIVILEGE_ENABLED            (0x00000002L)
-#define SE_PRIVILEGE_REMOVED            (0X00000004L)
-#define SE_PRIVILEGE_USED_FOR_ACCESS    (0x80000000L)
-
-
-#define AF_UNSPEC       0
-#define AF_UNIX         1
-#define AF_INET         2
-#define AF_IMPLINK      3
-#define AF_PUP          4
-#define AF_CHAOS        5
-#define AF_NS           6
-#define AF_IPX          AF_NS
-#define AF_ISO          7
-#define AF_OSI          AF_ISO
-#define AF_ECMA         8
-#define AF_DATAKIT      9
-#define AF_CCITT        10
-#define AF_SNA          11
-#define AF_DECnet       12
-#define AF_DLI          13
-#define AF_LAT          14
-#define AF_HYLINK       15
-#define AF_APPLETALK    16
-#define AF_NETBIOS      17
-#define AF_VOICEVIEW    18
-#define AF_FIREFOX      19
-#define AF_UNKNOWN1     20
-#define AF_BAN          21
-#define AF_ATM          22
-#define AF_INET6        23
-#define AF_CLUSTER      24
-#define AF_12844        25
-#define AF_IRDA         26
-#define AF_NETDES       28
-
-
-#define EXCEPTION_NONCONTINUABLE 0x1
-#define EXCEPTION_MAXIMUM_PARAMETERS 15
-
-
-#define STATUS_WAIT_0                    (0x00000000)
-#define STATUS_ABANDONED_WAIT_0          (0x00000080)
-#define STATUS_USER_APC                  (0x000000C0)
-#define STATUS_TIMEOUT                   (0x00000102)
-#define STATUS_PENDING                   (0x00000103)
-#define DBG_EXCEPTION_HANDLED            (0x00010001)
-#define DBG_CONTINUE                     (0x00010002)
-#define STATUS_SEGMENT_NOTIFICATION      (0x40000005)
-#define DBG_TERMINATE_THREAD             (0x40010003)
-#define DBG_TERMINATE_PROCESS            (0x40010004)
-#define DBG_CONTROL_C                    (0x40010005)
-#define DBG_PRINTEXCEPTION_C             (0x40010006)
-#define DBG_RIPEXCEPTION                 (0x40010007)
-#define DBG_CONTROL_BREAK                (0x40010008)
-#define DBG_COMMAND_EXCEPTION            (0x40010009)
-#define STATUS_GUARD_PAGE_VIOLATION      (0x80000001)
-#define STATUS_DATATYPE_MISALIGNMENT     (0x80000002)
-#define STATUS_BREAKPOINT                (0x80000003)
-#define STATUS_SINGLE_STEP               (0x80000004)
-#define STATUS_LONGJUMP                  (0x80000026)
-#define STATUS_UNWIND_CONSOLIDATE        (0x80000029)
-#define DBG_EXCEPTION_NOT_HANDLED        (0x80010001)
-#define STATUS_ACCESS_VIOLATION          (0xC0000005)
-#define STATUS_IN_PAGE_ERROR             (0xC0000006)
-#define STATUS_INVALID_HANDLE            (0xC0000008)
-#define STATUS_INVALID_PARAMETER         (0xC000000D)
-#define STATUS_NO_MEMORY                 (0xC0000017)
-#define STATUS_ILLEGAL_INSTRUCTION       (0xC000001D)
-#define STATUS_NONCONTINUABLE_EXCEPTION  (0xC0000025)
-#define STATUS_INVALID_DISPOSITION       (0xC0000026)
-#define STATUS_ARRAY_BOUNDS_EXCEEDED     (0xC000008C)
-#define STATUS_FLOAT_DENORMAL_OPERAND    (0xC000008D)
-#define STATUS_FLOAT_DIVIDE_BY_ZERO      (0xC000008E)
-#define STATUS_FLOAT_INEXACT_RESULT      (0xC000008F)
-#define STATUS_FLOAT_INVALID_OPERATION   (0xC0000090)
-#define STATUS_FLOAT_OVERFLOW            (0xC0000091)
-#define STATUS_FLOAT_STACK_CHECK         (0xC0000092)
-#define STATUS_FLOAT_UNDERFLOW           (0xC0000093)
-#define STATUS_INTEGER_DIVIDE_BY_ZERO    (0xC0000094)
-#define STATUS_INTEGER_OVERFLOW          (0xC0000095)
-#define STATUS_PRIVILEGED_INSTRUCTION    (0xC0000096)
-#define STATUS_STACK_OVERFLOW            (0xC00000FD)
-#define STATUS_DLL_NOT_FOUND             (0xC0000135)
-#define STATUS_ORDINAL_NOT_FOUND         (0xC0000138)
-#define STATUS_ENTRYPOINT_NOT_FOUND      (0xC0000139)
-#define STATUS_CONTROL_C_EXIT            (0xC000013A)
-#define STATUS_DLL_INIT_FAILED           (0xC0000142)
-#define STATUS_FLOAT_MULTIPLE_FAULTS     (0xC00002B4)
-#define STATUS_FLOAT_MULTIPLE_TRAPS      (0xC00002B5)
-#define STATUS_REG_NAT_CONSUMPTION       (0xC00002C9)
-#define STATUS_STACK_BUFFER_OVERRUN      (0xC0000409)
-#define STATUS_INVALID_CRUNTIME_PARAMETER (0xC0000417)
-#define STATUS_ASSERTION_FAILURE         (0xC0000420)
-
-
-#define WAIT_IO_COMPLETION                  STATUS_USER_APC
-#define STILL_ACTIVE                        STATUS_PENDING
-#define EXCEPTION_ACCESS_VIOLATION          STATUS_ACCESS_VIOLATION
-#define EXCEPTION_DATATYPE_MISALIGNMENT     STATUS_DATATYPE_MISALIGNMENT
-#define EXCEPTION_BREAKPOINT                STATUS_BREAKPOINT
-#define EXCEPTION_SINGLE_STEP               STATUS_SINGLE_STEP
-#define EXCEPTION_ARRAY_BOUNDS_EXCEEDED     STATUS_ARRAY_BOUNDS_EXCEEDED
-#define EXCEPTION_FLT_DENORMAL_OPERAND      STATUS_FLOAT_DENORMAL_OPERAND
-#define EXCEPTION_FLT_DIVIDE_BY_ZERO        STATUS_FLOAT_DIVIDE_BY_ZERO
-#define EXCEPTION_FLT_INEXACT_RESULT        STATUS_FLOAT_INEXACT_RESULT
-#define EXCEPTION_FLT_INVALID_OPERATION     STATUS_FLOAT_INVALID_OPERATION
-#define EXCEPTION_FLT_OVERFLOW              STATUS_FLOAT_OVERFLOW
-#define EXCEPTION_FLT_STACK_CHECK           STATUS_FLOAT_STACK_CHECK
-#define EXCEPTION_FLT_UNDERFLOW             STATUS_FLOAT_UNDERFLOW
-#define EXCEPTION_INT_DIVIDE_BY_ZERO        STATUS_INTEGER_DIVIDE_BY_ZERO
-#define EXCEPTION_INT_OVERFLOW              STATUS_INTEGER_OVERFLOW
-#define EXCEPTION_PRIV_INSTRUCTION          STATUS_PRIVILEGED_INSTRUCTION
-#define EXCEPTION_IN_PAGE_ERROR             STATUS_IN_PAGE_ERROR
-#define EXCEPTION_ILLEGAL_INSTRUCTION       STATUS_ILLEGAL_INSTRUCTION
-#define EXCEPTION_NONCONTINUABLE_EXCEPTION  STATUS_NONCONTINUABLE_EXCEPTION
-#define EXCEPTION_STACK_OVERFLOW            STATUS_STACK_OVERFLOW
-#define EXCEPTION_INVALID_DISPOSITION       STATUS_INVALID_DISPOSITION
-#define EXCEPTION_GUARD_PAGE                STATUS_GUARD_PAGE_VIOLATION
-#define EXCEPTION_INVALID_HANDLE            STATUS_INVALID_HANDLE
-#define EXCEPTION_POSSIBLE_DEADLOCK         STATUS_POSSIBLE_DEADLOCK
-#define CONTROL_C_EXIT                      STATUS_CONTROL_C_EXIT
-
-
-#define EXCEPTION_EXECUTE_HANDLER       1
-#define EXCEPTION_CONTINUE_SEARCH       0
-#define EXCEPTION_CONTINUE_EXECUTION    -1
-
-
-#define GENERIC_READ                     (0x80000000)
-#define GENERIC_WRITE                    (0x40000000)
-#define GENERIC_EXECUTE                  (0x20000000)
-#define GENERIC_ALL                      (0x10000000)
-
-#define FILE_FLAG_WRITE_THROUGH         0x80000000
-#define FILE_FLAG_OVERLAPPED            0x40000000
-#define FILE_FLAG_NO_BUFFERING          0x20000000
-#define FILE_FLAG_RANDOM_ACCESS         0x10000000
-#define FILE_FLAG_SEQUENTIAL_SCAN       0x08000000
-#define FILE_FLAG_DELETE_ON_CLOSE       0x04000000
-#define FILE_FLAG_BACKUP_SEMANTICS      0x02000000
-#define FILE_FLAG_POSIX_SEMANTICS       0x01000000
-#define FILE_FLAG_OPEN_REPARSE_POINT    0x00200000
-#define FILE_FLAG_OPEN_NO_RECALL        0x00100000
-#define FILE_FLAG_FIRST_PIPE_INSTANCE   0x00080000
-
-#define CREATE_NEW          1
-#define CREATE_ALWAYS       2
-#define OPEN_EXISTING       3
-#define OPEN_ALWAYS         4
-#define TRUNCATE_EXISTING   5
-
-
-#define FILE_SHARE_READ                 0x00000001
-#define FILE_SHARE_WRITE                0x00000002
-#define FILE_SHARE_DELETE               0x00000004
-#define FILE_ATTRIBUTE_READONLY             0x00000001
-#define FILE_ATTRIBUTE_HIDDEN               0x00000002
-#define FILE_ATTRIBUTE_SYSTEM               0x00000004
-#define FILE_ATTRIBUTE_DIRECTORY            0x00000010
-#define FILE_ATTRIBUTE_ARCHIVE              0x00000020
-#define FILE_ATTRIBUTE_DEVICE               0x00000040
-#define FILE_ATTRIBUTE_NORMAL               0x00000080
-#define FILE_ATTRIBUTE_TEMPORARY            0x00000100
-#define FILE_ATTRIBUTE_SPARSE_FILE          0x00000200
-#define FILE_ATTRIBUTE_REPARSE_POINT        0x00000400
-#define FILE_ATTRIBUTE_COMPRESSED           0x00000800
-#define FILE_ATTRIBUTE_OFFLINE              0x00001000
-#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED  0x00002000
-#define FILE_ATTRIBUTE_ENCRYPTED            0x00004000
-#define FILE_ATTRIBUTE_VIRTUAL              0x00010000
-#define FILE_NOTIFY_CHANGE_FILE_NAME    0x00000001
-#define FILE_NOTIFY_CHANGE_DIR_NAME     0x00000002
-#define FILE_NOTIFY_CHANGE_ATTRIBUTES   0x00000004
-#define FILE_NOTIFY_CHANGE_SIZE         0x00000008
-#define FILE_NOTIFY_CHANGE_LAST_WRITE   0x00000010
-#define FILE_NOTIFY_CHANGE_LAST_ACCESS  0x00000020
-#define FILE_NOTIFY_CHANGE_CREATION     0x00000040
-#define FILE_NOTIFY_CHANGE_SECURITY     0x00000100
-#define FILE_ACTION_ADDED                   0x00000001
-#define FILE_ACTION_REMOVED                 0x00000002
-#define FILE_ACTION_MODIFIED                0x00000003
-#define FILE_ACTION_RENAMED_OLD_NAME        0x00000004
-#define FILE_ACTION_RENAMED_NEW_NAME        0x00000005
-#define MAILSLOT_NO_MESSAGE             (-1)
-#define MAILSLOT_WAIT_FOREVER           (-1)
-#define FILE_CASE_SENSITIVE_SEARCH          0x00000001
-#define FILE_CASE_PRESERVED_NAMES           0x00000002
-#define FILE_UNICODE_ON_DISK                0x00000004
-#define FILE_PERSISTENT_ACLS                0x00000008
-#define FILE_FILE_COMPRESSION               0x00000010
-#define FILE_VOLUME_QUOTAS                  0x00000020
-#define FILE_SUPPORTS_SPARSE_FILES          0x00000040
-#define FILE_SUPPORTS_REPARSE_POINTS        0x00000080
-#define FILE_SUPPORTS_REMOTE_STORAGE        0x00000100
-#define FILE_VOLUME_IS_COMPRESSED           0x00008000
-#define FILE_SUPPORTS_OBJECT_IDS            0x00010000
-#define FILE_SUPPORTS_ENCRYPTION            0x00020000
-#define FILE_NAMED_STREAMS                  0x00040000
-#define FILE_READ_ONLY_VOLUME               0x00080000
-#define FILE_SEQUENTIAL_WRITE_ONCE          0x00100000
-#define FILE_SUPPORTS_TRANSACTIONS          0x00200000
-#define FILE_SUPPORTS_HARD_LINKS            0x00400000
-#define FILE_SUPPORTS_EXTENDED_ATTRIBUTES   0x00800000
-#define FILE_SUPPORTS_OPEN_BY_FILE_ID       0x01000000
-#define FILE_SUPPORTS_USN_JOURNAL           0x02000000
-
-
-#define HKEY_CLASSES_ROOT                   (0x80000000)
-#define HKEY_CURRENT_USER                   (0x80000001)
-#define HKEY_LOCAL_MACHINE                  (0x80000002)
-#define HKEY_USERS                          (0x80000003)
-#define HKEY_PERFORMANCE_DATA               (0x80000004)
-#define HKEY_PERFORMANCE_TEXT               (0x80000050)
-#define HKEY_PERFORMANCE_NLSTEXT            (0x80000060)
-
-
-#define RRF_RT_REG_NONE        0x00000001
-#define RRF_RT_REG_SZ          0x00000002
-#define RRF_RT_REG_EXPAND_SZ   0x00000004
-#define RRF_RT_REG_BINARY      0x00000008
-#define RRF_RT_REG_DWORD       0x00000010
-#define RRF_RT_REG_MULTI_SZ    0x00000020
-#define RRF_RT_REG_QWORD       0x00000040
-#define RRF_RT_DWORD           (RRF_RT_REG_BINARY | RRF_RT_REG_DWORD)
-#define RRF_RT_QWORD           (RRF_RT_REG_BINARY | RRF_RT_REG_QWORD)
-#define RRF_RT_ANY             0x0000ffff
-#define RRF_NOEXPAND           0x10000000
-#define RRF_ZEROONFAILURE      0x20000000
-
-
-#define KEY_QUERY_VALUE         (0x0001)
-#define KEY_SET_VALUE           (0x0002)
-#define KEY_CREATE_SUB_KEY      (0x0004)
-#define KEY_ENUMERATE_SUB_KEYS  (0x0008)
-#define KEY_NOTIFY              (0x0010)
-#define KEY_CREATE_LINK         (0x0020)
-#define KEY_WOW64_32KEY         (0x0200)
-#define KEY_WOW64_64KEY         (0x0100)
-#define KEY_WOW64_RES           (0x0300)
-
-
-#define KEY_READ                ((STANDARD_RIGHTS_READ|KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS|KEY_NOTIFY)&(~SYNCHRONIZE))
-#define KEY_WRITE               ((STANDARD_RIGHTS_WRITE|KEY_SET_VALUE|KEY_CREATE_SUB_KEY)&(~SYNCHRONIZE))
-#define KEY_EXECUTE             ((KEY_READ)&(~SYNCHRONIZE))
-#define KEY_ALL_ACCESS          ((STANDARD_RIGHTS_ALL|KEY_QUERY_VALUE|KEY_SET_VALUE|KEY_CREATE_SUB_KEY|KEY_ENUMERATE_SUB_KEYS|KEY_NOTIFY|KEY_CREATE_LINK)&(~SYNCHRONIZE))
-
-#define STATUS_INFO_LENGTH_MISMATCH      (0xC0000004L)
-
-#define ERROR_NOT_ALL_ASSIGNED           1300
-
-
-#define S_OK                     0
-#define S_FALSE                  1
-#define E_NOINTERFACE            0x80004002
-#define E_FAIL                   0x80004005
-
-
-#define DEBUG_EVENT_BREAKPOINT              0x00000001
-#define DEBUG_EVENT_EXCEPTION               0x00000002
-#define DEBUG_EVENT_CREATE_THREAD           0x00000004
-#define DEBUG_EVENT_EXIT_THREAD             0x00000008
-#define DEBUG_EVENT_CREATE_PROCESS          0x00000010
-#define DEBUG_EVENT_EXIT_PROCESS            0x00000020
-#define DEBUG_EVENT_LOAD_MODULE             0x00000040
-#define DEBUG_EVENT_UNLOAD_MODULE           0x00000080
-#define DEBUG_EVENT_SYSTEM_ERROR            0x00000100
-#define DEBUG_EVENT_SESSION_STATUS          0x00000200
-#define DEBUG_EVENT_CHANGE_DEBUGGEE_STATE   0x00000400
-#define DEBUG_EVENT_CHANGE_ENGINE_STATE     0x00000800
-#define DEBUG_EVENT_CHANGE_SYMBOL_STATE     0x00001000
-
-#define WOW64_MAXIMUM_SUPPORTED_EXTENSION     512
-#define WOW64_SIZE_OF_80387_REGISTERS      80
-
-
-#define REG_NONE                    ( 0 )
-#define REG_SZ                      ( 1 )
-#define REG_EXPAND_SZ               ( 2 )
-
-#define REG_BINARY                  ( 3 )
-#define REG_DWORD                   ( 4 )
-#define REG_DWORD_LITTLE_ENDIAN     ( 4 )
-#define REG_DWORD_BIG_ENDIAN        ( 5 )
-#define REG_LINK                    ( 6 )
-#define REG_MULTI_SZ                ( 7 )
-#define REG_RESOURCE_LIST           ( 8 )
-#define REG_FULL_RESOURCE_DESCRIPTOR ( 9 )
-#define REG_RESOURCE_REQUIREMENTS_LIST ( 10 )
-#define REG_QWORD                   ( 11 )
-#define REG_QWORD_LITTLE_ENDIAN     ( 11 )

ctypes_generation/winfunc.txt

@@ -1,656 +0,0 @@
-VOID WINAPI ExitProcess(
-  _In_  UINT uExitCode
-);
-
-BOOL WINAPI TerminateProcess(
-  _In_ HANDLE hProcess,
-  _In_ UINT   uExitCode
-);
-
-DWORD WINAPI GetLastError();
-
-HANDLE WINAPI GetCurrentProcess();
-
-HANDLE WINAPI CreateFileA(
-    __in     LPCSTR lpFileName,
-    __in     DWORD dwDesiredAccess,
-    __in     DWORD dwShareMode,
-    __in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes,
-    __in     DWORD dwCreationDisposition,
-    __in     DWORD dwFlagsAndAttributes,
-    __in_opt HANDLE hTemplateFile
-    );
-
-HANDLE WINAPI CreateFileW(
-    __in     LPCWSTR lpFileName,
-    __in     DWORD dwDesiredAccess,
-    __in     DWORD dwShareMode,
-    __in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes,
-    __in     DWORD dwCreationDisposition,
-    __in     DWORD dwFlagsAndAttributes,
-    __in_opt HANDLE hTemplateFile
-    );
-
-
-NTSTATUS WINAPI NtQuerySystemInformation(
-  _In_       SYSTEM_INFORMATION_CLASS SystemInformationClass,
-  _Inout_    PVOID SystemInformation,
-  _In_       ULONG SystemInformationLength,
-  _Out_opt_  PULONG ReturnLength
-);
-
-NTSTATUS WINAPI NtQueryInformationProcess(
-  _In_      HANDLE           ProcessHandle,
-  _In_      PROCESSINFOCLASS ProcessInformationClass,
-  _Out_     PVOID            ProcessInformation,
-  _In_      ULONG            ProcessInformationLength,
-  _Out_opt_ PULONG           ReturnLength
-);
-
-NTSTATUS WINAPI NtQueryVirtualMemory(
-  _In_      HANDLE                   ProcessHandle,
-  _In_opt_  PVOID                    BaseAddress,
-  _In_      MEMORY_INFORMATION_CLASS MemoryInformationClass,
-  _Out_     PVOID                    MemoryInformation,
-  _In_      SIZE_T                   MemoryInformationLength,
-  _Out_opt_ PSIZE_T                  ReturnLength
-);
-
-NTSTATUS NtCreateThreadEx(
-        PHANDLE                 ThreadHandle,
-        ACCESS_MASK             DesiredAccess,
-        LPVOID                  ObjectAttributes,
-        HANDLE                  ProcessHandle,
-        LPTHREAD_START_ROUTINE  lpStartAddress,
-        LPVOID                  lpParameter,
-        BOOL                    CreateSuspended,
-        DWORD                   dwStackSize,
-        DWORD                   Unknown1,
-        DWORD                   Unknown2,
-        LPVOID                  Unknown3
-);
-
-NTSTATUS WINAPI NtQueryInformationThread (
-    _In_ HANDLE ThreadHandle,
-    _In_ THREAD_INFORMATION_CLASS ThreadInformationClass,
-    _Out_ PVOID ThreadInformation,
-    _In_ ULONG ThreadInformationLength,
-    _Out_ PULONG ReturnLength
-);
-
-BOOL WINAPI GetExitCodeThread(
-    _In_  HANDLE hThread,
-    _Out_ LPDWORD lpExitCode
-);
-
-BOOL WINAPI GetExitCodeProcess(
-    __in  HANDLE hProcess,
-    __out LPDWORD lpExitCode
-);
-
-LPVOID WINAPI VirtualAlloc(
-  _In_opt_  LPVOID lpAddress,
-  _In_      SIZE_T dwSize,
-  _In_      DWORD flAllocationType,
-  _In_      DWORD flProtect
-);
-
-LPVOID WINAPI VirtualAllocEx(
-  _In_      HANDLE hProcess,
-  _In_opt_  LPVOID lpAddress,
-  _In_      SIZE_T dwSize,
-  _In_      DWORD flAllocationType,
-  _In_      DWORD flProtect
-);
-
-BOOL WINAPI VirtualFree(
-  _In_ LPVOID lpAddress,
-  _In_ SIZE_T dwSize,
-  _In_ DWORD  dwFreeType
-);
-
-BOOL WINAPI VirtualFreeEx(
-  _In_ HANDLE hProcess,
-  _In_ LPVOID lpAddress,
-  _In_ SIZE_T dwSize,
-  _In_ DWORD  dwFreeType
-);
-
-BOOL WINAPI VirtualProtect(
-  _In_   LPVOID lpAddress,
-  _In_   SIZE_T dwSize,
-  _In_   DWORD flNewProtect,
-  _Out_  PDWORD lpflOldProtect
-);
-
-DWORD VirtualQuery(
-  LPCVOID lpAddress,
-  PMEMORY_BASIC_INFORMATION lpBuffer,
-  DWORD dwLength
-);
-
-SIZE_T WINAPI VirtualQueryEx(
-    _In_     HANDLE hProcess,
-    _In_opt_ LPCVOID lpAddress,
-    _Out_ PMEMORY_BASIC_INFORMATION lpBuffer,
-    _In_     SIZE_T dwLength
-    );
-
-
-DWORD WINAPI GetModuleFileNameA(
-  _In_opt_  HMODULE hModule,
-  _Out_     LPSTR lpFilename,
-  _In_      DWORD nSize
-);
-
-DWORD WINAPI GetModuleFileNameW(
-  _In_opt_  HMODULE hModule,
-  _Out_     LPWSTR lpFilename,
-  _In_      DWORD nSize
-);
-
-HANDLE WINAPI CreateThread(
-  _In_opt_   LPSECURITY_ATTRIBUTES lpThreadAttributes,
-  _In_       SIZE_T dwStackSize,
-  _In_       LPTHREAD_START_ROUTINE lpStartAddress,
-  _In_opt_   LPVOID lpParameter,
-  _In_       DWORD dwCreationFlags,
-  _Out_opt_  LPDWORD lpThreadId
-);
-
-HANDLE WINAPI CreateRemoteThread(
-  _In_   HANDLE hProcess,
-  _In_   LPSECURITY_ATTRIBUTES lpThreadAttributes,
-  _In_   SIZE_T dwStackSize,
-  _In_   LPTHREAD_START_ROUTINE lpStartAddress,
-  _In_   LPVOID lpParameter,
-  _In_   DWORD dwCreationFlags,
-  _Out_  LPDWORD lpThreadId
-);
-
-BOOL WINAPI VirtualProtect(
-  _In_   LPVOID lpAddress,
-  _In_   SIZE_T dwSize,
-  _In_   DWORD flNewProtect,
-  _Out_  PDWORD lpflOldProtect
-);
-
-BOOL WINAPI CreateProcessA(
-    __in_opt    LPCSTR lpApplicationName,
-    __inout_opt LPSTR lpCommandLine,
-    __in_opt    LPSECURITY_ATTRIBUTES lpProcessAttributes,
-    __in_opt    LPSECURITY_ATTRIBUTES lpThreadAttributes,
-    __in        BOOL bInheritHandles,
-    __in        DWORD dwCreationFlags,
-    __in_opt    LPVOID lpEnvironment,
-    __in_opt    LPCSTR lpCurrentDirectory,
-    __in        LPSTARTUPINFOA lpStartupInfo,
-    __out       LPPROCESS_INFORMATION lpProcessInformation
-);
-
-BOOL WINAPI CreateProcessW(
-    __in_opt    LPCWSTR lpApplicationName,
-    __inout_opt LPWSTR lpCommandLine,
-    __in_opt    LPSECURITY_ATTRIBUTES lpProcessAttributes,
-    __in_opt    LPSECURITY_ATTRIBUTES lpThreadAttributes,
-    __in        BOOL bInheritHandles,
-    __in        DWORD dwCreationFlags,
-    __in_opt    LPVOID lpEnvironment,
-    __in_opt    LPCWSTR lpCurrentDirectory,
-    __in        LPSTARTUPINFOW lpStartupInfo,
-    __out       LPPROCESS_INFORMATION lpProcessInformation
-);
-
-BOOL WINAPI GetThreadContext(
-    __in    HANDLE hThread,
-    __inout LPCONTEXT lpContext
-);
-
-BOOL WINAPI NtGetContextThread(
-    __in    HANDLE hThread,
-    __inout LPCONTEXT lpContext
-);
-
-BOOL WINAPI SetThreadContext(
-    __in HANDLE hThread,
-    __in CONST LPCONTEXT lpContext
-);
-
-HANDLE WINAPI OpenThread(
-    __in DWORD dwDesiredAccess,
-    __in BOOL bInheritHandle,
-    __in DWORD dwThreadId
-);
-
-HANDLE WINAPI OpenProcess(
-    __in DWORD dwDesiredAccess,
-    __in BOOL bInheritHandle,
-    __in DWORD dwProcessId
-);
-
-BOOL WINAPI CloseHandle(
-    __in HANDLE hObject
-);
-
-BOOL WINAPI ReadProcessMemory(
-  _In_   HANDLE hProcess,
-  _In_   LPCVOID lpBaseAddress,
-  _Out_  LPVOID lpBuffer,
-  _In_   SIZE_T nSize,
-  _Out_  SIZE_T *lpNumberOfBytesRead
-);
-
-BOOL WINAPI NtWow64ReadVirtualMemory64(
-  _In_   HANDLE hProcess,
-  _In_   ULONG64 lpBaseAddress,
-  _Out_  LPVOID lpBuffer,
-  _In_   ULONG64 nSize,
-  _Out_  PULONG64 *lpNumberOfBytesRead
-);
-
-BOOL WINAPI WriteProcessMemory(
-  _In_   HANDLE hProcess,
-  _In_   LPVOID lpBaseAddress,
-  _In_   LPCVOID lpBuffer,
-  _In_   SIZE_T nSize,
-  _Out_  SIZE_T *lpNumberOfBytesWritten
-);
-
-HANDLE WINAPI CreateToolhelp32Snapshot(
-  _In_  DWORD dwFlags,
-  _In_  DWORD th32ProcessID
-);
-
-BOOL WINAPI Thread32First(
-  _In_     HANDLE hSnapshot,
-  _Inout_  LPTHREADENTRY32 lpte
-);
-
-BOOL WINAPI Thread32Next(
-  _In_   HANDLE hSnapshot,
-  _Out_  LPTHREADENTRY32 lpte
-);
-
-BOOL WINAPI Process32First(
-  _In_     HANDLE hSnapshot,
-  _Inout_  LPPROCESSENTRY32 lppe
-);
-
-BOOL WINAPI Process32Next(
-  _In_   HANDLE hSnapshot,
-  _Out_  LPPROCESSENTRY32 lppe
-);
-
-BOOL Process32FirstW(
-    HANDLE hSnapshot,
-    LPPROCESSENTRY32W lppe
-);
-
-BOOL Process32NextW(
-    HANDLE hSnapshot,
-    LPPROCESSENTRY32W lppe
-);
-
-FARPROC WINAPI GetProcAddress(
-  _In_  HMODULE hModule,
-  _In_  LPCSTR lpProcName
-);
-
-
-HMODULE WINAPI LoadLibraryA(
-    __in LPCSTR lpFileName
-);
-
-HMODULE WINAPI LoadLibraryW(
-    __in LPCWSTR lpFileName
-);
-
-BOOL WINAPI OpenProcessToken(
-  _In_   HANDLE ProcessHandle,
-  _In_   DWORD DesiredAccess,
-  _Out_  PHANDLE TokenHandle
-);
-
-BOOL WINAPI LookupPrivilegeValueA(
-    __in_opt LPCSTR lpSystemName,
-    __in     LPCSTR lpName,
-    __out    PLUID   lpLuid
-);
-
-BOOL WINAPI LookupPrivilegeValueW(
-    __in_opt LPCWSTR lpSystemName,
-    __in     LPCWSTR lpName,
-    __out    PLUID   lpLuid
-);
-
-BOOL WINAPI AdjustTokenPrivileges(
-  _In_       HANDLE TokenHandle,
-  _In_       BOOL DisableAllPrivileges,
-  _In_opt_   PTOKEN_PRIVILEGES NewState,
-  _In_       DWORD BufferLength,
-  _Out_opt_  PTOKEN_PRIVILEGES PreviousState,
-  _Out_opt_  PDWORD ReturnLength
-);
-
-HRSRC WINAPI FindResourceA(
-    __in_opt HMODULE hModule,
-    __in     LPCSTR lpName,
-    __in     LPCSTR lpType
-);
-
-HRSRC WINAPI FindResourceW(
-    __in_opt HMODULE hModule,
-    __in     LPCWSTR lpName,
-    __in     LPCWSTR lpType
-);
-
-DWORD WINAPI SizeofResource(
-  _In_opt_  HMODULE hModule,
-  _In_      HRSRC hResInfo
-);
-
-HGLOBAL WINAPI LoadResource(
-  _In_opt_  HMODULE hModule,
-  _In_      HRSRC hResInfo
-);
-
-LPVOID WINAPI LockResource(
-  _In_  HGLOBAL hResData
-);
-
-BOOL WINAPI GetVersionExA(
-    __inout LPOSVERSIONINFOA lpVersionInformation
-);
-
-BOOL WINAPI GetVersionExW(
-    __inout LPOSVERSIONINFOW lpVersionInformation
-);
-
-DWORD GetVersion();
-
-HANDLE GetCurrentThread();
-
-DWORD GetCurrentThreadId();
-
-DWORD GetCurrentProcessorNumber();
-
-BOOL AllocConsole();
-
-BOOL FreeConsole();
-
-HANDLE WINAPI GetStdHandle(
-  _In_  DWORD nStdHandle
-);
-
-BOOL WINAPI SetStdHandle(
-  _In_  DWORD nStdHandle,
-  _In_  HANDLE hHandle
-);
-
-DWORD WINAPI SetThreadAffinityMask(
-  _In_  HANDLE hThread,
-  _In_  DWORD dwThreadAffinityMask
-);
-
-BOOL WINAPI WriteFile(
-  _In_         HANDLE hFile,
-  _In_         LPCVOID lpBuffer,
-  _In_         DWORD nNumberOfBytesToWrite,
-  _Out_opt_    LPDWORD lpNumberOfBytesWritten,
-  _Inout_opt_  LPOVERLAPPED lpOverlapped
-);
-
-DWORD WINAPI GetExtendedTcpTable(
-  _Out_    PVOID pTcpTable,
-  _Inout_  PDWORD pdwSize,
-  _In_     BOOL bOrder,
-  _In_     ULONG ulAf,
-  _In_     TCP_TABLE_CLASS TableClass,
-  _In_     ULONG Reserved
-);
-
-DWORD WINAPI GetExtendedUdpTable(
-  _Out_    PVOID pUdpTable,
-  _Inout_  PDWORD pdwSize,
-  _In_     BOOL bOrder,
-  _In_     ULONG ulAf,
-  _In_     UDP_TABLE_CLASS TableClass,
-  _In_     ULONG Reserved
-);
-
-DWORD WINAPI SetTcpEntry(
-  _In_  PMIB_TCPROW pTcpRow
-);
-
-PVOID WINAPI AddVectoredContinueHandler(
-  _In_  ULONG FirstHandler,
-  _In_  PVECTORED_EXCEPTION_HANDLER VectoredHandler
-);
-
-
-PVOID WINAPI AddVectoredExceptionHandler(
-  _In_  ULONG FirstHandler,
-  _In_  PVECTORED_EXCEPTION_HANDLER VectoredHandler
-);
-
-BOOL WINAPI TerminateThread(
-  _Inout_  HANDLE hThread,
-  _In_     DWORD dwExitCode
-);
-
-VOID WINAPI ExitThread(
-  _In_  DWORD dwExitCode
-);
-
-ULONG WINAPI RemoveVectoredExceptionHandler(
-  _In_  PVOID Handler
-);
-
-DWORD WINAPI ResumeThread(
-  _In_  HANDLE hThread
-);
-
-DWORD WINAPI SuspendThread(
-  _In_  HANDLE hThread
-);
-
-
-
-DWORD WINAPI WaitForSingleObject(
-  _In_  HANDLE hHandle,
-  _In_  DWORD dwMilliseconds
-);
-
-DWORD WINAPI GetThreadId(
- _In_ HANDLE Thread
- );
-
-HMODULE WINAPI LoadLibraryExA(
-  _In_       LPCSTR lpFileName,
-  _Reserved_ HANDLE  hFile,
-  _In_       DWORD   dwFlags
-);
-
-HMODULE WINAPI LoadLibraryExW(
-  _In_       LPCWSTR lpFileName,
-  _Reserved_ HANDLE  hFile,
-  _In_       DWORD   dwFlags
-);
-
-BOOL WINAPI SymInitialize(
-  _In_     HANDLE hProcess,
-  _In_opt_ LPCSTR UserSearchPath,
-  _In_     BOOL   fInvadeProcess
-);
-
-BOOL WINAPI SymFromName(
-  _In_    HANDLE       hProcess,
-  _In_    LPCSTR       Name,
-  _Inout_ PSYMBOL_INFO Symbol
-);
-
-DWORD64 WINAPI SymLoadModuleEx(
-  _In_ HANDLE        hProcess,
-  _In_ HANDLE        hFile,
-  _In_ LPCSTR        ImageName,
-  _In_ LPCSTR        ModuleName,
-  _In_ DWORD64       BaseOfDll,
-  _In_ DWORD         DllSize,
-  _In_ PMODLOAD_DATA Data,
-  _In_ DWORD         Flags
-);
-
-DWORD WINAPI SymSetOptions(
-  _In_ DWORD SymOptions
-);
-
-BOOL WINAPI SymGetTypeInfo(
-  _In_  HANDLE                    hProcess,
-  _In_  DWORD64                   ModBase,
-  _In_  ULONG                     TypeId,
-  _In_  IMAGEHLP_SYMBOL_TYPE_INFO GetType,
-  _Out_ PVOID                     pInfo
-);
-
-BOOL WINAPI DeviceIoControl(
-  _In_        HANDLE       hDevice,
-  _In_        DWORD        dwIoControlCode,
-  _In_opt_    LPVOID       lpInBuffer,
-  _In_        DWORD        nInBufferSize,
-  _Out_opt_   LPVOID       lpOutBuffer,
-  _In_        DWORD        nOutBufferSize,
-  _Out_opt_   LPDWORD      lpBytesReturned,
-  _Inout_opt_ LPOVERLAPPED lpOverlapped
-);
-
-BOOL WINAPI GetTokenInformation(
-  _In_      HANDLE                  TokenHandle,
-  _In_      TOKEN_INFORMATION_CLASS TokenInformationClass,
-  _Out_opt_ LPVOID                  TokenInformation,
-  _In_      DWORD                   TokenInformationLength,
-  _Out_     PDWORD                  ReturnLength
-);
-
-LONG WINAPI RegOpenKeyExA(
-  _In_     HKEY    hKey,
-  _In_opt_ LPCSTR lpSubKey,
-  _In_     DWORD   ulOptions,
-  _In_     REGSAM  samDesired,
-  _Out_    PHKEY   phkResult
-);
-
-LONG WINAPI RegOpenKeyExW(
-  _In_     HKEY    hKey,
-  _In_opt_ LPWSTR lpSubKey,
-  _In_     DWORD   ulOptions,
-  _In_     REGSAM  samDesired,
-  _Out_    PHKEY   phkResult
-);
-
-LONG WINAPI RegGetValueA(
-  _In_        HKEY    hkey,
-  _In_opt_    LPCSTR lpSubKey,
-  _In_opt_    LPCSTR lpValue,
-  _In_opt_    DWORD   dwFlags,
-  _Out_opt_   LPDWORD pdwType,
-  _Out_opt_   PVOID   pvData,
-  _Inout_opt_ LPDWORD pcbData
-);
-
-LONG WINAPI RegGetValueW(
-  _In_        HKEY    hkey,
-  _In_opt_    LPWSTR lpSubKey,
-  _In_opt_    LPWSTR lpValue,
-  _In_opt_    DWORD   dwFlags,
-  _Out_opt_   LPDWORD pdwType,
-  _Out_opt_   PVOID   pvData,
-  _Inout_opt_ LPDWORD pcbData
-);
-
-LONG WINAPI RegCloseKey(
-  _In_ HKEY hKey
-);
-
-BOOL WINAPI Wow64DisableWow64FsRedirection(
-  _Out_ PVOID *OldValue
-);
-
-BOOL WINAPI Wow64RevertWow64FsRedirection(
-  _In_ PVOID OldValue
-);
-
-BOOLEAN WINAPI Wow64EnableWow64FsRedirection(
-  _In_ BOOLEAN Wow64FsEnableRedirection
-);
-
-BOOL WINAPI Wow64GetThreadContext(
-    _In_    HANDLE hThread,
-    _Inout_ PWOW64_CONTEXT lpContext
-);
-
-BOOL WINAPI SetConsoleCtrlHandler(
-  _In_opt_ PHANDLER_ROUTINE HandlerRoutine,
-  _In_     BOOL             Add
-);
-
-LONG WINAPI WinVerifyTrust(
-    _In_opt_ HWND hwnd,
-    _In_ GUID *pgActionID,
-    _Inout_ LPVOID pWVTData
-);
-
-HGLOBAL WINAPI GlobalAlloc(
-  _In_ UINT   uFlags,
-  _In_ SIZE_T dwBytes
-);
-
-HGLOBAL WINAPI GlobalFree(
-  _In_ HGLOBAL hMem
-);
-
-BOOL WINAPI GlobalUnlock(
-  _In_ HGLOBAL hMem
-);
-
-LPVOID WINAPI GlobalLock(
-  _In_ HGLOBAL hMem
-);
-
-BOOL WINAPI OpenClipboard(
-  _In_opt_ HWND hWndNewOwner
-);
-
-BOOL WINAPI EmptyClipboard();
-
-BOOL WINAPI CloseClipboard();
-
-HANDLE WINAPI SetClipboardData(
-  _In_     UINT   uFormat,
-  _In_opt_ HANDLE hMem
-);
-
-HANDLE WINAPI GetClipboardData(
-  _In_ UINT uFormat
-);
-
-UINT WINAPI EnumClipboardFormats(
-  _In_ UINT format
-);
-
-INT WINAPI GetClipboardFormatNameA(
-  _In_  UINT   format,
-  _Out_ LPCSTR lpszFormatName,
-  _In_  INT    cchMaxCount
-);
-
-INT WINAPI GetClipboardFormatNameW(
-  _In_  UINT   format,
-  _Out_ LPCWSTR lpszFormatName,
-  _In_  INT    cchMaxCount
-);
-
-LONG WINAPI WinVerifyTrust(
-  _In_ HWND   hWnd,
-  _In_ GUID   *pgActionID,
-  _In_ LPVOID pWVTData
-);

ctypes_generation/winstruct.py

@@ -25,12 +25,13 @@ class Ptr(object):
 
     def __repr__(self):
         return "Ptr({0})".format(repr(self.type))
-        
+
 
 class WinStruct(object):
     ctypes_type = "Structure"
-    def __init__(self, name):
+    def __init__(self, name, pack=None):
         self.name = name
+        self.pack = pack
         self.fields = []
         self.typedef = {}
 
@@ -51,47 +52,74 @@ class WinStruct(object):
         for type in [f[0] for f in self.fields]:
             if type.name == self.name:
                 return True
+            if type.name in self.typedef:
+                return True
         return False
 
     def generate_selfref_ctypes_class(self):
-        res = "# Self referencing struct tricks\n"
-        res += """class {0}(Structure): pass\n""".format(self.name)
-        res += "{0}._fields_ = [\n".format(self.name)
+        res = ["# Self referencing struct tricks"]
+        res += ["""class {0}(Structure): pass""".format(self.name)]
+        # res += [self.generate_anonymous_union()]
+        res += [self.generate_typedef_ctypes()]
 
+        if self.pack:
+            res += ["{0}._pack_ = ".format(self.pack)]
+        res += ["{0}._fields_ = [".format(self.name)]
         for (ftype, name, nb_rep) in self.fields:
-            if  nb_rep == 1: 
-                res+= '    ("{0}", {1}),\n'.format(name, ftype.generate_ctypes())
-            else:       
-                res+= '    ("{0}", {1} * {2}),\n'.format(name, ftype.generate_ctypes(), nb_rep)
-        res += "]\n"
-        return res
+            if  nb_rep == 1:
+                res+= ['    ("{0}", {1}),'.format(name, ftype.generate_ctypes())]
+            else:
+                res+= ['    ("{0}", {1} * {2}),'.format(name, ftype.generate_ctypes(), nb_rep)]
+        res += ["]"]
+        return "\n".join(res)
+
+    def generate_anonymous_union(self):
+        annon_fields = [name for (ftype, name, nb_rep) in self.fields if ftype.name.startswith("_ANON_")]
+        if not annon_fields:
+            return ""
+        if len(annon_fields) == 1:
+            annon_fields_str = '"{0}",'.format(annon_fields[0])
+        else:
+            annon_fields_str = ",".join(['"{0}"'.format(name) for name in annon_fields])
+        return "    _anonymous_ = ({0})\n".format(annon_fields_str)
 
     def generate_ctypes_class(self):
-        if self.is_self_referencing():
-            return self.generate_selfref_ctypes_class()
-        res = """class {0}({1}):
-        _fields_ = [\n""".format(self.name, self.ctypes_type)
+        res = "class {0}({1}):\n".format(self.name, self.ctypes_type)
+        if self.pack:
+            res += "    _pack_ = {0}\n".format(self.pack)
+        res += self.generate_anonymous_union()
+        res += "    _fields_ = [\n"""
+
 
         for (ftype, name, nb_rep) in self.fields:
-            if  nb_rep == 1: 
+            if  nb_rep == 1:
                 res+= '        ("{0}", {1}),\n'.format(name, ftype.generate_ctypes())
-            else:       
+            else:
                 res+= '        ("{0}", {1} * {2}),\n'.format(name, ftype.generate_ctypes(), nb_rep)
-        res += "    ]\n"
+        res += "    ]"
         return res
 
-    def generate_ctypes(self):
-        ctypes_class = self.generate_ctypes_class()
+    def generate_typedef_ctypes(self):
+        typedef_ctypes = []
         for typedef_name, value in self.typedef.items():
             str_value = self.name
             if type(value) == Ptr:
                 str_value = "POINTER({0})".format(self.name)
-            ctypes_class += "{0} = {1}\n".format(typedef_name, str_value)
-        return ctypes_class
-        
+            typedef_ctypes += ["{0} = {1}".format(typedef_name, str_value)]
+        return "\n".join(typedef_ctypes)
+
+    def generate_ctypes(self):
+        if self.is_self_referencing():
+            print("{0} is self referencing".format(self.name))
+            return self.generate_selfref_ctypes_class() + "\n"
+
+        ctypes_class = self.generate_ctypes_class()
+        ctypes_typedef = self.generate_typedef_ctypes()
+        return "\n".join([ctypes_class, ctypes_typedef]) + "\n"
+
 class WinUnion(WinStruct):
     ctypes_type = "Union"
-                
+
 class WinEnum(object):
     def __init__(self, name):
         self.name = name
@@ -105,7 +133,7 @@ class WinEnum(object):
         if name in self.typedef:
             raise ValueError("nop")
         self.typedef[name] = self
-        
+
     def add_ptr_typedef(self, name):
         if name in self.typedef:
             raise ValueError("nop")
@@ -113,7 +141,15 @@ class WinEnum(object):
 
     # Assert that enum are DWORD
     def generate_ctypes(self):
-        lines = ["{0} = DWORD".format(self.name)]
+        #lines = ["{0} = DWORD".format(self.name)]
+        lines = []
+        for i, name in self.fields:
+            lines.append('{0} = EnumValue("{2}", "{0}", {1})'.format(name, "{0:#x}".format(i), self.name))
+
+        lines += ["class {0}(EnumType):".format(self.name)]
+        lines += ["    values = [{0}]".format(", ".join([name for i, name in self.fields]))]
+        lines += ["    mapper = {{x:x for x in values}}".format(self.name)]
+
         for typedef_name, value in self.typedef.items():
             str_value = self.name
             if type(value) == Ptr:
@@ -121,10 +157,5 @@ class WinEnum(object):
             lines += ["{0} = {1}".format(typedef_name, str_value)]
         #lines += ["{0} = {1}".format(t, self.name) for t in self.typedef]
         lines += [""]
-
-        for i, name in self.fields:
-            lines.append("{0} = {1}".format(name, hex(i)))
-        ctypes_class = "\n".join(lines) 
-
+        ctypes_class = "\n".join(lines)
         return ctypes_class + "\n"
-        

doc/source/com.rst

@@ -1,21 +0,0 @@
-COM - Component Object Model
-""""""""""""""""""""""""""""
-
-A module to call `COM` interfaces from `Python` or
-`COM` vtable in python.
-
-This code is only used in :mod:`windows.wmi`.
-The ability to create `COM` vtable is used in the `LKD project <https://github.com/sogeti-esec-lab/LKD/>`_ .
-
-
-To call a `COM` interface you need to:
-
-    1. Describe the `COM` interface `CODE1 <https://github.com/sogeti-esec-lab/LKD/blob/ba40727d7d257b00f89fc6ca7296c9833b7b75b2/dbginterface/remote.py#L56>`_
-    2. Use an instance (which is a PVOID) to get the interface `CODE2 <https://github.com/sogeti-esec-lab/LKD/blob/ba40727d7d257b00f89fc6ca7296c9833b7b75b2/dbginterface/remote.py#L313>`_
-    3. Use the object ! `CODE3 <https://github.com/sogeti-esec-lab/LKD/blob/ba40727d7d257b00f89fc6ca7296c9833b7b75b2/dbginterface/remote.py#L366>`_
-
-To create `COM` object you need to:
-
-    1. Describe your ComVtable `CODE4 <https://github.com/sogeti-esec-lab/LKD/blob/ba40727d7d257b00f89fc6ca7296c9833b7b75b2/simple_com.py#L89>`_
-    2. Implement the python functions described `CODE5 <https://github.com/sogeti-esec-lab/LKD/blob/ba40727d7d257b00f89fc6ca7296c9833b7b75b2/dbginterface/remote.py#L233>`_
-    3. Create an instance and pass it to whatever native function expects it `CODE6 <https://github.com/sogeti-esec-lab/LKD/blob/ba40727d7d257b00f89fc6ca7296c9833b7b75b2/dbginterface/remote.py#L438>`_

doc/source/index.rst

@@ -1,32 +0,0 @@
-.. PyWindows documentation master file, created by
-   sphinx-quickstart on Tue Apr 07 11:39:41 2015.
-   You can adapt this file completely to your liking, but it should at least
-   contain the root `toctree` directive.
-
-Welcome to PythonForWindows's documentation!
-=====================================
-
-Contents:
-
-.. toctree::
-   :maxdepth: 2
-   :numbered:
-
-   windows.rst
-   various.rst
-   native_exec.rst
-   winproxy.rst
-   utils.rst
-   iat_hook.rst
-   wip.rst
-   internals.rst
-   sample.rst
-
-
-Indices and tables
-==================
-
-* :ref:`modindex`
-* :ref:`search`
-* :ref:`genindex`
-

doc/source/network.rst

@@ -1,19 +0,0 @@
-Network
-=======
-
-.. module:: windows.network
-
-.. note::
-
-    See sample :ref:`sample_network_exploration`
-
-
-.. autoclass:: windows.network.Network
-
-Connections
-"""""""""""
-
-.. autoclass:: windows.network.TCP4Connection
-
-
-.. autoclass:: windows.network.TCP6Connection

doc/source/sample.rst

@@ -1,190 +0,0 @@
-Samples of code
-===============
-
-.. _sample_current_process:
-
-``windows.current_process``
-"""""""""""""""""""""""""""
-
-.. literalinclude:: ..\..\samples\current_process.py
-
-Output::
-
-    (cmd λ) python32.exe current_process.py
-    current process is <windows.winobject.CurrentProcess object at 0x026CD190>
-    current process is a <32> bits process
-    current process is a SysWow64 process ? <True>
-    current process pid <7432>  and ppid <5412>
-    Here are the current process threads: <[<WinThread 5264 owner "python.exe" at 0x28563f0>]>
-    Let's execute some native code ! (0x41 + 1)
-    Waiting for execution to finish !
-    Native code returned <0x42L>
-    Allocating memory in current process
-    Allocated memory is at <0x3f0000>
-    Writing 'SOME STUFF' in allocation memory
-    Reading memory : <'SOME STUFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'>
-
-.. _sample_remote_process:
-
-Remote process : :class:`WinProcess`
-""""""""""""""""""""""""""""""""""""
-
-.. literalinclude:: ..\..\samples\remote_calc.py
-
-Output::
-
-    (cmd λ) python.exe remote_calc.py
-    Creating a calc
-    Looking for calcs in the processes
-    They are currently <1> calcs running on the system
-    Let's play with our calc: <<WinProcess "calc.exe" pid 8052 at 0x27bd5d0>>
-    Our calc pid is 8052
-    Our calc is a <32> bits process
-    Our calc is a SysWow64 process ? <True>
-    Our calc have threads ! <[<WinThread 8552 owner "calc.exe" at 0x27f7f30>, <WinThread 3464 owner "calc.exe" at 0x27f7f80>, <WinThread 3840 owner "calc.exe" at 0x27fa030>]>
-    Exploring our calc PEB ! <windows.winobject.RemotePEB object at 0x026DDD00>
-    Command line is <RemoteWinUnicodeString ""C:\windows\system32\calc.exe"" at 0x26ddee0>
-    Here are 3 loaded modules: [<RemoteLoadedModule "calc.exe" at 0x26dde40>, <RemoteLoadedModule "ntdll.dll" at 0x26ddf30>, <RemoteLoadedModule "kernel32.dll" at 0x26ddc60>]
-    Allocating memory in our calc
-    Allocated memory is at <0x5c90000>
-    Writing 'SOME STUFF' in allocated memory
-    Reading allocated memory : <'SOME STUFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'>
-    Execution some native code in our calc (write 0x424242 at allocated address + return 0x1337
-    Executing native code !
-    Return code = 0x1337L
-    Reading allocated memory : <'BBBB STUFF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'>
-    Executing python code !
-    Reading allocated memory : <'HELLO FROM CALC\x00\x00\x00\x00\x00'>
-    Trying to import in remote module 'FAKE_MODULE'
-    Remote ERROR !
-    Traceback (most recent call last):
-    File "<string>", line 3, in <module>
-    File "<string>", line 2, in func
-    ImportError: No module named FAKE_MODULE
-
-    That's all ! killing the calc
-
-
-.. _sample_peb_exploration:
-
-:class:`PEB` exploration
-""""""""""""""""""""""""
-
-.. literalinclude:: ..\..\samples\peb.py
-
-Output::
-
-    (cmd λ) python.exe  peb.py
-    Exploring the current process PEB
-    PEB is <<windows.winobject.PEB object at 0x02649B70>>
-    Commandline object is <WinUnicodeString "python.exe   peb.py " at 0x2649c60>
-    Commandline string is u'python.exe   peb.py '
-    Imagepath  <WinUnicodeString "C:\Python27\python.exe" at 0x2649d50>
-    Printing some modules: <LoadedModule "python.exe" at 0x272a030>
-    <LoadedModule "ntdll.dll" at 0x272a080>
-    <LoadedModule "kernel32.dll" at 0x272acb0>
-    <LoadedModule "kernelbase.dll" at 0x272ad00>
-    <LoadedModule "python27.dll" at 0x272ad50>
-    <LoadedModule "msvcr90.dll" at 0x272ada0>
-    === K32  ===
-    Looking for kernel32.dll
-    Kernel32 module: <LoadedModule "kernel32.dll" at 0x272acb0>
-    Module name = <kernel32.dll> | Fullname = <C:\Windows\SYSTEM32\KERNEL32.DLL>
-    Kernel32 is loaded at address 0x774c0000
-    === K32 PE ===
-    PE Representation of k32: <windows.pe_parse.PEFile object at 0x0272D350>
-    Here are some exports {0: 2001566688L, u'CreateFileA': 2001635616L, 42: 2001647872L, u'VirtualAlloc': 2001570704L}
-    Import DLL dependancies are (without api-*): [u'ntdll.dll', u'kernelbase.dll']
-    IAT Entry for ntdll!NtCreateFile = <IATEntry "NtCreateFile" ordinal 253> | addr = 0x77541128L
-    Sections: [<PESection ".text">, <PESection ".rdata">, <PESection ".data">, <PESection ".rsrc">, <PESection ".reloc">]
-
-
-.. _sample_iat_hook:
-
-IAT hooking
-"""""""""""
-
-.. literalinclude:: ..\..\samples\iat_hook.py
-
-Output::
-
-    (cmd λ) python iat_hook.py
-    Asking for <MY_SECRET_KEY>
-    <in hook> Hook called | hKey = 0x12d687 | lpSubKey = <MY_SECRET_KEY>
-    <in hook> Secret key asked, returning magic handle 0x12345678
-    Result = 0x12345678
-
-    Asking for <MY_FAIL_KEY>
-    <in hook> Hook called | hKey = 0x12d687 | lpSubKey = <MY_FAIL_KEY>
-    <in hook> Asked for a failing key: returning 0x2a
-    WindowsError(42, 'Windows Error 0x2A')
-
-    Asking for <HKEY_CURRENT_USER/Software>
-    <in hook> Hook called | hKey = 0x80000001L | lpSubKey = <Software>
-    <in hook> Non-secret key : calling normal function
-    Result = 0x108
-
-.. _sample_network_exploration:
-
-:class:`Network` - socket exploration
-"""""""""""""""""""""""""""""""""""""
-
-.. literalinclude:: ..\..\samples\network.py
-
-Output::
-
-    (cmd λ) python.exe  network.py
-    Working on ipv4
-    == Listening ==
-    Some listening connections: [<TCP IPV4 Listening socket on 0.0.0.0:80>, <TCP IPV4 Listening socket on 0.0.0.0:135>, <TCP IPV4 Listening socket on 0.0.0.0:443>]
-    Listening ports are : [80, 135, 443, 445, 902, 912, 5357, 49152, 49153, 49154, 49155, 49157, 49159, 8307, 25340, 139, 139]
-    == Established ==
-    Some established connections: [<TCP IPV4 Connection 127.0.0.1:25340 -> 127.0.0.1:49472>, <TCP IPV4 Connection 127.0.0.1:49173 -> 127.0.0.1:49174>, <TCP IPV4 Connection 127.0.0.1:49174 -> 127.0.0.1:49173>]
-    == connection to localhost:80 ==
-    Our connection is [<TCP IPV4 Connection 127.0.0.1:49616 -> 127.0.0.1:80>]
-    Sending YOP
-    Closing socket
-    Sending LAIT
-    Traceback (most recent call last):
-    File ".\network.py", line 45, in <module>
-        s.send("LAIT")
-    socket.error: [Errno 10054] An existing connection was forcibly closed by the remote host
-
-
-.. _sample_registry:
-
-:class:`Registry`
-"""""""""""""""""
-
-.. literalinclude:: ..\..\samples\registry.py
-
-Output::
-
-    (cmd λ) python.exe registry.py
-    Registry is <<windows.registry.Registry object at 0x02941290>>
-    HKEY_CURRENT_USER is <<PyHKey "HKEY_CURRENT_USER">>
-    HKEY_CURRENT_USER subkeys names are:
-    ['AppEvents',
-    'AppXBackupContentType',
-    'Console',
-    'Control Panel',
-    'Environment',
-    'EUDC',
-    'Identities',
-    'Keyboard Layout',
-    'Network',
-    'Printers',
-    'Software',
-    'System',
-    'Volatile Environment']
-    Opening 'Software' in HKEY_CURRENT_USER: <PyHKey "HKEY_CURRENT_USER\Software">
-    We can also open it in one access: <PyHKey "HKEY_CURRENT_USER\Sofware">
-    Looking at CurrentVersion
-    Key is <PyHKey "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion">
-    values are:
-    [KeyValue(name='SoftwareType', value=u'System', type=1),
-    KeyValue(name='RegisteredOwner', value=u'hakril', type=1),
-    KeyValue(name='InstallDate', value=0, type=4),
-    ...
-    KeyValue(name='PathName', value=u'C:\\Windows', type=1)]
-    registered owner = <KeyValue(name='RegisteredOwner', value=u'hakril', type=1)>

doc/source/utils.rst

@@ -1,34 +0,0 @@
-``windows.utils`` -- Windows Utilities
-***********************************************
-
-.. module:: windows.utils
-
-Context Managers
-""""""""""""""""
-
-:mod:`windows.utils` provides some context managers wrapping `standard` contextual operations
-like ``VirtualProtect`` or ``SysWow Redirection``
-
-VirtualProtected
-''''''''''''''''
-
-.. autoclass:: windows.utils.VirtualProtected
-    :no-show-inheritance:
-
-DisableWow64FsRedirection
-'''''''''''''''''''''''''
-
-.. autoclass:: windows.utils.DisableWow64FsRedirection
-    :no-show-inheritance:
-
-Helper functions
-""""""""""""""""
-
-.. autofunction:: windows.utils.enable_privilege
-.. autofunction:: windows.utils.check_is_elevated
-.. autofunction:: windows.utils.check_debug
-.. autofunction:: windows.utils.create_process
-.. autofunction:: windows.utils.create_console
-.. autofunction:: windows.utils.pop_shell
-.. autofunction:: windows.utils.create_file_from_handle
-.. autofunction:: windows.utils.get_handle_from_file

doc/source/winproxy.rst

@@ -1,395 +0,0 @@
-``windows.winproxy`` -- Windows API
-***********************************
-
-.. module:: windows.winproxy
-
-:mod:`windows.winproxy` tries to be a pythontic wrapper around windows API of various DLL.
-It also heavily relies on :mod:`ctypes` and :mod:`windows.generated_def.winfuncs`
-
-Here are the things to know about :mod:`windows.winproxy`
-    * All of this is based on :mod:`windows.generated_def.winfuncs`
-    * DLL is loaded the first time an API of it is called
-    * All parameters can be passed by ordinal or keyword
-    * The call will fail if an argument with default value ``NeededParamater`` have been called without another value.
-    * The call will raise a subclass of :class:`WindowsError` if it fails.
-    * Some functions are 'transparent proxy' it means that all parameters are mandatory
-
-Example: ``VirtualAlloc``
-"""""""""""""""""""""""""
-
-Exemple with the function `VirtualAlloc` in :mod:`windows.winproxy`
-
-Documentation:
-
-.. code-block:: python
-
-    import windows
-    windows.winproxy.VirtualAlloc
-    # <function VirtualAlloc at 0x02ED63F0>
-
-    help(windows.winproxy.VirtualAlloc)
-    # Help on function VirtualAlloc in module windows.winproxy:
-    # VirtualAlloc(lpAddress=0, dwSize=NeededParameter, flAllocationType=MEM_COMMIT(0x1000L), flProtect=PAGE_EXECUTE_READWRITE(0x40L))
-    #     Errcheck:
-    #     raise Kernel32Error if result is 0
-
-
-Calling it
-
-.. code-block:: python
-
-    import windows
-
-    # Ordinal arguments
-    windows.winproxy.VirtualAlloc(0, 0x1000)
-    34537472
-
-    # Keyword arguments
-    windows.winproxy.VirtualAlloc(dwSize=0x1000)
-    34603008
-
-    # NeededParameter must be provided
-    windows.winproxy.VirtualAlloc()
-    """
-    Traceback (most recent call last):
-    File "<stdin>", line 1, in <module>
-    File "windows\winproxy.py", line 264, in VirtualAlloc
-        return VirtualAlloc.ctypes_function(lpAddress, dwSize, flAllocationType, flProtect)
-    File "windows\winproxy.py", line 130, in perform_call
-        raise TypeError("{0}: Missing Mandatory parameter <{1}>".format(self.func_name, param_name))
-    TypeError: VirtualAlloc: Missing Mandatory parameter <dwSize>
-    """
-
-    # Error raises exception
-    windows.winproxy.VirtualAlloc(dwSize=0xffffffff)
-    """
-    Traceback (most recent call last):
-    File "<stdin>", line 1, in <module>
-    File "windows\winproxy.py", line 264, in VirtualAlloc
-        return VirtualAlloc.ctypes_function(lpAddress, dwSize, flAllocationType, flProtect)
-    File "windows\winproxy.py", line 133, in perform_call
-        return self._cprototyped(*args)
-    File "windows\winproxy.py", line 59, in kernel32_error_check
-        raise Kernel32Error(func_name)
-    windows.winproxy.Kernel32Error: VirtualAlloc: [Error 8] Not enough storage is available to process this command.
-    """
-
-
-Functions in :mod:`windows.winproxy`
-""""""""""""""""""""""""""""""""""""
-
-Transparent proxies:
-
-* AllocConsole
-* CloseHandle
-* ExitProcess
-* ExitThread
-* FreeConsole
-* GetCurrentProcess
-* GetCurrentProcessorNumber
-* GetCurrentThread
-* GetCurrentThreadId
-* GetExitCodeProcess
-* GetExitCodeThread
-* GetLastError
-* GetProcAddress
-* GetStdHandle
-* GetThreadId
-* LoadLibraryA
-* LoadLibraryW
-* ResumeThread
-* SetStdHandle
-* SetTcpEntry
-* SuspendThread
-* TerminateProcess
-* TerminateThread
-* VirtualQueryEx
-* Wow64DisableWow64FsRedirection
-* Wow64EnableWow64FsRedirection
-* Wow64GetThreadContext
-* Wow64RevertWow64FsRedirection
-
-Functions:
-
-* AddVectoredContinueHandler::
-
-    AddVectoredContinueHandler(FirstHandler=1, VectoredHandler=NeededParameter)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* AddVectoredExceptionHandler::
-
-    AddVectoredExceptionHandler(FirstHandler=1, VectoredHandler=NeededParameter)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* AdjustTokenPrivileges::
-
-    AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges=False, NewState=NeededParameter, BufferLength=None, PreviousState=None, ReturnLength=None)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* CreateFileA::
-
-    CreateFileA(lpFileName, dwDesiredAccess=GENERIC_READ(0x80000000L), dwShareMode=0, lpSecurityAttributes=None, dwCreationDisposition=OPEN_EXISTING(0x3L), dwFlagsAndAttributes=FILE_ATTRIBUTE_NORMAL(0x80L), hTemplateFile=None)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* CreateFileW::
-
-    CreateFileW(lpFileName, dwDesiredAccess=GENERIC_READ(0x80000000L), dwShareMode=0, lpSecurityAttributes=None, dwCreationDisposition=OPEN_EXISTING(0x3L), dwFlagsAndAttributes=FILE_ATTRIBUTE_NORMAL(0x80L), hTemplateFile=None)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* CreateProcessA::
-
-    CreateProcessA(lpApplicationName, lpCommandLine=None, lpProcessAttributes=None, lpThreadAttributes=None, bInheritHandles=False, dwCreationFlags=0, lpEnvironment=None, lpCurrentDirectory=None, lpStartupInfo=None, lpProcessInformation=None)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* CreateProcessW::
-
-    CreateProcessW(lpApplicationName, lpCommandLine=None, lpProcessAttributes=None, lpThreadAttributes=None, bInheritHandles=False, dwCreationFlags=0, lpEnvironment=None, lpCurrentDirectory=None, lpStartupInfo=None, lpProcessInformation=None)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* CreateRemoteThread::
-
-    CreateRemoteThread(hProcess=NeededParameter, lpThreadAttributes=None, dwStackSize=0, lpStartAddress=NeededParameter, lpParameter=NeededParameter, dwCreationFlags=0, lpThreadId=None)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* CreateThread::
-
-    CreateThread(lpThreadAttributes=None, dwStackSize=0, lpStartAddress=NeededParameter, lpParameter=NeededParameter, dwCreationFlags=0, lpThreadId=None)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* CreateToolhelp32Snapshot::
-
-    CreateToolhelp32Snapshot(dwFlags, th32ProcessID=0)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* DeviceIoControl::
-
-    DeviceIoControl(hDevice, dwIoControlCode, lpInBuffer, nInBufferSize=None, lpOutBuffer=NeededParameter, nOutBufferSize=None, lpBytesReturned=None, lpOverlapped=None)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* GetExtendedTcpTable::
-
-    GetExtendedTcpTable(pTcpTable, pdwSize=None, bOrder=True, ulAf=NeededParameter, TableClass=5, Reserved=0)
-    Errcheck:
-       raise IphlpapiError if result is NOT 0
-
-* GetThreadContext::
-
-    GetThreadContext(hThread, lpContext=None)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* GetTokenInformation::
-
-    GetTokenInformation(TokenHandle=NeededParameter, TokenInformationClass=NeededParameter, TokenInformation=None, TokenInformationLength=0, ReturnLength=None)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* LookupPrivilegeValueA::
-
-    LookupPrivilegeValueA(lpSystemName=None, lpName=NeededParameter, lpLuid=NeededParameter)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* LookupPrivilegeValueW::
-
-    LookupPrivilegeValueW(lpSystemName=None, lpName=NeededParameter, lpLuid=NeededParameter)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* NtCreateThreadEx::
-
-    NtCreateThreadEx(ThreadHandle=None, DesiredAccess=2097151, ObjectAttributes=0, ProcessHandle=NeededParameter, lpStartAddress=NeededParameter, lpParameter=NeededParameter, CreateSuspended=0, dwStackSize=0, Unknown1=0, Unknown2=0, Unknown=0)
-
-* NtGetContextThread::
-
-    NtGetContextThread(hThread, lpContext)
-
-* NtQueryInformationProcess::
-
-    NtQueryInformationProcess(ProcessHandle, ProcessInformationClass, ProcessInformation, ProcessInformationLength=0, ReturnLength=None)
-
-* NtQueryInformationThread::
-
-    NtQueryInformationThread(ThreadHandle, ThreadInformationClass, ThreadInformation, ThreadInformationLength=0, ReturnLength=None)
-
-* NtQuerySystemInformation::
-
-    NtQuerySystemInformation(SystemInformationClass, SystemInformation=None, SystemInformationLength=0, ReturnLength=NeededParameter)
-
-* NtQueryVirtualMemory::
-
-    NtQueryVirtualMemory(ProcessHandle, BaseAddress, MemoryInformationClass, MemoryInformation=NeededParameter, MemoryInformationLength=0, ReturnLength=None)
-
-* NtWow64ReadVirtualMemory64::
-
-    NtWow64ReadVirtualMemory64(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesRead=None)
-
-* OpenProcess::
-
-    OpenProcess(dwDesiredAccess=PROCESS_ALL_ACCESS(0x1f0fffL), bInheritHandle=0, dwProcessId=NeededParameter)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* OpenProcessToken::
-
-    OpenProcessToken(ProcessHandle=None, DesiredAccess=NeededParameter, TokenHandle=NeededParameter)
-    If ProcessHandle is None: take the current process
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* OpenThread::
-
-    OpenThread(dwDesiredAccess=THREAD_ALL_ACCESS(0x1f03ffL), bInheritHandle=0, dwThreadId=NeededParameter)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* Process32First::
-
-    Process32First(hSnapshot, lpte)
-    Set byref(lpte) if needed
-    Errcheck:
-       Nothing special
-
-* Process32Next::
-
-    Process32Next(hSnapshot, lpte)
-    Set byref(lpte) if needed
-    Errcheck:
-       Nothing special
-
-* ReadProcessMemory::
-
-    ReadProcessMemory(hProcess, lpBaseAddress, lpBuffer, nSize, lpNumberOfBytesRead=None)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* RegCloseKey::
-
-    RegCloseKey(hKey)
-    Errcheck:
-       raise Kernel32Error if result is NOT 0
-
-* RegGetValueA::
-
-    RegGetValueA(hkey, lpSubKey, lpValue, dwFlags, pdwType, pvData, pcbData)
-    Errcheck:
-       raise Kernel32Error if result is NOT 0
-
-* RegGetValueW::
-
-    RegGetValueW(hkey, lpSubKey, lpValue, dwFlags, pdwType, pvData, pcbData)
-    Errcheck:
-       raise Kernel32Error if result is NOT 0
-
-* RegOpenKeyExA::
-
-    RegOpenKeyExA(hKey, lpSubKey, ulOptions, samDesired, phkResult)
-    Errcheck:
-       raise Kernel32Error if result is NOT 0
-
-* RegOpenKeyExW::
-
-    RegOpenKeyExW(hKey, lpSubKey, ulOptions, samDesired, phkResult)
-    Errcheck:
-       raise Kernel32Error if result is NOT 0
-
-* RemoveVectoredExceptionHandler::
-
-    RemoveVectoredExceptionHandler(Handler)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* SetThreadAffinityMask::
-
-    SetThreadAffinityMask(hThread=None, dwThreadAffinityMask=NeededParameter)
-    If hThread is not given, it will be the current thread
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* SetThreadContext::
-
-    SetThreadContext(hThread, lpContext)
-    Allows to directly pass a CONTEXT and will call with byref(CONTEXT) by itself
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* Thread32First::
-
-    Thread32First(hSnapshot, lpte)
-    Set byref(lpte) if needed
-    Errcheck:
-       Nothing special
-
-* Thread32Next::
-
-    Thread32Next(hSnapshot, lpte)
-    Set byref(lpte) if needed
-    Errcheck:
-       Nothing special
-
-* VirtualAlloc::
-
-    VirtualAlloc(lpAddress=0, dwSize=NeededParameter, flAllocationType=MEM_COMMIT(0x1000L), flProtect=PAGE_EXECUTE_READWRITE(0x40L))
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* VirtualAllocEx::
-
-    VirtualAllocEx(hProcess, lpAddress=0, dwSize=NeededParameter, flAllocationType=MEM_COMMIT(0x1000L), flProtect=PAGE_EXECUTE_READWRITE(0x40L))
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* VirtualFree::
-
-    VirtualFree(lpAddress, dwSize=0, dwFreeType=MEM_RELEASE(0x8000L))
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* VirtualFreeEx::
-
-    VirtualFreeEx(hProcess, lpAddress, dwSize=0, dwFreeType=MEM_RELEASE(0x8000L))
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* VirtualProtect::
-
-    VirtualProtect(lpAddress, dwSize, flNewProtect, lpflOldProtect=0)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* WaitForSingleObject::
-
-    WaitForSingleObject(hHandle, dwMilliseconds=INFINITE(0xffffffffL))
-    Errcheck:
-       raise Kernel32Error if result is NOT 0
-
-* WinVerifyTrust::
-
-    WinVerifyTrust(hwnd, pgActionID, pWVTData)
-    Errcheck:
-       Nothing special
-
-* WriteFile::
-
-    WriteFile(hFile, lpBuffer, nNumberOfBytesToWrite=None, lpNumberOfBytesWritten=None, lpOverlapped=None)
-    Errcheck:
-       raise Kernel32Error if result is 0
-
-* WriteProcessMemory::
-
-    WriteProcessMemory(hProcess, lpBaseAddress, lpBuffer, nSize=None, lpNumberOfBytesWritten=None)
-    Computer nSize with len(lpBuffer) if not given
-    Errcheck:
-       raise Kernel32Error if result is 0
-

doc/source/wip.rst

@@ -1,23 +0,0 @@
-Early Work In Progress
-======================
-
-Here are some features that are still work in progress. Code might be unstable and/or ultra-ugly.
-
-Wintrust -- Signature check
-"""""""""""""""""""""""""""
-
-Should it juste be part of :mod:`windows.utils` ?
-
-.. module:: windows.wintrust
-
-.. autofunction:: windows.wintrust.check_signature
-
-
-.. module:: windows.wmi
-
-WMI -- WMI request
-""""""""""""""""""
-
-Unstable code: not fully tested, ugly COM initialisation
-
-.. autoclass:: windows.wmi.WmiRequester

docs/build/html/.buildinfo

@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: d3f8901358333c4426690a9a7d2b42b3
+tags: 645f666f9bcd5a90fca523b33c5a78b7

docs/build/html/_modules/ctypes.html

@@ -0,0 +1,633 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>ctypes &#8212; PythonForWindows 0.4 documentation</title>
+    <link rel="stylesheet" href="../_static/classic.css" type="text/css" />
+    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+    <link rel="stylesheet" href="../_static/css/mbasic.css" type="text/css" />
+    <script type="text/javascript" src="../_static/documentation_options.js"></script>
+    <script type="text/javascript" src="../_static/jquery.js"></script>
+    <script type="text/javascript" src="../_static/underscore.js"></script>
+    <script type="text/javascript" src="../_static/doctools.js"></script>
+    <link rel="index" title="Index" href="../genindex.html" />
+    <link rel="search" title="Search" href="../search.html" /> 
+  </head><body>
+    <div class="related" role="navigation" aria-label="related navigation">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="../genindex.html" title="General Index"
+             accesskey="I">index</a></li>
+        <li class="right" >
+          <a href="../py-modindex.html" title="Python Module Index"
+             >modules</a> |</li>
+        <li class="nav-item nav-item-0"><a href="../index.html">PythonForWindows 0.4 documentation</a> &#187;</li>
+          <li class="nav-item nav-item-1"><a href="index.html" accesskey="U">Module code</a> &#187;</li> 
+      </ul>
+    </div>  
+
+    <div class="document">
+      <div class="documentwrapper">
+        <div class="bodywrapper">
+          <div class="body" role="main">
+            
+  <h1>Source code for ctypes</h1><div class="highlight"><pre>
+<span></span><span class="sd">&quot;&quot;&quot;create and manipulate C data types in Python&quot;&quot;&quot;</span>
+
+<span class="kn">import</span> <span class="nn">os</span> <span class="k">as</span> <span class="nn">_os</span><span class="o">,</span> <span class="nn">sys</span> <span class="k">as</span> <span class="nn">_sys</span>
+
+<span class="n">__version__</span> <span class="o">=</span> <span class="s2">&quot;1.1.0&quot;</span>
+
+<span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">Union</span><span class="p">,</span> <span class="n">Structure</span><span class="p">,</span> <span class="n">Array</span>
+<span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">_Pointer</span>
+<span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">CFuncPtr</span> <span class="k">as</span> <span class="n">_CFuncPtr</span>
+<span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">__version__</span> <span class="k">as</span> <span class="n">_ctypes_version</span>
+<span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">RTLD_LOCAL</span><span class="p">,</span> <span class="n">RTLD_GLOBAL</span>
+<span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">ArgumentError</span>
+
+<span class="kn">from</span> <span class="nn">struct</span> <span class="k">import</span> <span class="n">calcsize</span> <span class="k">as</span> <span class="n">_calcsize</span>
+
+<span class="k">if</span> <span class="n">__version__</span> <span class="o">!=</span> <span class="n">_ctypes_version</span><span class="p">:</span>
+    <span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">&quot;Version number mismatch&quot;</span><span class="p">,</span> <span class="n">__version__</span><span class="p">,</span> <span class="n">_ctypes_version</span><span class="p">)</span>
+
+<span class="k">if</span> <span class="n">_os</span><span class="o">.</span><span class="n">name</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">&quot;nt&quot;</span><span class="p">,</span> <span class="s2">&quot;ce&quot;</span><span class="p">):</span>
+    <span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">FormatError</span>
+
+<span class="n">DEFAULT_MODE</span> <span class="o">=</span> <span class="n">RTLD_LOCAL</span>
+<span class="k">if</span> <span class="n">_os</span><span class="o">.</span><span class="n">name</span> <span class="o">==</span> <span class="s2">&quot;posix&quot;</span> <span class="ow">and</span> <span class="n">_sys</span><span class="o">.</span><span class="n">platform</span> <span class="o">==</span> <span class="s2">&quot;darwin&quot;</span><span class="p">:</span>
+    <span class="c1"># On OS X 10.3, we use RTLD_GLOBAL as default mode</span>
+    <span class="c1"># because RTLD_LOCAL does not work at least on some</span>
+    <span class="c1"># libraries.  OS X 10.3 is Darwin 7, so we check for</span>
+    <span class="c1"># that.</span>
+
+    <span class="k">if</span> <span class="nb">int</span><span class="p">(</span><span class="n">_os</span><span class="o">.</span><span class="n">uname</span><span class="p">()[</span><span class="mi">2</span><span class="p">]</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s1">&#39;.&#39;</span><span class="p">)[</span><span class="mi">0</span><span class="p">])</span> <span class="o">&lt;</span> <span class="mi">8</span><span class="p">:</span>
+        <span class="n">DEFAULT_MODE</span> <span class="o">=</span> <span class="n">RTLD_GLOBAL</span>
+
+<span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">FUNCFLAG_CDECL</span> <span class="k">as</span> <span class="n">_FUNCFLAG_CDECL</span><span class="p">,</span> \
+     <span class="n">FUNCFLAG_PYTHONAPI</span> <span class="k">as</span> <span class="n">_FUNCFLAG_PYTHONAPI</span><span class="p">,</span> \
+     <span class="n">FUNCFLAG_USE_ERRNO</span> <span class="k">as</span> <span class="n">_FUNCFLAG_USE_ERRNO</span><span class="p">,</span> \
+     <span class="n">FUNCFLAG_USE_LASTERROR</span> <span class="k">as</span> <span class="n">_FUNCFLAG_USE_LASTERROR</span>
+
+<span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">WINOLEAPI -&gt; HRESULT</span>
+<span class="sd">WINOLEAPI_(type)</span>
+
+<span class="sd">STDMETHODCALLTYPE</span>
+
+<span class="sd">STDMETHOD(name)</span>
+<span class="sd">STDMETHOD_(type, name)</span>
+
+<span class="sd">STDAPICALLTYPE</span>
+<span class="sd">&quot;&quot;&quot;</span>
+
+<span class="k">def</span> <span class="nf">create_string_buffer</span><span class="p">(</span><span class="n">init</span><span class="p">,</span> <span class="n">size</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;create_string_buffer(aString) -&gt; character array</span>
+<span class="sd">    create_string_buffer(anInteger) -&gt; character array</span>
+<span class="sd">    create_string_buffer(aString, anInteger) -&gt; character array</span>
+<span class="sd">    &quot;&quot;&quot;</span>
+    <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">init</span><span class="p">,</span> <span class="p">(</span><span class="nb">str</span><span class="p">,</span> <span class="n">unicode</span><span class="p">)):</span>
+        <span class="k">if</span> <span class="n">size</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="n">size</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">init</span><span class="p">)</span><span class="o">+</span><span class="mi">1</span>
+        <span class="n">buftype</span> <span class="o">=</span> <span class="n">c_char</span> <span class="o">*</span> <span class="n">size</span>
+        <span class="n">buf</span> <span class="o">=</span> <span class="n">buftype</span><span class="p">()</span>
+        <span class="n">buf</span><span class="o">.</span><span class="n">value</span> <span class="o">=</span> <span class="n">init</span>
+        <span class="k">return</span> <span class="n">buf</span>
+    <span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">init</span><span class="p">,</span> <span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="n">long</span><span class="p">)):</span>
+        <span class="n">buftype</span> <span class="o">=</span> <span class="n">c_char</span> <span class="o">*</span> <span class="n">init</span>
+        <span class="n">buf</span> <span class="o">=</span> <span class="n">buftype</span><span class="p">()</span>
+        <span class="k">return</span> <span class="n">buf</span>
+    <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="n">init</span><span class="p">)</span>
+
+<span class="k">def</span> <span class="nf">c_buffer</span><span class="p">(</span><span class="n">init</span><span class="p">,</span> <span class="n">size</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
+<span class="c1">##    &quot;deprecated, use create_string_buffer instead&quot;</span>
+<span class="c1">##    import warnings</span>
+<span class="c1">##    warnings.warn(&quot;c_buffer is deprecated, use create_string_buffer instead&quot;,</span>
+<span class="c1">##                  DeprecationWarning, stacklevel=2)</span>
+    <span class="k">return</span> <span class="n">create_string_buffer</span><span class="p">(</span><span class="n">init</span><span class="p">,</span> <span class="n">size</span><span class="p">)</span>
+
+<span class="n">_c_functype_cache</span> <span class="o">=</span> <span class="p">{}</span>
+<span class="k">def</span> <span class="nf">CFUNCTYPE</span><span class="p">(</span><span class="n">restype</span><span class="p">,</span> <span class="o">*</span><span class="n">argtypes</span><span class="p">,</span> <span class="o">**</span><span class="n">kw</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;CFUNCTYPE(restype, *argtypes,</span>
+<span class="sd">                 use_errno=False, use_last_error=False) -&gt; function prototype.</span>
+
+<span class="sd">    restype: the result type</span>
+<span class="sd">    argtypes: a sequence specifying the argument types</span>
+
+<span class="sd">    The function prototype can be called in different ways to create a</span>
+<span class="sd">    callable object:</span>
+
+<span class="sd">    prototype(integer address) -&gt; foreign function</span>
+<span class="sd">    prototype(callable) -&gt; create and return a C callable function from callable</span>
+<span class="sd">    prototype(integer index, method name[, paramflags]) -&gt; foreign function calling a COM method</span>
+<span class="sd">    prototype((ordinal number, dll object)[, paramflags]) -&gt; foreign function exported by ordinal</span>
+<span class="sd">    prototype((function name, dll object)[, paramflags]) -&gt; foreign function exported by name</span>
+<span class="sd">    &quot;&quot;&quot;</span>
+    <span class="n">flags</span> <span class="o">=</span> <span class="n">_FUNCFLAG_CDECL</span>
+    <span class="k">if</span> <span class="n">kw</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="s2">&quot;use_errno&quot;</span><span class="p">,</span> <span class="kc">False</span><span class="p">):</span>
+        <span class="n">flags</span> <span class="o">|=</span> <span class="n">_FUNCFLAG_USE_ERRNO</span>
+    <span class="k">if</span> <span class="n">kw</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="s2">&quot;use_last_error&quot;</span><span class="p">,</span> <span class="kc">False</span><span class="p">):</span>
+        <span class="n">flags</span> <span class="o">|=</span> <span class="n">_FUNCFLAG_USE_LASTERROR</span>
+    <span class="k">if</span> <span class="n">kw</span><span class="p">:</span>
+        <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;unexpected keyword argument(s) </span><span class="si">%s</span><span class="s2">&quot;</span> <span class="o">%</span> <span class="n">kw</span><span class="o">.</span><span class="n">keys</span><span class="p">())</span>
+    <span class="k">try</span><span class="p">:</span>
+        <span class="k">return</span> <span class="n">_c_functype_cache</span><span class="p">[(</span><span class="n">restype</span><span class="p">,</span> <span class="n">argtypes</span><span class="p">,</span> <span class="n">flags</span><span class="p">)]</span>
+    <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
+        <span class="k">class</span> <span class="nc">CFunctionType</span><span class="p">(</span><span class="n">_CFuncPtr</span><span class="p">):</span>
+            <span class="n">_argtypes_</span> <span class="o">=</span> <span class="n">argtypes</span>
+            <span class="n">_restype_</span> <span class="o">=</span> <span class="n">restype</span>
+            <span class="n">_flags_</span> <span class="o">=</span> <span class="n">flags</span>
+        <span class="n">_c_functype_cache</span><span class="p">[(</span><span class="n">restype</span><span class="p">,</span> <span class="n">argtypes</span><span class="p">,</span> <span class="n">flags</span><span class="p">)]</span> <span class="o">=</span> <span class="n">CFunctionType</span>
+        <span class="k">return</span> <span class="n">CFunctionType</span>
+
+<span class="k">if</span> <span class="n">_os</span><span class="o">.</span><span class="n">name</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">&quot;nt&quot;</span><span class="p">,</span> <span class="s2">&quot;ce&quot;</span><span class="p">):</span>
+    <span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">LoadLibrary</span> <span class="k">as</span> <span class="n">_dlopen</span>
+    <span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">FUNCFLAG_STDCALL</span> <span class="k">as</span> <span class="n">_FUNCFLAG_STDCALL</span>
+    <span class="k">if</span> <span class="n">_os</span><span class="o">.</span><span class="n">name</span> <span class="o">==</span> <span class="s2">&quot;ce&quot;</span><span class="p">:</span>
+        <span class="c1"># &#39;ce&#39; doesn&#39;t have the stdcall calling convention</span>
+        <span class="n">_FUNCFLAG_STDCALL</span> <span class="o">=</span> <span class="n">_FUNCFLAG_CDECL</span>
+
+    <span class="n">_win_functype_cache</span> <span class="o">=</span> <span class="p">{}</span>
+    <span class="k">def</span> <span class="nf">WINFUNCTYPE</span><span class="p">(</span><span class="n">restype</span><span class="p">,</span> <span class="o">*</span><span class="n">argtypes</span><span class="p">,</span> <span class="o">**</span><span class="n">kw</span><span class="p">):</span>
+        <span class="c1"># docstring set later (very similar to CFUNCTYPE.__doc__)</span>
+        <span class="n">flags</span> <span class="o">=</span> <span class="n">_FUNCFLAG_STDCALL</span>
+        <span class="k">if</span> <span class="n">kw</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="s2">&quot;use_errno&quot;</span><span class="p">,</span> <span class="kc">False</span><span class="p">):</span>
+            <span class="n">flags</span> <span class="o">|=</span> <span class="n">_FUNCFLAG_USE_ERRNO</span>
+        <span class="k">if</span> <span class="n">kw</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="s2">&quot;use_last_error&quot;</span><span class="p">,</span> <span class="kc">False</span><span class="p">):</span>
+            <span class="n">flags</span> <span class="o">|=</span> <span class="n">_FUNCFLAG_USE_LASTERROR</span>
+        <span class="k">if</span> <span class="n">kw</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;unexpected keyword argument(s) </span><span class="si">%s</span><span class="s2">&quot;</span> <span class="o">%</span> <span class="n">kw</span><span class="o">.</span><span class="n">keys</span><span class="p">())</span>
+        <span class="k">try</span><span class="p">:</span>
+            <span class="k">return</span> <span class="n">_win_functype_cache</span><span class="p">[(</span><span class="n">restype</span><span class="p">,</span> <span class="n">argtypes</span><span class="p">,</span> <span class="n">flags</span><span class="p">)]</span>
+        <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
+            <span class="k">class</span> <span class="nc">WinFunctionType</span><span class="p">(</span><span class="n">_CFuncPtr</span><span class="p">):</span>
+                <span class="n">_argtypes_</span> <span class="o">=</span> <span class="n">argtypes</span>
+                <span class="n">_restype_</span> <span class="o">=</span> <span class="n">restype</span>
+                <span class="n">_flags_</span> <span class="o">=</span> <span class="n">flags</span>
+            <span class="n">_win_functype_cache</span><span class="p">[(</span><span class="n">restype</span><span class="p">,</span> <span class="n">argtypes</span><span class="p">,</span> <span class="n">flags</span><span class="p">)]</span> <span class="o">=</span> <span class="n">WinFunctionType</span>
+            <span class="k">return</span> <span class="n">WinFunctionType</span>
+    <span class="k">if</span> <span class="n">WINFUNCTYPE</span><span class="o">.</span><span class="vm">__doc__</span><span class="p">:</span>
+        <span class="n">WINFUNCTYPE</span><span class="o">.</span><span class="vm">__doc__</span> <span class="o">=</span> <span class="n">CFUNCTYPE</span><span class="o">.</span><span class="vm">__doc__</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s2">&quot;CFUNCTYPE&quot;</span><span class="p">,</span> <span class="s2">&quot;WINFUNCTYPE&quot;</span><span class="p">)</span>
+
+<span class="k">elif</span> <span class="n">_os</span><span class="o">.</span><span class="n">name</span> <span class="o">==</span> <span class="s2">&quot;posix&quot;</span><span class="p">:</span>
+    <span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">dlopen</span> <span class="k">as</span> <span class="n">_dlopen</span>
+
+<span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">sizeof</span><span class="p">,</span> <span class="n">byref</span><span class="p">,</span> <span class="n">addressof</span><span class="p">,</span> <span class="n">alignment</span><span class="p">,</span> <span class="n">resize</span>
+<span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">get_errno</span><span class="p">,</span> <span class="n">set_errno</span>
+<span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">_SimpleCData</span>
+
+<span class="k">def</span> <span class="nf">_check_size</span><span class="p">(</span><span class="n">typ</span><span class="p">,</span> <span class="n">typecode</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
+    <span class="c1"># Check if sizeof(ctypes_type) against struct.calcsize.  This</span>
+    <span class="c1"># should protect somewhat against a misconfigured libffi.</span>
+    <span class="kn">from</span> <span class="nn">struct</span> <span class="k">import</span> <span class="n">calcsize</span>
+    <span class="k">if</span> <span class="n">typecode</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+        <span class="c1"># Most _type_ codes are the same as used in struct</span>
+        <span class="n">typecode</span> <span class="o">=</span> <span class="n">typ</span><span class="o">.</span><span class="n">_type_</span>
+    <span class="n">actual</span><span class="p">,</span> <span class="n">required</span> <span class="o">=</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">typ</span><span class="p">),</span> <span class="n">calcsize</span><span class="p">(</span><span class="n">typecode</span><span class="p">)</span>
+    <span class="k">if</span> <span class="n">actual</span> <span class="o">!=</span> <span class="n">required</span><span class="p">:</span>
+        <span class="k">raise</span> <span class="ne">SystemError</span><span class="p">(</span><span class="s2">&quot;sizeof(</span><span class="si">%s</span><span class="s2">) wrong: </span><span class="si">%d</span><span class="s2"> instead of </span><span class="si">%d</span><span class="s2">&quot;</span> <span class="o">%</span> \
+                          <span class="p">(</span><span class="n">typ</span><span class="p">,</span> <span class="n">actual</span><span class="p">,</span> <span class="n">required</span><span class="p">))</span>
+
+<span class="k">class</span> <span class="nc">py_object</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;O&quot;</span>
+    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">try</span><span class="p">:</span>
+            <span class="k">return</span> <span class="nb">super</span><span class="p">(</span><span class="n">py_object</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="fm">__repr__</span><span class="p">()</span>
+        <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
+            <span class="k">return</span> <span class="s2">&quot;</span><span class="si">%s</span><span class="s2">(&lt;NULL&gt;)&quot;</span> <span class="o">%</span> <span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="vm">__name__</span>
+<span class="n">_check_size</span><span class="p">(</span><span class="n">py_object</span><span class="p">,</span> <span class="s2">&quot;P&quot;</span><span class="p">)</span>
+
+<span class="k">class</span> <span class="nc">c_short</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;h&quot;</span>
+<span class="n">_check_size</span><span class="p">(</span><span class="n">c_short</span><span class="p">)</span>
+
+<span class="k">class</span> <span class="nc">c_ushort</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;H&quot;</span>
+<span class="n">_check_size</span><span class="p">(</span><span class="n">c_ushort</span><span class="p">)</span>
+
+<span class="k">class</span> <span class="nc">c_long</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;l&quot;</span>
+<span class="n">_check_size</span><span class="p">(</span><span class="n">c_long</span><span class="p">)</span>
+
+<span class="k">class</span> <span class="nc">c_ulong</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;L&quot;</span>
+<span class="n">_check_size</span><span class="p">(</span><span class="n">c_ulong</span><span class="p">)</span>
+
+<span class="k">if</span> <span class="n">_calcsize</span><span class="p">(</span><span class="s2">&quot;i&quot;</span><span class="p">)</span> <span class="o">==</span> <span class="n">_calcsize</span><span class="p">(</span><span class="s2">&quot;l&quot;</span><span class="p">):</span>
+    <span class="c1"># if int and long have the same size, make c_int an alias for c_long</span>
+    <span class="n">c_int</span> <span class="o">=</span> <span class="n">c_long</span>
+    <span class="n">c_uint</span> <span class="o">=</span> <span class="n">c_ulong</span>
+<span class="k">else</span><span class="p">:</span>
+    <span class="k">class</span> <span class="nc">c_int</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+        <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;i&quot;</span>
+    <span class="n">_check_size</span><span class="p">(</span><span class="n">c_int</span><span class="p">)</span>
+
+    <span class="k">class</span> <span class="nc">c_uint</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+        <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;I&quot;</span>
+    <span class="n">_check_size</span><span class="p">(</span><span class="n">c_uint</span><span class="p">)</span>
+
+<span class="k">class</span> <span class="nc">c_float</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;f&quot;</span>
+<span class="n">_check_size</span><span class="p">(</span><span class="n">c_float</span><span class="p">)</span>
+
+<span class="k">class</span> <span class="nc">c_double</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;d&quot;</span>
+<span class="n">_check_size</span><span class="p">(</span><span class="n">c_double</span><span class="p">)</span>
+
+<span class="k">class</span> <span class="nc">c_longdouble</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;g&quot;</span>
+<span class="k">if</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">c_longdouble</span><span class="p">)</span> <span class="o">==</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">c_double</span><span class="p">):</span>
+    <span class="n">c_longdouble</span> <span class="o">=</span> <span class="n">c_double</span>
+
+<span class="k">if</span> <span class="n">_calcsize</span><span class="p">(</span><span class="s2">&quot;l&quot;</span><span class="p">)</span> <span class="o">==</span> <span class="n">_calcsize</span><span class="p">(</span><span class="s2">&quot;q&quot;</span><span class="p">):</span>
+    <span class="c1"># if long and long long have the same size, make c_longlong an alias for c_long</span>
+    <span class="n">c_longlong</span> <span class="o">=</span> <span class="n">c_long</span>
+    <span class="n">c_ulonglong</span> <span class="o">=</span> <span class="n">c_ulong</span>
+<span class="k">else</span><span class="p">:</span>
+    <span class="k">class</span> <span class="nc">c_longlong</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+        <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;q&quot;</span>
+    <span class="n">_check_size</span><span class="p">(</span><span class="n">c_longlong</span><span class="p">)</span>
+
+    <span class="k">class</span> <span class="nc">c_ulonglong</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+        <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;Q&quot;</span>
+    <span class="c1">##    def from_param(cls, val):</span>
+    <span class="c1">##        return (&#39;d&#39;, float(val), val)</span>
+    <span class="c1">##    from_param = classmethod(from_param)</span>
+    <span class="n">_check_size</span><span class="p">(</span><span class="n">c_ulonglong</span><span class="p">)</span>
+
+<span class="k">class</span> <span class="nc">c_ubyte</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;B&quot;</span>
+<span class="n">c_ubyte</span><span class="o">.</span><span class="n">__ctype_le__</span> <span class="o">=</span> <span class="n">c_ubyte</span><span class="o">.</span><span class="n">__ctype_be__</span> <span class="o">=</span> <span class="n">c_ubyte</span>
+<span class="c1"># backward compatibility:</span>
+<span class="c1">##c_uchar = c_ubyte</span>
+<span class="n">_check_size</span><span class="p">(</span><span class="n">c_ubyte</span><span class="p">)</span>
+
+<span class="k">class</span> <span class="nc">c_byte</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;b&quot;</span>
+<span class="n">c_byte</span><span class="o">.</span><span class="n">__ctype_le__</span> <span class="o">=</span> <span class="n">c_byte</span><span class="o">.</span><span class="n">__ctype_be__</span> <span class="o">=</span> <span class="n">c_byte</span>
+<span class="n">_check_size</span><span class="p">(</span><span class="n">c_byte</span><span class="p">)</span>
+
+<span class="k">class</span> <span class="nc">c_char</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;c&quot;</span>
+<span class="n">c_char</span><span class="o">.</span><span class="n">__ctype_le__</span> <span class="o">=</span> <span class="n">c_char</span><span class="o">.</span><span class="n">__ctype_be__</span> <span class="o">=</span> <span class="n">c_char</span>
+<span class="n">_check_size</span><span class="p">(</span><span class="n">c_char</span><span class="p">)</span>
+
+<span class="k">class</span> <span class="nc">c_char_p</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;z&quot;</span>
+    <span class="k">if</span> <span class="n">_os</span><span class="o">.</span><span class="n">name</span> <span class="o">==</span> <span class="s2">&quot;nt&quot;</span><span class="p">:</span>
+        <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+            <span class="k">if</span> <span class="ow">not</span> <span class="n">windll</span><span class="o">.</span><span class="n">kernel32</span><span class="o">.</span><span class="n">IsBadStringPtrA</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">):</span>
+                <span class="k">return</span> <span class="s2">&quot;</span><span class="si">%s</span><span class="s2">(</span><span class="si">%r</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">value</span><span class="p">)</span>
+            <span class="k">return</span> <span class="s2">&quot;</span><span class="si">%s</span><span class="s2">(</span><span class="si">%s</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,</span> <span class="n">cast</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">c_void_p</span><span class="p">)</span><span class="o">.</span><span class="n">value</span><span class="p">)</span>
+    <span class="k">else</span><span class="p">:</span>
+        <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+            <span class="k">return</span> <span class="s2">&quot;</span><span class="si">%s</span><span class="s2">(</span><span class="si">%s</span><span class="s2">)&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,</span> <span class="n">cast</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">c_void_p</span><span class="p">)</span><span class="o">.</span><span class="n">value</span><span class="p">)</span>
+<span class="n">_check_size</span><span class="p">(</span><span class="n">c_char_p</span><span class="p">,</span> <span class="s2">&quot;P&quot;</span><span class="p">)</span>
+
+<span class="k">class</span> <span class="nc">c_void_p</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;P&quot;</span>
+<span class="n">c_voidp</span> <span class="o">=</span> <span class="n">c_void_p</span> <span class="c1"># backwards compatibility (to a bug)</span>
+<span class="n">_check_size</span><span class="p">(</span><span class="n">c_void_p</span><span class="p">)</span>
+
+<span class="k">class</span> <span class="nc">c_bool</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+    <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;?&quot;</span>
+
+<span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">POINTER</span><span class="p">,</span> <span class="n">pointer</span><span class="p">,</span> <span class="n">_pointer_type_cache</span>
+
+<span class="k">def</span> <span class="nf">_reset_cache</span><span class="p">():</span>
+    <span class="n">_pointer_type_cache</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
+    <span class="n">_c_functype_cache</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
+    <span class="k">if</span> <span class="n">_os</span><span class="o">.</span><span class="n">name</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">&quot;nt&quot;</span><span class="p">,</span> <span class="s2">&quot;ce&quot;</span><span class="p">):</span>
+        <span class="n">_win_functype_cache</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
+    <span class="c1"># _SimpleCData.c_wchar_p_from_param</span>
+    <span class="n">POINTER</span><span class="p">(</span><span class="n">c_wchar</span><span class="p">)</span><span class="o">.</span><span class="n">from_param</span> <span class="o">=</span> <span class="n">c_wchar_p</span><span class="o">.</span><span class="n">from_param</span>
+    <span class="c1"># _SimpleCData.c_char_p_from_param</span>
+    <span class="n">POINTER</span><span class="p">(</span><span class="n">c_char</span><span class="p">)</span><span class="o">.</span><span class="n">from_param</span> <span class="o">=</span> <span class="n">c_char_p</span><span class="o">.</span><span class="n">from_param</span>
+    <span class="n">_pointer_type_cache</span><span class="p">[</span><span class="kc">None</span><span class="p">]</span> <span class="o">=</span> <span class="n">c_void_p</span>
+    <span class="c1"># XXX for whatever reasons, creating the first instance of a callback</span>
+    <span class="c1"># function is needed for the unittests on Win64 to succeed.  This MAY</span>
+    <span class="c1"># be a compiler bug, since the problem occurs only when _ctypes is</span>
+    <span class="c1"># compiled with the MS SDK compiler.  Or an uninitialized variable?</span>
+    <span class="n">CFUNCTYPE</span><span class="p">(</span><span class="n">c_int</span><span class="p">)(</span><span class="k">lambda</span><span class="p">:</span> <span class="kc">None</span><span class="p">)</span>
+
+<span class="k">try</span><span class="p">:</span>
+    <span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">set_conversion_mode</span>
+<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
+    <span class="k">pass</span>
+<span class="k">else</span><span class="p">:</span>
+    <span class="k">if</span> <span class="n">_os</span><span class="o">.</span><span class="n">name</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">&quot;nt&quot;</span><span class="p">,</span> <span class="s2">&quot;ce&quot;</span><span class="p">):</span>
+        <span class="n">set_conversion_mode</span><span class="p">(</span><span class="s2">&quot;mbcs&quot;</span><span class="p">,</span> <span class="s2">&quot;ignore&quot;</span><span class="p">)</span>
+    <span class="k">else</span><span class="p">:</span>
+        <span class="n">set_conversion_mode</span><span class="p">(</span><span class="s2">&quot;ascii&quot;</span><span class="p">,</span> <span class="s2">&quot;strict&quot;</span><span class="p">)</span>
+
+    <span class="k">class</span> <span class="nc">c_wchar_p</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+        <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;Z&quot;</span>
+
+    <span class="k">class</span> <span class="nc">c_wchar</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+        <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;u&quot;</span>
+
+    <span class="k">def</span> <span class="nf">create_unicode_buffer</span><span class="p">(</span><span class="n">init</span><span class="p">,</span> <span class="n">size</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;create_unicode_buffer(aString) -&gt; character array</span>
+<span class="sd">        create_unicode_buffer(anInteger) -&gt; character array</span>
+<span class="sd">        create_unicode_buffer(aString, anInteger) -&gt; character array</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">init</span><span class="p">,</span> <span class="p">(</span><span class="nb">str</span><span class="p">,</span> <span class="n">unicode</span><span class="p">)):</span>
+            <span class="k">if</span> <span class="n">size</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+                <span class="n">size</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">init</span><span class="p">)</span><span class="o">+</span><span class="mi">1</span>
+            <span class="n">buftype</span> <span class="o">=</span> <span class="n">c_wchar</span> <span class="o">*</span> <span class="n">size</span>
+            <span class="n">buf</span> <span class="o">=</span> <span class="n">buftype</span><span class="p">()</span>
+            <span class="n">buf</span><span class="o">.</span><span class="n">value</span> <span class="o">=</span> <span class="n">init</span>
+            <span class="k">return</span> <span class="n">buf</span>
+        <span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">init</span><span class="p">,</span> <span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="n">long</span><span class="p">)):</span>
+            <span class="n">buftype</span> <span class="o">=</span> <span class="n">c_wchar</span> <span class="o">*</span> <span class="n">init</span>
+            <span class="n">buf</span> <span class="o">=</span> <span class="n">buftype</span><span class="p">()</span>
+            <span class="k">return</span> <span class="n">buf</span>
+        <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="n">init</span><span class="p">)</span>
+
+<span class="c1"># XXX Deprecated</span>
+<span class="k">def</span> <span class="nf">SetPointerType</span><span class="p">(</span><span class="n">pointer</span><span class="p">,</span> <span class="bp">cls</span><span class="p">):</span>
+    <span class="k">if</span> <span class="n">_pointer_type_cache</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
+        <span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s2">&quot;This type already exists in the cache&quot;</span><span class="p">)</span>
+    <span class="k">if</span> <span class="nb">id</span><span class="p">(</span><span class="n">pointer</span><span class="p">)</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">_pointer_type_cache</span><span class="p">:</span>
+        <span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s2">&quot;What&#39;s this???&quot;</span><span class="p">)</span>
+    <span class="n">pointer</span><span class="o">.</span><span class="n">set_type</span><span class="p">(</span><span class="bp">cls</span><span class="p">)</span>
+    <span class="n">_pointer_type_cache</span><span class="p">[</span><span class="bp">cls</span><span class="p">]</span> <span class="o">=</span> <span class="n">pointer</span>
+    <span class="k">del</span> <span class="n">_pointer_type_cache</span><span class="p">[</span><span class="nb">id</span><span class="p">(</span><span class="n">pointer</span><span class="p">)]</span>
+
+<span class="c1"># XXX Deprecated</span>
+<span class="k">def</span> <span class="nf">ARRAY</span><span class="p">(</span><span class="n">typ</span><span class="p">,</span> <span class="nb">len</span><span class="p">):</span>
+    <span class="k">return</span> <span class="n">typ</span> <span class="o">*</span> <span class="nb">len</span>
+
+<span class="c1">################################################################</span>
+
+
+<span class="k">class</span> <span class="nc">CDLL</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;An instance of this class represents a loaded dll/shared</span>
+<span class="sd">    library, exporting functions using the standard C calling</span>
+<span class="sd">    convention (named &#39;cdecl&#39; on Windows).</span>
+
+<span class="sd">    The exported functions can be accessed as attributes, or by</span>
+<span class="sd">    indexing with the function name.  Examples:</span>
+
+<span class="sd">    &lt;obj&gt;.qsort -&gt; callable object</span>
+<span class="sd">    &lt;obj&gt;[&#39;qsort&#39;] -&gt; callable object</span>
+
+<span class="sd">    Calling the functions releases the Python GIL during the call and</span>
+<span class="sd">    reacquires it afterwards.</span>
+<span class="sd">    &quot;&quot;&quot;</span>
+    <span class="n">_func_flags_</span> <span class="o">=</span> <span class="n">_FUNCFLAG_CDECL</span>
+    <span class="n">_func_restype_</span> <span class="o">=</span> <span class="n">c_int</span>
+
+    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="n">DEFAULT_MODE</span><span class="p">,</span> <span class="n">handle</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span>
+                 <span class="n">use_errno</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
+                 <span class="n">use_last_error</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">_name</span> <span class="o">=</span> <span class="n">name</span>
+        <span class="n">flags</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_func_flags_</span>
+        <span class="k">if</span> <span class="n">use_errno</span><span class="p">:</span>
+            <span class="n">flags</span> <span class="o">|=</span> <span class="n">_FUNCFLAG_USE_ERRNO</span>
+        <span class="k">if</span> <span class="n">use_last_error</span><span class="p">:</span>
+            <span class="n">flags</span> <span class="o">|=</span> <span class="n">_FUNCFLAG_USE_LASTERROR</span>
+
+        <span class="k">class</span> <span class="nc">_FuncPtr</span><span class="p">(</span><span class="n">_CFuncPtr</span><span class="p">):</span>
+            <span class="n">_flags_</span> <span class="o">=</span> <span class="n">flags</span>
+            <span class="n">_restype_</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_func_restype_</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">_FuncPtr</span> <span class="o">=</span> <span class="n">_FuncPtr</span>
+
+        <span class="k">if</span> <span class="n">handle</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">_handle</span> <span class="o">=</span> <span class="n">_dlopen</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_name</span><span class="p">,</span> <span class="n">mode</span><span class="p">)</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">_handle</span> <span class="o">=</span> <span class="n">handle</span>
+
+    <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">return</span> <span class="s2">&quot;&lt;</span><span class="si">%s</span><span class="s2"> &#39;</span><span class="si">%s</span><span class="s2">&#39;, handle </span><span class="si">%x</span><span class="s2"> at </span><span class="si">%x</span><span class="s2">&gt;&quot;</span> <span class="o">%</span> \
+               <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">_name</span><span class="p">,</span>
+                <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_handle</span> <span class="o">&amp;</span> <span class="p">(</span><span class="n">_sys</span><span class="o">.</span><span class="n">maxint</span><span class="o">*</span><span class="mi">2</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)),</span>
+                <span class="nb">id</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">&amp;</span> <span class="p">(</span><span class="n">_sys</span><span class="o">.</span><span class="n">maxint</span><span class="o">*</span><span class="mi">2</span> <span class="o">+</span> <span class="mi">1</span><span class="p">))</span>
+
+    <span class="k">def</span> <span class="nf">__getattr__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
+        <span class="k">if</span> <span class="n">name</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s1">&#39;__&#39;</span><span class="p">)</span> <span class="ow">and</span> <span class="n">name</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="s1">&#39;__&#39;</span><span class="p">):</span>
+            <span class="k">raise</span> <span class="ne">AttributeError</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
+        <span class="n">func</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="fm">__getitem__</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
+        <span class="nb">setattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">func</span><span class="p">)</span>
+        <span class="k">return</span> <span class="n">func</span>
+
+    <span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name_or_ordinal</span><span class="p">):</span>
+        <span class="n">func</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_FuncPtr</span><span class="p">((</span><span class="n">name_or_ordinal</span><span class="p">,</span> <span class="bp">self</span><span class="p">))</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">name_or_ordinal</span><span class="p">,</span> <span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="n">long</span><span class="p">)):</span>
+            <span class="n">func</span><span class="o">.</span><span class="vm">__name__</span> <span class="o">=</span> <span class="n">name_or_ordinal</span>
+        <span class="k">return</span> <span class="n">func</span>
+
+<span class="k">class</span> <span class="nc">PyDLL</span><span class="p">(</span><span class="n">CDLL</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;This class represents the Python library itself.  It allows</span>
+<span class="sd">    accessing Python API functions.  The GIL is not released, and</span>
+<span class="sd">    Python exceptions are handled correctly.</span>
+<span class="sd">    &quot;&quot;&quot;</span>
+    <span class="n">_func_flags_</span> <span class="o">=</span> <span class="n">_FUNCFLAG_CDECL</span> <span class="o">|</span> <span class="n">_FUNCFLAG_PYTHONAPI</span>
+
+<span class="k">if</span> <span class="n">_os</span><span class="o">.</span><span class="n">name</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">&quot;nt&quot;</span><span class="p">,</span> <span class="s2">&quot;ce&quot;</span><span class="p">):</span>
+
+    <span class="k">class</span> <span class="nc">WinDLL</span><span class="p">(</span><span class="n">CDLL</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;This class represents a dll exporting functions using the</span>
+<span class="sd">        Windows stdcall calling convention.</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="n">_func_flags_</span> <span class="o">=</span> <span class="n">_FUNCFLAG_STDCALL</span>
+
+    <span class="c1"># XXX Hm, what about HRESULT as normal parameter?</span>
+    <span class="c1"># Mustn&#39;t it derive from c_long then?</span>
+    <span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">_check_HRESULT</span><span class="p">,</span> <span class="n">_SimpleCData</span>
+    <span class="k">class</span> <span class="nc">HRESULT</span><span class="p">(</span><span class="n">_SimpleCData</span><span class="p">):</span>
+        <span class="n">_type_</span> <span class="o">=</span> <span class="s2">&quot;l&quot;</span>
+        <span class="c1"># _check_retval_ is called with the function&#39;s result when it</span>
+        <span class="c1"># is used as restype.  It checks for the FAILED bit, and</span>
+        <span class="c1"># raises a WindowsError if it is set.</span>
+        <span class="c1">#</span>
+        <span class="c1"># The _check_retval_ method is implemented in C, so that the</span>
+        <span class="c1"># method definition itself is not included in the traceback</span>
+        <span class="c1"># when it raises an error - that is what we want (and Python</span>
+        <span class="c1"># doesn&#39;t have a way to raise an exception in the caller&#39;s</span>
+        <span class="c1"># frame).</span>
+        <span class="n">_check_retval_</span> <span class="o">=</span> <span class="n">_check_HRESULT</span>
+
+    <span class="k">class</span> <span class="nc">OleDLL</span><span class="p">(</span><span class="n">CDLL</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;This class represents a dll exporting functions using the</span>
+<span class="sd">        Windows stdcall calling convention, and returning HRESULT.</span>
+<span class="sd">        HRESULT error values are automatically raised as WindowsError</span>
+<span class="sd">        exceptions.</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="n">_func_flags_</span> <span class="o">=</span> <span class="n">_FUNCFLAG_STDCALL</span>
+        <span class="n">_func_restype_</span> <span class="o">=</span> <span class="n">HRESULT</span>
+
+<span class="k">class</span> <span class="nc">LibraryLoader</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
+    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">dlltype</span><span class="p">):</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">_dlltype</span> <span class="o">=</span> <span class="n">dlltype</span>
+
+    <span class="k">def</span> <span class="nf">__getattr__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
+        <span class="k">if</span> <span class="n">name</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">==</span> <span class="s1">&#39;_&#39;</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">AttributeError</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
+        <span class="n">dll</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_dlltype</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
+        <span class="nb">setattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">dll</span><span class="p">)</span>
+        <span class="k">return</span> <span class="n">dll</span>
+
+    <span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
+        <span class="k">return</span> <span class="nb">getattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span>
+
+    <span class="k">def</span> <span class="nf">LoadLibrary</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_dlltype</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
+
+<span class="n">cdll</span> <span class="o">=</span> <span class="n">LibraryLoader</span><span class="p">(</span><span class="n">CDLL</span><span class="p">)</span>
+<span class="n">pydll</span> <span class="o">=</span> <span class="n">LibraryLoader</span><span class="p">(</span><span class="n">PyDLL</span><span class="p">)</span>
+
+<span class="k">if</span> <span class="n">_os</span><span class="o">.</span><span class="n">name</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">&quot;nt&quot;</span><span class="p">,</span> <span class="s2">&quot;ce&quot;</span><span class="p">):</span>
+    <span class="n">pythonapi</span> <span class="o">=</span> <span class="n">PyDLL</span><span class="p">(</span><span class="s2">&quot;python dll&quot;</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="n">_sys</span><span class="o">.</span><span class="n">dllhandle</span><span class="p">)</span>
+<span class="k">elif</span> <span class="n">_sys</span><span class="o">.</span><span class="n">platform</span> <span class="o">==</span> <span class="s2">&quot;cygwin&quot;</span><span class="p">:</span>
+    <span class="n">pythonapi</span> <span class="o">=</span> <span class="n">PyDLL</span><span class="p">(</span><span class="s2">&quot;libpython</span><span class="si">%d</span><span class="s2">.</span><span class="si">%d</span><span class="s2">.dll&quot;</span> <span class="o">%</span> <span class="n">_sys</span><span class="o">.</span><span class="n">version_info</span><span class="p">[:</span><span class="mi">2</span><span class="p">])</span>
+<span class="k">else</span><span class="p">:</span>
+    <span class="n">pythonapi</span> <span class="o">=</span> <span class="n">PyDLL</span><span class="p">(</span><span class="kc">None</span><span class="p">)</span>
+
+
+<span class="k">if</span> <span class="n">_os</span><span class="o">.</span><span class="n">name</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">&quot;nt&quot;</span><span class="p">,</span> <span class="s2">&quot;ce&quot;</span><span class="p">):</span>
+    <span class="n">windll</span> <span class="o">=</span> <span class="n">LibraryLoader</span><span class="p">(</span><span class="n">WinDLL</span><span class="p">)</span>
+    <span class="n">oledll</span> <span class="o">=</span> <span class="n">LibraryLoader</span><span class="p">(</span><span class="n">OleDLL</span><span class="p">)</span>
+
+    <span class="k">if</span> <span class="n">_os</span><span class="o">.</span><span class="n">name</span> <span class="o">==</span> <span class="s2">&quot;nt&quot;</span><span class="p">:</span>
+        <span class="n">GetLastError</span> <span class="o">=</span> <span class="n">windll</span><span class="o">.</span><span class="n">kernel32</span><span class="o">.</span><span class="n">GetLastError</span>
+    <span class="k">else</span><span class="p">:</span>
+        <span class="n">GetLastError</span> <span class="o">=</span> <span class="n">windll</span><span class="o">.</span><span class="n">coredll</span><span class="o">.</span><span class="n">GetLastError</span>
+    <span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">get_last_error</span><span class="p">,</span> <span class="n">set_last_error</span>
+
+    <span class="k">def</span> <span class="nf">WinError</span><span class="p">(</span><span class="n">code</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">descr</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
+        <span class="k">if</span> <span class="n">code</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="n">code</span> <span class="o">=</span> <span class="n">GetLastError</span><span class="p">()</span>
+        <span class="k">if</span> <span class="n">descr</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="n">descr</span> <span class="o">=</span> <span class="n">FormatError</span><span class="p">(</span><span class="n">code</span><span class="p">)</span><span class="o">.</span><span class="n">strip</span><span class="p">()</span>
+        <span class="k">return</span> <span class="ne">WindowsError</span><span class="p">(</span><span class="n">code</span><span class="p">,</span> <span class="n">descr</span><span class="p">)</span>
+
+<span class="k">if</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">c_uint</span><span class="p">)</span> <span class="o">==</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">c_void_p</span><span class="p">):</span>
+    <span class="n">c_size_t</span> <span class="o">=</span> <span class="n">c_uint</span>
+    <span class="n">c_ssize_t</span> <span class="o">=</span> <span class="n">c_int</span>
+<span class="k">elif</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">c_ulong</span><span class="p">)</span> <span class="o">==</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">c_void_p</span><span class="p">):</span>
+    <span class="n">c_size_t</span> <span class="o">=</span> <span class="n">c_ulong</span>
+    <span class="n">c_ssize_t</span> <span class="o">=</span> <span class="n">c_long</span>
+<span class="k">elif</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">c_ulonglong</span><span class="p">)</span> <span class="o">==</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">c_void_p</span><span class="p">):</span>
+    <span class="n">c_size_t</span> <span class="o">=</span> <span class="n">c_ulonglong</span>
+    <span class="n">c_ssize_t</span> <span class="o">=</span> <span class="n">c_longlong</span>
+
+<span class="c1"># functions</span>
+
+<span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">_memmove_addr</span><span class="p">,</span> <span class="n">_memset_addr</span><span class="p">,</span> <span class="n">_string_at_addr</span><span class="p">,</span> <span class="n">_cast_addr</span>
+
+<span class="c1">## void *memmove(void *, const void *, size_t);</span>
+<span class="n">memmove</span> <span class="o">=</span> <span class="n">CFUNCTYPE</span><span class="p">(</span><span class="n">c_void_p</span><span class="p">,</span> <span class="n">c_void_p</span><span class="p">,</span> <span class="n">c_void_p</span><span class="p">,</span> <span class="n">c_size_t</span><span class="p">)(</span><span class="n">_memmove_addr</span><span class="p">)</span>
+
+<span class="c1">## void *memset(void *, int, size_t)</span>
+<span class="n">memset</span> <span class="o">=</span> <span class="n">CFUNCTYPE</span><span class="p">(</span><span class="n">c_void_p</span><span class="p">,</span> <span class="n">c_void_p</span><span class="p">,</span> <span class="n">c_int</span><span class="p">,</span> <span class="n">c_size_t</span><span class="p">)(</span><span class="n">_memset_addr</span><span class="p">)</span>
+
+<span class="k">def</span> <span class="nf">PYFUNCTYPE</span><span class="p">(</span><span class="n">restype</span><span class="p">,</span> <span class="o">*</span><span class="n">argtypes</span><span class="p">):</span>
+    <span class="k">class</span> <span class="nc">CFunctionType</span><span class="p">(</span><span class="n">_CFuncPtr</span><span class="p">):</span>
+        <span class="n">_argtypes_</span> <span class="o">=</span> <span class="n">argtypes</span>
+        <span class="n">_restype_</span> <span class="o">=</span> <span class="n">restype</span>
+        <span class="n">_flags_</span> <span class="o">=</span> <span class="n">_FUNCFLAG_CDECL</span> <span class="o">|</span> <span class="n">_FUNCFLAG_PYTHONAPI</span>
+    <span class="k">return</span> <span class="n">CFunctionType</span>
+
+<span class="n">_cast</span> <span class="o">=</span> <span class="n">PYFUNCTYPE</span><span class="p">(</span><span class="n">py_object</span><span class="p">,</span> <span class="n">c_void_p</span><span class="p">,</span> <span class="n">py_object</span><span class="p">,</span> <span class="n">py_object</span><span class="p">)(</span><span class="n">_cast_addr</span><span class="p">)</span>
+<span class="k">def</span> <span class="nf">cast</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">typ</span><span class="p">):</span>
+    <span class="k">return</span> <span class="n">_cast</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">obj</span><span class="p">,</span> <span class="n">typ</span><span class="p">)</span>
+
+<span class="n">_string_at</span> <span class="o">=</span> <span class="n">PYFUNCTYPE</span><span class="p">(</span><span class="n">py_object</span><span class="p">,</span> <span class="n">c_void_p</span><span class="p">,</span> <span class="n">c_int</span><span class="p">)(</span><span class="n">_string_at_addr</span><span class="p">)</span>
+<span class="k">def</span> <span class="nf">string_at</span><span class="p">(</span><span class="n">ptr</span><span class="p">,</span> <span class="n">size</span><span class="o">=-</span><span class="mi">1</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;string_at(addr[, size]) -&gt; string</span>
+
+<span class="sd">    Return the string at addr.&quot;&quot;&quot;</span>
+    <span class="k">return</span> <span class="n">_string_at</span><span class="p">(</span><span class="n">ptr</span><span class="p">,</span> <span class="n">size</span><span class="p">)</span>
+
+<span class="k">try</span><span class="p">:</span>
+    <span class="kn">from</span> <span class="nn">_ctypes</span> <span class="k">import</span> <span class="n">_wstring_at_addr</span>
+<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
+    <span class="k">pass</span>
+<span class="k">else</span><span class="p">:</span>
+    <span class="n">_wstring_at</span> <span class="o">=</span> <span class="n">PYFUNCTYPE</span><span class="p">(</span><span class="n">py_object</span><span class="p">,</span> <span class="n">c_void_p</span><span class="p">,</span> <span class="n">c_int</span><span class="p">)(</span><span class="n">_wstring_at_addr</span><span class="p">)</span>
+    <span class="k">def</span> <span class="nf">wstring_at</span><span class="p">(</span><span class="n">ptr</span><span class="p">,</span> <span class="n">size</span><span class="o">=-</span><span class="mi">1</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;wstring_at(addr[, size]) -&gt; string</span>
+
+<span class="sd">        Return the string at addr.&quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="n">_wstring_at</span><span class="p">(</span><span class="n">ptr</span><span class="p">,</span> <span class="n">size</span><span class="p">)</span>
+
+
+<span class="k">if</span> <span class="n">_os</span><span class="o">.</span><span class="n">name</span> <span class="ow">in</span> <span class="p">(</span><span class="s2">&quot;nt&quot;</span><span class="p">,</span> <span class="s2">&quot;ce&quot;</span><span class="p">):</span> <span class="c1"># COM stuff</span>
+    <span class="k">def</span> <span class="nf">DllGetClassObject</span><span class="p">(</span><span class="n">rclsid</span><span class="p">,</span> <span class="n">riid</span><span class="p">,</span> <span class="n">ppv</span><span class="p">):</span>
+        <span class="k">try</span><span class="p">:</span>
+            <span class="n">ccom</span> <span class="o">=</span> <span class="nb">__import__</span><span class="p">(</span><span class="s2">&quot;comtypes.server.inprocserver&quot;</span><span class="p">,</span> <span class="nb">globals</span><span class="p">(),</span> <span class="nb">locals</span><span class="p">(),</span> <span class="p">[</span><span class="s1">&#39;*&#39;</span><span class="p">])</span>
+        <span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
+            <span class="k">return</span> <span class="o">-</span><span class="mi">2147221231</span> <span class="c1"># CLASS_E_CLASSNOTAVAILABLE</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="k">return</span> <span class="n">ccom</span><span class="o">.</span><span class="n">DllGetClassObject</span><span class="p">(</span><span class="n">rclsid</span><span class="p">,</span> <span class="n">riid</span><span class="p">,</span> <span class="n">ppv</span><span class="p">)</span>
+
+    <span class="k">def</span> <span class="nf">DllCanUnloadNow</span><span class="p">():</span>
+        <span class="k">try</span><span class="p">:</span>
+            <span class="n">ccom</span> <span class="o">=</span> <span class="nb">__import__</span><span class="p">(</span><span class="s2">&quot;comtypes.server.inprocserver&quot;</span><span class="p">,</span> <span class="nb">globals</span><span class="p">(),</span> <span class="nb">locals</span><span class="p">(),</span> <span class="p">[</span><span class="s1">&#39;*&#39;</span><span class="p">])</span>
+        <span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
+            <span class="k">return</span> <span class="mi">0</span> <span class="c1"># S_OK</span>
+        <span class="k">return</span> <span class="n">ccom</span><span class="o">.</span><span class="n">DllCanUnloadNow</span><span class="p">()</span>
+
+<span class="kn">from</span> <span class="nn">ctypes._endian</span> <span class="k">import</span> <span class="n">BigEndianStructure</span><span class="p">,</span> <span class="n">LittleEndianStructure</span>
+
+<span class="c1"># Fill in specifically-sized types</span>
+<span class="n">c_int8</span> <span class="o">=</span> <span class="n">c_byte</span>
+<span class="n">c_uint8</span> <span class="o">=</span> <span class="n">c_ubyte</span>
+<span class="k">for</span> <span class="n">kind</span> <span class="ow">in</span> <span class="p">[</span><span class="n">c_short</span><span class="p">,</span> <span class="n">c_int</span><span class="p">,</span> <span class="n">c_long</span><span class="p">,</span> <span class="n">c_longlong</span><span class="p">]:</span>
+    <span class="k">if</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">kind</span><span class="p">)</span> <span class="o">==</span> <span class="mi">2</span><span class="p">:</span> <span class="n">c_int16</span> <span class="o">=</span> <span class="n">kind</span>
+    <span class="k">elif</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">kind</span><span class="p">)</span> <span class="o">==</span> <span class="mi">4</span><span class="p">:</span> <span class="n">c_int32</span> <span class="o">=</span> <span class="n">kind</span>
+    <span class="k">elif</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">kind</span><span class="p">)</span> <span class="o">==</span> <span class="mi">8</span><span class="p">:</span> <span class="n">c_int64</span> <span class="o">=</span> <span class="n">kind</span>
+<span class="k">for</span> <span class="n">kind</span> <span class="ow">in</span> <span class="p">[</span><span class="n">c_ushort</span><span class="p">,</span> <span class="n">c_uint</span><span class="p">,</span> <span class="n">c_ulong</span><span class="p">,</span> <span class="n">c_ulonglong</span><span class="p">]:</span>
+    <span class="k">if</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">kind</span><span class="p">)</span> <span class="o">==</span> <span class="mi">2</span><span class="p">:</span> <span class="n">c_uint16</span> <span class="o">=</span> <span class="n">kind</span>
+    <span class="k">elif</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">kind</span><span class="p">)</span> <span class="o">==</span> <span class="mi">4</span><span class="p">:</span> <span class="n">c_uint32</span> <span class="o">=</span> <span class="n">kind</span>
+    <span class="k">elif</span> <span class="n">sizeof</span><span class="p">(</span><span class="n">kind</span><span class="p">)</span> <span class="o">==</span> <span class="mi">8</span><span class="p">:</span> <span class="n">c_uint64</span> <span class="o">=</span> <span class="n">kind</span>
+<span class="k">del</span><span class="p">(</span><span class="n">kind</span><span class="p">)</span>
+
+<span class="n">_reset_cache</span><span class="p">()</span>
+</pre></div>
+
+          </div>
+        </div>
+      </div>
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+<div id="searchbox" style="display: none" role="search">
+  <h3>Quick search</h3>
+    <div class="searchformwrapper">
+    <form class="search" action="../search.html" method="get">
+      <input type="text" name="q" />
+      <input type="submit" value="Go" />
+      <input type="hidden" name="check_keywords" value="yes" />
+      <input type="hidden" name="area" value="default" />
+    </form>
+    </div>
+</div>
+<script type="text/javascript">$('#searchbox').show(0);</script>
+        </div>
+      </div>
+      <div class="clearer"></div>
+    </div>
+    <div class="related" role="navigation" aria-label="related navigation">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="../genindex.html" title="General Index"
+             >index</a></li>
+        <li class="right" >
+          <a href="../py-modindex.html" title="Python Module Index"
+             >modules</a> |</li>
+        <li class="nav-item nav-item-0"><a href="../index.html">PythonForWindows 0.4 documentation</a> &#187;</li>
+          <li class="nav-item nav-item-1"><a href="index.html" >Module code</a> &#187;</li> 
+      </ul>
+    </div>
+    <div class="footer" role="contentinfo">
+        &#169; Copyright 2015, Clement Rouault.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.7.1.
+    </div>
+  </body>
+</html>

docs/build/html/_modules/index.html

@@ -0,0 +1,116 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>Overview: module code &#8212; PythonForWindows 0.4 documentation</title>
+    <link rel="stylesheet" href="../_static/classic.css" type="text/css" />
+    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
+    <link rel="stylesheet" href="../_static/css/mbasic.css" type="text/css" />
+    <script type="text/javascript" src="../_static/documentation_options.js"></script>
+    <script type="text/javascript" src="../_static/jquery.js"></script>
+    <script type="text/javascript" src="../_static/underscore.js"></script>
+    <script type="text/javascript" src="../_static/doctools.js"></script>
+    <link rel="index" title="Index" href="../genindex.html" />
+    <link rel="search" title="Search" href="../search.html" /> 
+  </head><body>
+    <div class="related" role="navigation" aria-label="related navigation">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="../genindex.html" title="General Index"
+             accesskey="I">index</a></li>
+        <li class="right" >
+          <a href="../py-modindex.html" title="Python Module Index"
+             >modules</a> |</li>
+        <li class="nav-item nav-item-0"><a href="../index.html">PythonForWindows 0.4 documentation</a> &#187;</li> 
+      </ul>
+    </div>  
+
+    <div class="document">
+      <div class="documentwrapper">
+        <div class="bodywrapper">
+          <div class="body" role="main">
+            
+  <h1>All modules for which code is available</h1>
+<ul><li><a href="ctypes.html">ctypes</a></li>
+<li><a href="windows/alpc.html">windows.alpc</a></li>
+<li><a href="windows/com.html">windows.com</a></li>
+<li><a href="windows/crypto/certificate.html">windows.crypto.certificate</a></li>
+<li><a href="windows/crypto/cryptmsg.html">windows.crypto.cryptmsg</a></li>
+<li><a href="windows/crypto/encrypt_decrypt.html">windows.crypto.encrypt_decrypt</a></li>
+<li><a href="windows/crypto/generation.html">windows.crypto.generation</a></li>
+<li><a href="windows/debug/breakpoints.html">windows.debug.breakpoints</a></li>
+<li><a href="windows/debug/debugger.html">windows.debug.debugger</a></li>
+<li><a href="windows/debug/localdbg.html">windows.debug.localdbg</a></li>
+<li><a href="windows/generated_def/flag.html">windows.generated_def.flag</a></li>
+<li><a href="windows/generated_def/winstructs.html">windows.generated_def.winstructs</a></li>
+<li><a href="windows/hooks.html">windows.hooks</a></li>
+<li><a href="windows/native_exec/cpuid.html">windows.native_exec.cpuid</a></li>
+<li><a href="windows/native_exec/native_function.html">windows.native_exec.native_function</a></li>
+<li><a href="windows/native_exec/simple_x86.html">windows.native_exec.simple_x86</a></li>
+<li><a href="windows/pe_parse.html">windows.pe_parse</a></li>
+<li><a href="windows/pipe.html">windows.pipe</a></li>
+<li><a href="windows/remotectypes.html">windows.remotectypes</a></li>
+<li><a href="windows/rpc/client.html">windows.rpc.client</a></li>
+<li><a href="windows/rpc/epmapper.html">windows.rpc.epmapper</a></li>
+<li><a href="windows/rpc/ndr.html">windows.rpc.ndr</a></li>
+<li><a href="windows/syswow64.html">windows.syswow64</a></li>
+<li><a href="windows/utils/pythonutils.html">windows.utils.pythonutils</a></li>
+<li><a href="windows/utils/winutils.html">windows.utils.winutils</a></li>
+<li><a href="windows/winobject/apisetmap.html">windows.winobject.apisetmap</a></li>
+<li><a href="windows/winobject/exception.html">windows.winobject.exception</a></li>
+<li><a href="windows/winobject/handle.html">windows.winobject.handle</a></li>
+<li><a href="windows/winobject/network.html">windows.winobject.network</a></li>
+<li><a href="windows/winobject/process.html">windows.winobject.process</a></li>
+<li><a href="windows/winobject/registry.html">windows.winobject.registry</a></li>
+<li><a href="windows/winobject/service.html">windows.winobject.service</a></li>
+<li><a href="windows/winobject/system.html">windows.winobject.system</a></li>
+<li><a href="windows/winobject/volume.html">windows.winobject.volume</a></li>
+<li><a href="windows/winobject/wmi.html">windows.winobject.wmi</a></li>
+<li><a href="windows/winproxy.html">windows.winproxy</a></li>
+<li><a href="windows/wintrust.html">windows.wintrust</a></li>
+</ul>
+
+          </div>
+        </div>
+      </div>
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+<div id="searchbox" style="display: none" role="search">
+  <h3>Quick search</h3>
+    <div class="searchformwrapper">
+    <form class="search" action="../search.html" method="get">
+      <input type="text" name="q" />
+      <input type="submit" value="Go" />
+      <input type="hidden" name="check_keywords" value="yes" />
+      <input type="hidden" name="area" value="default" />
+    </form>
+    </div>
+</div>
+<script type="text/javascript">$('#searchbox').show(0);</script>
+        </div>
+      </div>
+      <div class="clearer"></div>
+    </div>
+    <div class="related" role="navigation" aria-label="related navigation">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="../genindex.html" title="General Index"
+             >index</a></li>
+        <li class="right" >
+          <a href="../py-modindex.html" title="Python Module Index"
+             >modules</a> |</li>
+        <li class="nav-item nav-item-0"><a href="../index.html">PythonForWindows 0.4 documentation</a> &#187;</li> 
+      </ul>
+    </div>
+    <div class="footer" role="contentinfo">
+        &#169; Copyright 2015, Clement Rouault.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.7.1.
+    </div>
+  </body>
+</html>

docs/build/html/_modules/windows/alpc.html

@@ -0,0 +1,618 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>windows.alpc &#8212; PythonForWindows 0.4 documentation</title>
+    <link rel="stylesheet" href="../../_static/classic.css" type="text/css" />
+    <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
+    <link rel="stylesheet" href="../../_static/css/mbasic.css" type="text/css" />
+    <script type="text/javascript" src="../../_static/documentation_options.js"></script>
+    <script type="text/javascript" src="../../_static/jquery.js"></script>
+    <script type="text/javascript" src="../../_static/underscore.js"></script>
+    <script type="text/javascript" src="../../_static/doctools.js"></script>
+    <link rel="index" title="Index" href="../../genindex.html" />
+    <link rel="search" title="Search" href="../../search.html" /> 
+  </head><body>
+    <div class="related" role="navigation" aria-label="related navigation">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="../../genindex.html" title="General Index"
+             accesskey="I">index</a></li>
+        <li class="right" >
+          <a href="../../py-modindex.html" title="Python Module Index"
+             >modules</a> |</li>
+        <li class="nav-item nav-item-0"><a href="../../index.html">PythonForWindows 0.4 documentation</a> &#187;</li>
+          <li class="nav-item nav-item-1"><a href="../index.html" accesskey="U">Module code</a> &#187;</li> 
+      </ul>
+    </div>  
+
+    <div class="document">
+      <div class="documentwrapper">
+        <div class="bodywrapper">
+          <div class="body" role="main">
+            
+  <h1>Source code for windows.alpc</h1><div class="highlight"><pre>
+<span></span><span class="kn">import</span> <span class="nn">sys</span>
+<span class="kn">import</span> <span class="nn">ctypes</span>
+<span class="kn">from</span> <span class="nn">collections</span> <span class="k">import</span> <span class="n">namedtuple</span>
+
+<span class="kn">import</span> <span class="nn">windows</span>
+<span class="kn">from</span> <span class="nn">windows</span> <span class="k">import</span> <span class="n">winproxy</span>
+<span class="kn">from</span> <span class="nn">windows</span> <span class="k">import</span> <span class="n">generated_def</span> <span class="k">as</span> <span class="n">gdef</span>
+
+
+<span class="c1">## For 64b python</span>
+<span class="c1"># 0x1f: 0x80000000: ALPC_MESSAGE_SECURITY_ATTRIBUTE(0x80000000) : size=0x18?</span>
+<span class="c1"># 0x1e: 0x40000000: ALPC_MESSAGE_VIEW_ATTRIBUTE(0x40000000): size=0x20</span>
+<span class="c1"># 0x1d: 0x20000000: ALPC_MESSAGE_CONTEXT_ATTRIBUTE(0x20000000): size=0x20</span>
+<span class="c1"># 0x1c: 0x10000000: ALPC_MESSAGE_HANDLE_ATTRIBUTE(0x10000000): size=0x18</span>
+<span class="c1"># 0x1b: 0x8000000: ALPC_MESSAGE_TOKEN_ATTRIBUTE(0x8000000): size=0x18</span>
+<span class="c1"># 0x1a: 0x4000000: ALPC_MESSAGE_DIRECT_ATTRIBUTE(0x4000000) size=0x8</span>
+<span class="c1"># 0x19: 0x2000000: ALPC_MESSAGE_WORK_ON_BEHALF_ATTRIBUTE(0x2000000) size=0x8</span>
+
+<div class="viewcode-block" id="AlpcMessage"><a class="viewcode-back" href="../../alpc.html#windows.alpc.AlpcMessage">[docs]</a><span class="k">class</span> <span class="nc">AlpcMessage</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;Represent a full ALPC Message: a :class:`AlpcMessagePort` and a :class:`MessageAttribute`&quot;&quot;&quot;</span>
+    <span class="c1"># PORT_MESSAGE + MessageAttribute</span>
+    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">msg_or_size</span><span class="o">=</span><span class="mh">0x1000</span><span class="p">,</span> <span class="n">attributes</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
+        <span class="c1"># Init the PORT_MESSAGE</span>
+        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">msg_or_size</span><span class="p">,</span> <span class="p">(</span><span class="n">long</span><span class="p">,</span> <span class="nb">int</span><span class="p">)):</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">port_message_buffer_size</span> <span class="o">=</span> <span class="n">msg_or_size</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">port_message_raw_buffer</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_buffer</span><span class="p">(</span><span class="n">msg_or_size</span><span class="p">)</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">port_message</span> <span class="o">=</span> <span class="n">AlpcMessagePort</span><span class="o">.</span><span class="n">from_buffer</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">port_message_raw_buffer</span><span class="p">)</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">port_message</span><span class="o">.</span><span class="n">set_datalen</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
+        <span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">msg_or_size</span><span class="p">,</span> <span class="n">AlpcMessagePort</span><span class="p">):</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">port_message</span> <span class="o">=</span> <span class="n">msg_or_size</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">port_message_raw_buffer</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">port_message</span><span class="o">.</span><span class="n">raw_buffer</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">port_message_buffer_size</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">port_message_raw_buffer</span><span class="p">)</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">(</span><span class="s2">&quot;Uneexpected type for &lt;msg_or_size&gt;: </span><span class="si">{0}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">msg_or_size</span><span class="p">))</span>
+
+        <span class="c1"># Init the MessageAttributes</span>
+        <span class="k">if</span> <span class="n">attributes</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="c1"># self.attributes = MessageAttribute.with_all_attributes()</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span> <span class="o">=</span> <span class="n">MessageAttribute</span><span class="o">.</span><span class="n">with_all_attributes</span><span class="p">()</span> <span class="c1">## Testing</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span> <span class="o">=</span> <span class="n">attributes</span>
+
+    <span class="c1"># PORT_MESSAGE wrappers</span>
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">type</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;The type of the message (``PORT_MESSAGE.u2.s2.Type``)&quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">port_message</span><span class="o">.</span><span class="n">u2</span><span class="o">.</span><span class="n">s2</span><span class="o">.</span><span class="n">Type</span>
+
+    <span class="k">def</span> <span class="nf">get_port_message_data</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">port_message</span><span class="o">.</span><span class="n">data</span>
+
+    <span class="k">def</span> <span class="nf">set_port_message_data</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">):</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">port_message</span><span class="o">.</span><span class="n">data</span> <span class="o">=</span> <span class="n">data</span>
+
+    <span class="n">data</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="n">get_port_message_data</span><span class="p">,</span> <span class="n">set_port_message_data</span><span class="p">)</span>
+    <span class="s2">&quot;The data of the message (located after the PORT_MESSAGE header)&quot;</span>
+
+    <span class="c1"># MessageAttributes wrappers</span>
+
+    <span class="c1">## Low level attributes access</span>
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">security_attribute</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;The :data:`~windows.generated_def.ALPC_MESSAGE_SECURITY_ATTRIBUTE` of the message</span>
+
+<span class="sd">            :type: :class:`ALPC_SECURITY_ATTR`</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span><span class="o">.</span><span class="n">get_attribute</span><span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_SECURITY_ATTRIBUTE</span><span class="p">)</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">view_attribute</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;The :data:`~windows.generated_def.ALPC_MESSAGE_VIEW_ATTRIBUTE` of the message:</span>
+
+<span class="sd">            :type: :class:`ALPC_DATA_VIEW_ATTR`</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span><span class="o">.</span><span class="n">get_attribute</span><span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_VIEW_ATTRIBUTE</span><span class="p">)</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">context_attribute</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;The :data:`~windows.generated_def.ALPC_MESSAGE_CONTEXT_ATTRIBUTE` of the message:</span>
+
+<span class="sd">            :type: :class:`ALPC_CONTEXT_ATTR`</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span><span class="o">.</span><span class="n">get_attribute</span><span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_CONTEXT_ATTRIBUTE</span><span class="p">)</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">handle_attribute</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;The :data:`~windows.generated_def.ALPC_MESSAGE_HANDLE_ATTRIBUTE` of the message:</span>
+
+<span class="sd">            :type: :class:`ALPC_HANDLE_ATTR`</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span><span class="o">.</span><span class="n">get_attribute</span><span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_HANDLE_ATTRIBUTE</span><span class="p">)</span>
+
+    <span class="c1">## Low level validity check (Test)</span>
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">view_is_valid</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="c1"># Change the name ?</span>
+        <span class="sd">&quot;&quot;&quot;True if :data:`~windows.generated_def.ALPC_MESSAGE_VIEW_ATTRIBUTE` is a ValidAttributes&quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span><span class="o">.</span><span class="n">is_valid</span><span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_VIEW_ATTRIBUTE</span><span class="p">)</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">security_is_valid</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="c1"># Change the name ?</span>
+        <span class="sd">&quot;&quot;&quot;True if :data:`~windows.generated_def.ALPC_MESSAGE_SECURITY_ATTRIBUTE` is a ValidAttributes&quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span><span class="o">.</span><span class="n">is_valid</span><span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_SECURITY_ATTRIBUTE</span><span class="p">)</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">handle_is_valid</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="c1"># Change the name ?</span>
+        <span class="sd">&quot;&quot;&quot;True if :data:`~windows.generated_def.ALPC_MESSAGE_HANDLE_ATTRIBUTE` is a ValidAttributes&quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span><span class="o">.</span><span class="n">is_valid</span><span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_HANDLE_ATTRIBUTE</span><span class="p">)</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">context_is_valid</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="c1"># Change the name ?</span>
+        <span class="sd">&quot;&quot;&quot;True if :data:`~windows.generated_def.ALPC_MESSAGE_CONTEXT_ATTRIBUTE` is a ValidAttributes&quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span><span class="o">.</span><span class="n">is_valid</span><span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_CONTEXT_ATTRIBUTE</span><span class="p">)</span>
+
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">valid_attributes</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;The list of valid attributes</span>
+
+<span class="sd">            :type: [:class:`~windows.generated_def.Flag`]</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span><span class="o">.</span><span class="n">valid_list</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">allocated_attributes</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;The list of allocated attributes</span>
+
+<span class="sd">            :type: [:class:`~windows.generated_def.Flag`]</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">attributes</span><span class="o">.</span><span class="n">allocated_list</span>
+
+    <span class="c1">## High level setup (Test)</span>
+    <span class="k">def</span> <span class="nf">setup_view</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">section_handle</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">flags</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span></div>
+        <span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">setup_view</span><span class="p">)</span>
+
+
+
+<div class="viewcode-block" id="AlpcMessagePort"><a class="viewcode-back" href="../../alpc.html#windows.alpc.AlpcMessagePort">[docs]</a><span class="k">class</span> <span class="nc">AlpcMessagePort</span><span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">PORT_MESSAGE</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;The effective ALPC Message composed of a ``PORT_MESSAGE`` structure followed by the data&quot;&quot;&quot;</span>
+    <span class="c1"># Constructeur</span>
+<div class="viewcode-block" id="AlpcMessagePort.from_buffer"><a class="viewcode-back" href="../../alpc.html#windows.alpc.AlpcMessagePort.from_buffer">[docs]</a>    <span class="nd">@classmethod</span>
+    <span class="k">def</span> <span class="nf">from_buffer</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">buffer</span><span class="p">):</span>
+        <span class="c1"># A sort of super(AlpcMessagePort).from_buffer</span>
+        <span class="c1"># But from_buffer is from the Metaclass of AlpcMessagePort so we use &#39;type(AlpcMessagePort)&#39;</span>
+        <span class="c1"># To access the standard version of from_buffer.</span>
+        <span class="bp">self</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="n">AlpcMessagePort</span><span class="p">)</span><span class="o">.</span><span class="n">from_buffer</span><span class="p">(</span><span class="n">AlpcMessagePort</span><span class="p">,</span> <span class="n">buffer</span><span class="p">)</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">buffer_size</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">buffer</span><span class="p">)</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">raw_buffer</span> <span class="o">=</span> <span class="n">buffer</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">header_size</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">sizeof</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">max_datasize</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">buffer_size</span> <span class="o">-</span> <span class="bp">self</span><span class="o">.</span><span class="n">header_size</span></div>
+        <span class="k">return</span> <span class="bp">self</span>
+
+    <span class="nd">@classmethod</span>
+    <span class="k">def</span> <span class="nf">from_buffer_size</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">buffer_size</span><span class="p">):</span>
+        <span class="n">buffer</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_buffer</span><span class="p">(</span><span class="n">buffer_size</span><span class="p">)</span>
+        <span class="k">return</span> <span class="bp">cls</span><span class="o">.</span><span class="n">from_buffer</span><span class="p">(</span><span class="n">buffer</span><span class="p">)</span>
+
+    <span class="k">def</span> <span class="nf">read_data</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">raw_buffer</span><span class="p">[</span><span class="n">ctypes</span><span class="o">.</span><span class="n">sizeof</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span><span class="n">ctypes</span><span class="o">.</span><span class="n">sizeof</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">u1</span><span class="o">.</span><span class="n">s1</span><span class="o">.</span><span class="n">DataLength</span><span class="p">]</span>
+
+    <span class="k">def</span> <span class="nf">write_data</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">):</span>
+        <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">data</span><span class="p">)</span> <span class="o">&gt;</span> <span class="bp">self</span><span class="o">.</span><span class="n">max_datasize</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;Cannot write data of len &lt;</span><span class="si">{0}</span><span class="s2">&gt; (raw_buffer size == &lt;</span><span class="si">{1}</span><span class="s2">&gt;)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">data</span><span class="p">),</span> <span class="bp">self</span><span class="o">.</span><span class="n">buffer_size</span><span class="p">))</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">raw_buffer</span><span class="p">[</span><span class="bp">self</span><span class="o">.</span><span class="n">header_size</span><span class="p">:</span> <span class="bp">self</span><span class="o">.</span><span class="n">header_size</span> <span class="o">+</span> <span class="nb">len</span><span class="p">(</span><span class="n">data</span><span class="p">)]</span> <span class="o">=</span> <span class="n">data</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">set_datalen</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">data</span><span class="p">))</span>
+
+    <span class="n">data</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="n">read_data</span><span class="p">,</span> <span class="n">write_data</span><span class="p">)</span>
+    <span class="s2">&quot;The data of the message (located after the header)&quot;</span>
+
+    <span class="k">def</span> <span class="nf">set_datalen</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">datalen</span><span class="p">):</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">u1</span><span class="o">.</span><span class="n">s1</span><span class="o">.</span><span class="n">TotalLength</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">header_size</span> <span class="o">+</span> <span class="n">datalen</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">u1</span><span class="o">.</span><span class="n">s1</span><span class="o">.</span><span class="n">DataLength</span> <span class="o">=</span> <span class="n">datalen</span>
+
+    <span class="k">def</span> <span class="nf">get_datalen</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">u1</span><span class="o">.</span><span class="n">s1</span><span class="o">.</span><span class="n">DataLength</span>
+
+    <span class="n">datalen</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="n">get_datalen</span><span class="p">,</span> <span class="n">set_datalen</span><span class="p">)</span></div>
+    <span class="sd">&quot;&quot;&quot;The length of the data&quot;&quot;&quot;</span>
+
+<span class="n">KNOWN_ALPC_ATTRIBUTES</span> <span class="o">=</span> <span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_SECURITY_ATTRIBUTE</span><span class="p">,</span>
+                            <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_VIEW_ATTRIBUTE</span><span class="p">,</span>
+                            <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_CONTEXT_ATTRIBUTE</span><span class="p">,</span>
+                            <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_HANDLE_ATTRIBUTE</span><span class="p">,</span>
+                            <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_TOKEN_ATTRIBUTE</span><span class="p">,</span>
+                            <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_DIRECT_ATTRIBUTE</span><span class="p">,</span>
+                            <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_WORK_ON_BEHALF_ATTRIBUTE</span><span class="p">)</span>
+
+<span class="n">KNOWN_ALPC_ATTRIBUTES_MAPPING</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">FlagMapper</span><span class="p">(</span><span class="o">*</span><span class="n">KNOWN_ALPC_ATTRIBUTES</span><span class="p">)</span>
+
+
+<div class="viewcode-block" id="MessageAttribute"><a class="viewcode-back" href="../../alpc.html#windows.alpc.MessageAttribute">[docs]</a><span class="k">class</span> <span class="nc">MessageAttribute</span><span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_ATTRIBUTES</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;The attributes of an ALPC message&quot;&quot;&quot;</span>
+    <span class="n">ATTRIBUTE_BY_FLAG</span> <span class="o">=</span> <span class="p">[(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_SECURITY_ATTRIBUTE</span><span class="p">,</span> <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_SECURITY_ATTR</span><span class="p">),</span>
+                            <span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_VIEW_ATTRIBUTE</span><span class="p">,</span> <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_DATA_VIEW_ATTR</span><span class="p">),</span>
+                            <span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_CONTEXT_ATTRIBUTE</span><span class="p">,</span> <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_CONTEXT_ATTR</span><span class="p">),</span>
+                            <span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_HANDLE_ATTRIBUTE</span><span class="p">,</span> <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_HANDLE_ATTR</span><span class="p">),</span>
+                            <span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_TOKEN_ATTRIBUTE</span><span class="p">,</span> <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_TOKEN_ATTR</span><span class="p">),</span>
+                            <span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_DIRECT_ATTRIBUTE</span><span class="p">,</span> <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_DIRECT_ATTR</span><span class="p">),</span>
+                            <span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_WORK_ON_BEHALF_ATTRIBUTE</span><span class="p">,</span> <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_WORK_ON_BEHALF_ATTR</span><span class="p">),</span>
+                            <span class="p">]</span>
+
+<div class="viewcode-block" id="MessageAttribute.with_attributes"><a class="viewcode-back" href="../../alpc.html#windows.alpc.MessageAttribute.with_attributes">[docs]</a>    <span class="nd">@classmethod</span>
+    <span class="k">def</span> <span class="nf">with_attributes</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">attributes</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Create a new :class:`MessageAttribute` with ``attributes`` allocated</span>
+
+<span class="sd">            :returns: :class:`MessageAttribute`</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="n">size</span> <span class="o">=</span> <span class="bp">cls</span><span class="o">.</span><span class="n">_get_required_buffer_size</span><span class="p">(</span><span class="n">attributes</span><span class="p">)</span>
+        <span class="n">buffer</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_buffer</span><span class="p">(</span><span class="n">size</span><span class="p">)</span>
+        <span class="bp">self</span> <span class="o">=</span> <span class="bp">cls</span><span class="o">.</span><span class="n">from_buffer</span><span class="p">(</span><span class="n">buffer</span><span class="p">)</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">raw_buffer</span> <span class="o">=</span> <span class="n">buffer</span>
+        <span class="n">res</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">DWORD</span><span class="p">()</span>
+        <span class="n">winproxy</span><span class="o">.</span><span class="n">AlpcInitializeMessageAttribute</span><span class="p">(</span><span class="n">attributes</span><span class="p">,</span> <span class="bp">self</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">raw_buffer</span><span class="p">),</span> <span class="n">res</span><span class="p">)</span></div>
+        <span class="k">return</span> <span class="bp">self</span>
+
+<div class="viewcode-block" id="MessageAttribute.with_all_attributes"><a class="viewcode-back" href="../../alpc.html#windows.alpc.MessageAttribute.with_all_attributes">[docs]</a>    <span class="nd">@classmethod</span>
+    <span class="k">def</span> <span class="nf">with_all_attributes</span><span class="p">(</span><span class="bp">cls</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Create a new :class:`MessageAttribute` with the following attributes allocated:</span>
+
+<span class="sd">            - :class:`ALPC_MESSAGE_SECURITY_ATTRIBUTE`</span>
+<span class="sd">            - :class:`ALPC_MESSAGE_VIEW_ATTRIBUTE`</span>
+<span class="sd">            - :class:`ALPC_MESSAGE_CONTEXT_ATTRIBUTE`</span>
+<span class="sd">            - :class:`ALPC_MESSAGE_HANDLE_ATTRIBUTE`</span>
+<span class="sd">            - :class:`ALPC_MESSAGE_TOKEN_ATTRIBUTE`</span>
+<span class="sd">            - :class:`ALPC_MESSAGE_DIRECT_ATTRIBUTE`</span>
+<span class="sd">            - :class:`ALPC_MESSAGE_WORK_ON_BEHALF_ATTRIBUTE`</span>
+
+<span class="sd">            :returns: :class:`MessageAttribute`</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="bp">cls</span><span class="o">.</span><span class="n">with_attributes</span><span class="p">(</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_SECURITY_ATTRIBUTE</span> <span class="o">|</span>
+                                    <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_VIEW_ATTRIBUTE</span>    <span class="o">|</span>
+                                    <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_CONTEXT_ATTRIBUTE</span> <span class="o">|</span>
+                                    <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_HANDLE_ATTRIBUTE</span>  <span class="o">|</span>
+                                    <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_TOKEN_ATTRIBUTE</span>   <span class="o">|</span>
+                                    <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_DIRECT_ATTRIBUTE</span>  <span class="o">|</span></div>
+                                    <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MESSAGE_WORK_ON_BEHALF_ATTRIBUTE</span><span class="p">)</span>
+
+
+    <span class="nd">@staticmethod</span>
+    <span class="k">def</span> <span class="nf">_get_required_buffer_size</span><span class="p">(</span><span class="n">flags</span><span class="p">):</span>
+        <span class="n">res</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">DWORD</span><span class="p">()</span>
+        <span class="k">try</span><span class="p">:</span>
+            <span class="n">windows</span><span class="o">.</span><span class="n">winproxy</span><span class="o">.</span><span class="n">AlpcInitializeMessageAttribute</span><span class="p">(</span><span class="n">flags</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">res</span><span class="p">)</span>
+        <span class="k">except</span> <span class="n">windows</span><span class="o">.</span><span class="n">generated_def</span><span class="o">.</span><span class="n">ntstatus</span><span class="o">.</span><span class="n">NtStatusException</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
+            <span class="c1"># Buffer too small: osef</span>
+            <span class="k">return</span> <span class="n">res</span><span class="o">.</span><span class="n">value</span>
+        <span class="k">return</span> <span class="n">res</span><span class="o">.</span><span class="n">value</span>
+
+<div class="viewcode-block" id="MessageAttribute.is_allocated"><a class="viewcode-back" href="../../alpc.html#windows.alpc.MessageAttribute.is_allocated">[docs]</a>    <span class="k">def</span> <span class="nf">is_allocated</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">attribute</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Return ``True`` if ``attribute`` is allocated&quot;&quot;&quot;</span></div>
+        <span class="k">return</span> <span class="nb">bool</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">AllocatedAttributes</span> <span class="o">&amp;</span> <span class="n">attribute</span><span class="p">)</span>
+
+<div class="viewcode-block" id="MessageAttribute.is_valid"><a class="viewcode-back" href="../../alpc.html#windows.alpc.MessageAttribute.is_valid">[docs]</a>    <span class="k">def</span> <span class="nf">is_valid</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">attribute</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Return ``True`` if ``attribute`` is valid&quot;&quot;&quot;</span></div>
+        <span class="k">return</span> <span class="nb">bool</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">ValidAttributes</span> <span class="o">&amp;</span> <span class="n">attribute</span><span class="p">)</span>
+
+    <span class="k">def</span> <span class="nf">get_attribute</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">attribute</span><span class="p">):</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">is_allocated</span><span class="p">(</span><span class="n">attribute</span><span class="p">):</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;Cannot get non-allocated attribute &lt;</span><span class="si">{0}</span><span class="s2">&gt;&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">attribute</span><span class="p">))</span>
+        <span class="n">offset</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">sizeof</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
+        <span class="k">for</span> <span class="n">sflag</span><span class="p">,</span> <span class="n">struct</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">ATTRIBUTE_BY_FLAG</span><span class="p">:</span>
+            <span class="k">if</span> <span class="n">sflag</span> <span class="o">==</span> <span class="n">attribute</span><span class="p">:</span>
+                <span class="c1"># print(&quot;Attr {0:#x} was at offet {1:#x}&quot;.format(attribute, offset))</span>
+                <span class="k">return</span> <span class="n">struct</span><span class="o">.</span><span class="n">from_address</span><span class="p">(</span><span class="n">ctypes</span><span class="o">.</span><span class="n">addressof</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">+</span> <span class="n">offset</span><span class="p">)</span>
+            <span class="k">elif</span> <span class="bp">self</span><span class="o">.</span><span class="n">is_allocated</span><span class="p">(</span><span class="n">sflag</span><span class="p">):</span>
+                <span class="n">offset</span> <span class="o">+=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">sizeof</span><span class="p">(</span><span class="n">struct</span><span class="p">)</span>
+        <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;ALPC Attribute &lt;</span><span class="si">{0}</span><span class="s2">&gt; not found :(&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">attribute</span><span class="p">))</span>
+
+    <span class="k">def</span> <span class="nf">_extract_alpc_attributes_values</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
+        <span class="n">attrs</span> <span class="o">=</span> <span class="p">[]</span>
+        <span class="k">for</span> <span class="n">mask</span> <span class="ow">in</span> <span class="p">(</span><span class="mi">1</span> <span class="o">&lt;&lt;</span> <span class="n">i</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">64</span><span class="p">)):</span>
+            <span class="k">if</span> <span class="n">value</span> <span class="o">&amp;</span> <span class="n">mask</span><span class="p">:</span>
+                <span class="n">attrs</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">mask</span><span class="p">)</span>
+        <span class="k">return</span> <span class="p">[</span><span class="n">KNOWN_ALPC_ATTRIBUTES_MAPPING</span><span class="p">[</span><span class="n">x</span><span class="p">]</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">attrs</span><span class="p">]</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">valid_list</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;The list of valid attributes</span>
+
+<span class="sd">            :type: [:class:`~windows.generated_def.Flag`]</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_extract_alpc_attributes_values</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">ValidAttributes</span><span class="p">)</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">allocated_list</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;The list of allocated attributes</span>
+
+<span class="sd">            :type: [:class:`~windows.generated_def.Flag`]</span>
+<span class="sd">        &quot;&quot;&quot;</span></div>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_extract_alpc_attributes_values</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">AllocatedAttributes</span><span class="p">)</span>
+
+
+<span class="n">AlpcSection</span> <span class="o">=</span> <span class="n">namedtuple</span><span class="p">(</span><span class="s2">&quot;AlpcSection&quot;</span><span class="p">,</span> <span class="p">[</span><span class="s2">&quot;handle&quot;</span><span class="p">,</span> <span class="s2">&quot;size&quot;</span><span class="p">])</span>
+
+<span class="k">class</span> <span class="nc">AlpcTransportBase</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
+    <span class="k">def</span> <span class="nf">send_receive</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">alpc_message</span><span class="p">,</span> <span class="n">receive_msg</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">flags</span><span class="o">=</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MSGFLG_SYNC_REQUEST</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Send and receive a message with ``flags``.</span>
+
+<span class="sd">            :param alpc_message: The message to send. If ``alpc_message`` is a :class:`str` it build an AlpcMessage with the message as data.</span>
+<span class="sd">            :type alpc_message: AlpcMessage or str</span>
+<span class="sd">            :param receive_msg: The message to send. If ``receive_msg`` is a ``None`` it create and return a simple :class:`AlpcMessage`</span>
+<span class="sd">            :type receive_msg: AlpcMessage or None</span>
+<span class="sd">            :param int flags: The flags for :func:`NtAlpcSendWaitReceivePort`</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">alpc_message</span><span class="p">,</span> <span class="n">basestring</span><span class="p">):</span>
+            <span class="n">raw_alpc_message</span> <span class="o">=</span> <span class="n">alpc_message</span>
+            <span class="n">alpc_message</span> <span class="o">=</span> <span class="n">AlpcMessage</span><span class="p">(</span><span class="nb">max</span><span class="p">(</span><span class="mh">0x1000</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">alpc_message</span><span class="p">)))</span>
+            <span class="n">alpc_message</span><span class="o">.</span><span class="n">port_message</span><span class="o">.</span><span class="n">data</span> <span class="o">=</span> <span class="n">raw_alpc_message</span>
+
+        <span class="k">if</span> <span class="n">receive_msg</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="n">receive_msg</span> <span class="o">=</span> <span class="n">AlpcMessage</span><span class="p">(</span><span class="mh">0x1000</span><span class="p">)</span>
+        <span class="n">receive_size</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">SIZE_T</span><span class="p">(</span><span class="n">receive_msg</span><span class="o">.</span><span class="n">port_message_buffer_size</span><span class="p">)</span>
+        <span class="n">winproxy</span><span class="o">.</span><span class="n">NtAlpcSendWaitReceivePort</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">flags</span><span class="p">,</span> <span class="n">alpc_message</span><span class="o">.</span><span class="n">port_message</span><span class="p">,</span> <span class="n">alpc_message</span><span class="o">.</span><span class="n">attributes</span><span class="p">,</span> <span class="n">receive_msg</span><span class="o">.</span><span class="n">port_message</span><span class="p">,</span> <span class="n">receive_size</span><span class="p">,</span> <span class="n">receive_msg</span><span class="o">.</span><span class="n">attributes</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
+        <span class="k">return</span> <span class="n">receive_msg</span>
+
+    <span class="k">def</span> <span class="nf">send</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">alpc_message</span><span class="p">,</span> <span class="n">flags</span><span class="o">=</span><span class="mi">0</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Send the ``alpc_message`` with ``flags``</span>
+
+<span class="sd">            :param alpc_message: The message to send. If ``alpc_message`` is a :class:`str` it build an AlpcMessage with the message as data.</span>
+<span class="sd">            :type alpc_message: AlpcMessage or str</span>
+<span class="sd">            :param int flags: The flags for :func:`NtAlpcSendWaitReceivePort`</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">alpc_message</span><span class="p">,</span> <span class="n">basestring</span><span class="p">):</span>
+            <span class="n">raw_alpc_message</span> <span class="o">=</span> <span class="n">alpc_message</span>
+            <span class="n">alpc_message</span> <span class="o">=</span> <span class="n">AlpcMessage</span><span class="p">(</span><span class="nb">max</span><span class="p">(</span><span class="mh">0x1000</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">alpc_message</span><span class="p">)))</span>
+            <span class="n">alpc_message</span><span class="o">.</span><span class="n">port_message</span><span class="o">.</span><span class="n">data</span> <span class="o">=</span> <span class="n">raw_alpc_message</span>
+        <span class="n">winproxy</span><span class="o">.</span><span class="n">NtAlpcSendWaitReceivePort</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">flags</span><span class="p">,</span> <span class="n">alpc_message</span><span class="o">.</span><span class="n">port_message</span><span class="p">,</span> <span class="n">alpc_message</span><span class="o">.</span><span class="n">attributes</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
+
+    <span class="k">def</span> <span class="nf">recv</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">receive_msg</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">flags</span><span class="o">=</span><span class="mi">0</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Receive a message into ``alpc_message`` with ``flags``.</span>
+
+<span class="sd">            :param receive_msg: The message to send. If ``receive_msg`` is a ``None`` it create and return a simple :class:`AlpcMessage`</span>
+<span class="sd">            :type receive_msg: AlpcMessage or None</span>
+<span class="sd">            :param int flags: The flags for :func:`NtAlpcSendWaitReceivePort`</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="k">if</span> <span class="n">receive_msg</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="n">receive_msg</span> <span class="o">=</span> <span class="n">AlpcMessage</span><span class="p">(</span><span class="mh">0x1000</span><span class="p">)</span>
+        <span class="n">receive_size</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">SIZE_T</span><span class="p">(</span><span class="n">receive_msg</span><span class="o">.</span><span class="n">port_message_buffer_size</span><span class="p">)</span>
+        <span class="n">winproxy</span><span class="o">.</span><span class="n">NtAlpcSendWaitReceivePort</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">flags</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="n">receive_msg</span><span class="o">.</span><span class="n">port_message</span><span class="p">,</span> <span class="n">receive_size</span><span class="p">,</span> <span class="n">receive_msg</span><span class="o">.</span><span class="n">attributes</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
+        <span class="k">return</span> <span class="n">receive_msg</span>
+
+    <span class="k">def</span> <span class="nf">_close_port</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">port_handle</span><span class="p">):</span>
+        <span class="n">windows</span><span class="o">.</span><span class="n">winproxy</span><span class="o">.</span><span class="n">NtAlpcDisconnectPort</span><span class="p">(</span><span class="n">port_handle</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
+        <span class="n">windows</span><span class="o">.</span><span class="n">winproxy</span><span class="o">.</span><span class="n">CloseHandle</span><span class="p">(</span><span class="n">port_handle</span><span class="p">)</span>
+
+
+
+<div class="viewcode-block" id="AlpcClient"><a class="viewcode-back" href="../../alpc.html#windows.alpc.AlpcClient">[docs]</a><span class="k">class</span> <span class="nc">AlpcClient</span><span class="p">(</span><span class="n">AlpcTransportBase</span><span class="p">):</span>
+    <span class="s2">&quot;An ALPC client able to connect to a port and send/receive messages&quot;</span>
+    <span class="n">DEFAULT_MAX_MESSAGE_LENGTH</span> <span class="o">=</span> <span class="mh">0x1000</span>
+
+    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">port_name</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Init the :class:`AlpcClient` automatically connect to ``port_name`` using default values if given&quot;&quot;&quot;</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">handle</span> <span class="o">=</span> <span class="kc">None</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">port_name</span> <span class="o">=</span> <span class="kc">None</span>
+        <span class="k">if</span> <span class="n">port_name</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="n">x</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">connect_to_port</span><span class="p">(</span><span class="n">port_name</span><span class="p">,</span> <span class="s2">&quot;&quot;</span><span class="p">)</span>
+
+    <span class="k">def</span> <span class="nf">_alpc_port_to_unicode_string</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
+        <span class="k">return</span> <span class="n">gdef</span><span class="o">.</span><span class="n">UNICODE_STRING</span><span class="o">.</span><span class="n">from_string</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
+
+<div class="viewcode-block" id="AlpcClient.connect_to_port"><a class="viewcode-back" href="../../alpc.html#windows.alpc.AlpcClient.connect_to_port">[docs]</a>    <span class="k">def</span> <span class="nf">connect_to_port</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">port_name</span><span class="p">,</span> <span class="n">connect_message</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span>
+                                <span class="n">port_attr</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">port_attr_flags</span><span class="o">=</span><span class="mh">0x10000</span><span class="p">,</span> <span class="n">obj_attr</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span>
+                                <span class="n">flags</span><span class="o">=</span><span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_MSGFLG_SYNC_REQUEST</span><span class="p">,</span> <span class="n">timeout</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Connect to the ALPC port ``port_name``. Most of the parameters have defauls value is ``None`` is passed.</span>
+
+<span class="sd">            :param AlpcMessage connect_message: The message send with the connection request, if not ``None`` the function will return an :class:`AlpcMessage`</span>
+<span class="sd">            :param ALPC_PORT_ATTRIBUTES port_attr: The port attributes, one with default value will be used if this parameter is ``None``</span>
+<span class="sd">            :param int port_attr_flags: ``ALPC_PORT_ATTRIBUTES.Flags`` used if ``port_attr`` is ``None`` (MUTUALY EXCLUSINVE WITH ``port_attr``)</span>
+<span class="sd">            :param OBJECT_ATTRIBUTES obj_attr: The attributes of the port (can be None)</span>
+<span class="sd">            :param int flags: The flags for :func:`NtAlpcConnectPort`</span>
+<span class="sd">            :param int timeout: The timeout of the request</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="c1"># TODO raise on mutual exclusive parameter</span>
+        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">handle</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;Client already connected&quot;</span><span class="p">)</span>
+        <span class="n">handle</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">HANDLE</span><span class="p">()</span>
+        <span class="n">port_name_unicode</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_alpc_port_to_unicode_string</span><span class="p">(</span><span class="n">port_name</span><span class="p">)</span>
+
+        <span class="k">if</span> <span class="n">port_attr</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="n">port_attr</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_PORT_ATTRIBUTES</span><span class="p">()</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">Flags</span> <span class="o">=</span> <span class="n">port_attr_flags</span> <span class="c1"># Flag qui fonctionne pour l&#39;UAC</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxMessageLength</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">DEFAULT_MAX_MESSAGE_LENGTH</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MemoryBandwidth</span> <span class="o">=</span> <span class="mi">0</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxPoolUsage</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxSectionSize</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxViewSize</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxTotalSectionSize</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">DupObjectTypes</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">SecurityQos</span><span class="o">.</span><span class="n">Length</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">sizeof</span><span class="p">(</span><span class="n">port_attr</span><span class="o">.</span><span class="n">SecurityQos</span><span class="p">)</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">SecurityQos</span><span class="o">.</span><span class="n">ImpersonationLevel</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">SecurityImpersonation</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">SecurityQos</span><span class="o">.</span><span class="n">ContextTrackingMode</span> <span class="o">=</span> <span class="mi">0</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">SecurityQos</span><span class="o">.</span><span class="n">EffectiveOnly</span> <span class="o">=</span> <span class="mi">0</span>
+
+        <span class="k">if</span> <span class="n">connect_message</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="n">send_msg</span> <span class="o">=</span> <span class="kc">None</span>
+            <span class="n">send_msg_attr</span> <span class="o">=</span> <span class="kc">None</span>
+            <span class="n">buffersize</span> <span class="o">=</span> <span class="kc">None</span>
+        <span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">connect_message</span><span class="p">,</span> <span class="n">basestring</span><span class="p">):</span>
+            <span class="n">buffersize</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">DWORD</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">connect_message</span><span class="p">)</span> <span class="o">+</span> <span class="mh">0x1000</span><span class="p">)</span>
+            <span class="n">send_msg</span> <span class="o">=</span> <span class="n">AlpcMessagePort</span><span class="o">.</span><span class="n">from_buffer_size</span><span class="p">(</span><span class="n">buffersize</span><span class="o">.</span><span class="n">value</span><span class="p">)</span>
+            <span class="n">send_msg</span><span class="o">.</span><span class="n">data</span> <span class="o">=</span> <span class="n">connect_message</span>
+            <span class="n">send_msg_attr</span> <span class="o">=</span> <span class="n">MessageAttribute</span><span class="o">.</span><span class="n">with_all_attributes</span><span class="p">()</span>
+        <span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">connect_message</span><span class="p">,</span> <span class="n">AlpcMessage</span><span class="p">):</span>
+            <span class="n">send_msg</span> <span class="o">=</span> <span class="n">connect_message</span><span class="o">.</span><span class="n">port_message</span>
+            <span class="n">send_msg_attr</span> <span class="o">=</span> <span class="n">connect_message</span><span class="o">.</span><span class="n">attributes</span>
+            <span class="n">buffersize</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">DWORD</span><span class="p">(</span><span class="n">connect_message</span><span class="o">.</span><span class="n">port_message_buffer_size</span><span class="p">)</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;Don&#39;t know how to send &lt;</span><span class="si">{0!r}</span><span class="s2">&gt; as connect message&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">connect_message</span><span class="p">))</span>
+
+        <span class="c1"># windows.utils.print_ctypes_struct(port_attr, &quot;port_attr_connect&quot;, hexa=True)</span>
+        <span class="n">receive_attr</span> <span class="o">=</span> <span class="n">MessageAttribute</span><span class="o">.</span><span class="n">with_all_attributes</span><span class="p">()</span>
+        <span class="n">winproxy</span><span class="o">.</span><span class="n">NtAlpcConnectPort</span><span class="p">(</span><span class="n">handle</span><span class="p">,</span> <span class="n">port_name_unicode</span><span class="p">,</span> <span class="n">obj_attr</span><span class="p">,</span> <span class="n">port_attr</span><span class="p">,</span> <span class="n">flags</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="n">send_msg</span><span class="p">,</span> <span class="n">buffersize</span><span class="p">,</span> <span class="n">send_msg_attr</span><span class="p">,</span> <span class="n">receive_attr</span><span class="p">,</span> <span class="n">timeout</span><span class="p">)</span>
+        <span class="c1"># If send_msg is not None, it contains the ClientId.UniqueProcess : PID of the server :)</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">handle</span> <span class="o">=</span> <span class="n">handle</span><span class="o">.</span><span class="n">value</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">port_name</span> <span class="o">=</span> <span class="n">port_name</span></div>
+        <span class="k">return</span> <span class="n">AlpcMessage</span><span class="p">(</span><span class="n">send_msg</span><span class="p">,</span> <span class="n">receive_attr</span><span class="p">)</span> <span class="k">if</span> <span class="n">send_msg</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="k">else</span> <span class="kc">None</span>
+
+    <span class="k">def</span> <span class="nf">create_port_section</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">Flags</span><span class="p">,</span> <span class="n">SectionHandle</span><span class="p">,</span> <span class="n">SectionSize</span><span class="p">):</span>
+        <span class="n">AlpcSectionHandle</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">HANDLE</span><span class="p">()</span>
+        <span class="n">ActualSectionSize</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">SIZE_T</span><span class="p">()</span>
+        <span class="c1"># RPCRT4 USE FLAGS 0x40000 ALPC_VIEWFLG_NOT_SECURE ?</span>
+        <span class="n">winproxy</span><span class="o">.</span><span class="n">NtAlpcCreatePortSection</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">Flags</span><span class="p">,</span> <span class="n">SectionHandle</span><span class="p">,</span> <span class="n">SectionSize</span><span class="p">,</span> <span class="n">AlpcSectionHandle</span><span class="p">,</span> <span class="n">ActualSectionSize</span><span class="p">)</span>
+        <span class="k">return</span> <span class="n">AlpcSection</span><span class="p">(</span><span class="n">AlpcSectionHandle</span><span class="o">.</span><span class="n">value</span><span class="p">,</span> <span class="n">ActualSectionSize</span><span class="o">.</span><span class="n">value</span><span class="p">)</span>
+
+    <span class="k">def</span> <span class="nf">map_section</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">section_handle</span><span class="p">,</span> <span class="n">size</span><span class="p">,</span> <span class="n">flags</span><span class="o">=</span><span class="mi">0</span><span class="p">):</span>
+        <span class="n">view_attributes</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_DATA_VIEW_ATTR</span><span class="p">()</span>
+        <span class="n">view_attributes</span><span class="o">.</span><span class="n">Flags</span> <span class="o">=</span> <span class="mi">0</span>
+        <span class="n">view_attributes</span><span class="o">.</span><span class="n">SectionHandle</span> <span class="o">=</span> <span class="n">section_handle</span>
+        <span class="n">view_attributes</span><span class="o">.</span><span class="n">ViewBase</span> <span class="o">=</span> <span class="mi">0</span>
+        <span class="n">view_attributes</span><span class="o">.</span><span class="n">ViewSize</span> <span class="o">=</span> <span class="n">size</span>
+        <span class="n">r</span> <span class="o">=</span> <span class="n">winproxy</span><span class="o">.</span><span class="n">NtAlpcCreateSectionView</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">flags</span><span class="p">,</span> <span class="n">view_attributes</span><span class="p">)</span>
+        <span class="k">return</span> <span class="n">view_attributes</span>
+
+    <span class="k">def</span> <span class="nf">disconnect</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">_close_port</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">)</span>
+
+    <span class="k">def</span> <span class="nf">__del__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">path</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span></div>
+            <span class="bp">self</span><span class="o">.</span><span class="n">disconnect</span><span class="p">()</span>
+
+
+<div class="viewcode-block" id="AlpcServer"><a class="viewcode-back" href="../../alpc.html#windows.alpc.AlpcServer">[docs]</a><span class="k">class</span> <span class="nc">AlpcServer</span><span class="p">(</span><span class="n">AlpcTransportBase</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;An ALPC server able to create a port, accept connections and send/receive messages&quot;&quot;&quot;</span>
+    <span class="n">DEFAULT_MAX_MESSAGE_LENGTH</span> <span class="o">=</span> <span class="mh">0x1000</span>
+
+    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">port_name</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">port_name</span> <span class="o">=</span> <span class="kc">None</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">communication_port_list</span> <span class="o">=</span> <span class="p">[]</span>
+        <span class="k">if</span> <span class="n">port_name</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">create_port</span><span class="p">(</span><span class="n">port_name</span><span class="p">)</span>
+
+    <span class="k">def</span> <span class="nf">_alpc_port_to_unicode_string</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
+        <span class="k">return</span> <span class="n">gdef</span><span class="o">.</span><span class="n">UNICODE_STRING</span><span class="o">.</span><span class="n">from_string</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
+
+<div class="viewcode-block" id="AlpcServer.create_port"><a class="viewcode-back" href="../../alpc.html#windows.alpc.AlpcServer.create_port">[docs]</a>    <span class="k">def</span> <span class="nf">create_port</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">port_name</span><span class="p">,</span> <span class="n">msglen</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">port_attr_flags</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">obj_attr</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">port_attr</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Create the ALPC port ``port_name``. Most of the parameters have defauls value is ``None`` is passed.</span>
+
+<span class="sd">            :param str port_name: The port&#39;s name to create.</span>
+<span class="sd">            :param int msglen: ``ALPC_PORT_ATTRIBUTES.MaxMessageLength`` used if ``port_attr`` is ``None`` (MUTUALY EXCLUSINVE WITH ``port_attr``)</span>
+<span class="sd">            :param int port_attr_flags: ``ALPC_PORT_ATTRIBUTES.Flags`` used if ``port_attr`` is ``None`` (MUTUALY EXCLUSINVE WITH ``port_attr``)</span>
+<span class="sd">            :param OBJECT_ATTRIBUTES obj_attr: The attributes of the port, one with default value will be used if this parameter is ``None``</span>
+<span class="sd">            :param ALPC_PORT_ATTRIBUTES port_attr: The port attributes, one with default value will be used if this parameter is ``None``</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="c1"># TODO raise on mutual exclusive parameter (port_attr + port_attr_flags | obj_attr + msglen)</span>
+        <span class="n">handle</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">HANDLE</span><span class="p">()</span>
+        <span class="n">raw_name</span> <span class="o">=</span>  <span class="n">port_name</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="n">raw_name</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">&quot;</span><span class="se">\\</span><span class="s2">&quot;</span><span class="p">):</span>
+            <span class="n">raw_name</span> <span class="o">=</span> <span class="s2">&quot;</span><span class="se">\\</span><span class="s2">&quot;</span> <span class="o">+</span> <span class="n">port_name</span>
+        <span class="n">port_name</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_alpc_port_to_unicode_string</span><span class="p">(</span><span class="n">raw_name</span><span class="p">)</span>
+
+        <span class="k">if</span> <span class="n">msglen</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="n">msglen</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">DEFAULT_MAX_MESSAGE_LENGTH</span>
+        <span class="k">if</span> <span class="n">obj_attr</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="n">obj_attr</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">OBJECT_ATTRIBUTES</span><span class="p">()</span>
+            <span class="n">obj_attr</span><span class="o">.</span><span class="n">Length</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">sizeof</span><span class="p">(</span><span class="n">obj_attr</span><span class="p">)</span>
+            <span class="n">obj_attr</span><span class="o">.</span><span class="n">RootDirectory</span> <span class="o">=</span> <span class="kc">None</span>
+            <span class="n">obj_attr</span><span class="o">.</span><span class="n">ObjectName</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">pointer</span><span class="p">(</span><span class="n">port_name</span><span class="p">)</span>
+            <span class="n">obj_attr</span><span class="o">.</span><span class="n">Attributes</span> <span class="o">=</span> <span class="mi">0</span>
+            <span class="n">obj_attr</span><span class="o">.</span><span class="n">SecurityDescriptor</span> <span class="o">=</span> <span class="kc">None</span>
+            <span class="n">obj_attr</span><span class="o">.</span><span class="n">SecurityQualityOfService</span> <span class="o">=</span> <span class="kc">None</span>
+        <span class="k">if</span> <span class="n">port_attr</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="n">port_attr</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_PORT_ATTRIBUTES</span><span class="p">()</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">Flags</span> <span class="o">=</span> <span class="n">port_attr_flags</span>
+            <span class="c1"># port_attr.Flags = 0x2080000</span>
+            <span class="c1"># port_attr.Flags = 0x90000</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxMessageLength</span> <span class="o">=</span> <span class="n">msglen</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MemoryBandwidth</span> <span class="o">=</span> <span class="mi">0</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxPoolUsage</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxSectionSize</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxViewSize</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxTotalSectionSize</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">DupObjectTypes</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+            <span class="c1"># windows.utils.print_ctypes_struct(port_attr, &quot;   - PORT_ATTR&quot;, hexa=True)</span>
+
+        <span class="n">winproxy</span><span class="o">.</span><span class="n">NtAlpcCreatePort</span><span class="p">(</span><span class="n">handle</span><span class="p">,</span> <span class="n">obj_attr</span><span class="p">,</span> <span class="n">port_attr</span><span class="p">)</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">port_name</span> <span class="o">=</span> <span class="n">raw_name</span></div>
+        <span class="bp">self</span><span class="o">.</span><span class="n">handle</span> <span class="o">=</span> <span class="n">handle</span><span class="o">.</span><span class="n">value</span>
+
+<div class="viewcode-block" id="AlpcServer.accept_connection"><a class="viewcode-back" href="../../alpc.html#windows.alpc.AlpcServer.accept_connection">[docs]</a>    <span class="k">def</span> <span class="nf">accept_connection</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">msg</span><span class="p">,</span> <span class="n">port_attr</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">port_context</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Accept the connection for a ``LPC_CONNECTION_REQUEST`` message.</span>
+<span class="sd">            ``msg.MessageId`` must be the same as the connection requesting message.</span>
+
+<span class="sd">            :param AlpcMessage msg: The response message.</span>
+<span class="sd">            :param ALPC_PORT_ATTRIBUTES port_attr: The attributes of the port, one with default value will be used if this parameter is ``None``</span>
+<span class="sd">            :param PVOID port_context: A value that will be copied in ``ALPC_CONTEXT_ATTR.PortContext`` of every message on this connection.</span>
+
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="n">rhandle</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">HANDLE</span><span class="p">()</span>
+
+        <span class="k">if</span> <span class="n">port_attr</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+            <span class="n">port_attr</span> <span class="o">=</span> <span class="n">gdef</span><span class="o">.</span><span class="n">ALPC_PORT_ATTRIBUTES</span><span class="p">()</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">Flags</span> <span class="o">=</span> <span class="mh">0x80000</span>
+            <span class="c1"># port_attr.Flags = 0x80000 + 0x2000000</span>
+            <span class="c1"># port_attr.Flags =  0x2000000</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxMessageLength</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">DEFAULT_MAX_MESSAGE_LENGTH</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MemoryBandwidth</span> <span class="o">=</span> <span class="mi">0</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxPoolUsage</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxSectionSize</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxViewSize</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">MaxTotalSectionSize</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+            <span class="n">port_attr</span><span class="o">.</span><span class="n">DupObjectTypes</span> <span class="o">=</span> <span class="mh">0xffffffff</span>
+        <span class="c1"># windows.utils.print_ctypes_struct(port_attr, &quot;   - CONN_PORT_ATTR&quot;, hexa=True)</span>
+        <span class="n">winproxy</span><span class="o">.</span><span class="n">NtAlpcAcceptConnectPort</span><span class="p">(</span><span class="n">rhandle</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="n">port_attr</span><span class="p">,</span> <span class="n">port_context</span><span class="p">,</span> <span class="n">msg</span><span class="o">.</span><span class="n">port_message</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="kc">True</span><span class="p">)</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">communication_port_list</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">rhandle</span><span class="o">.</span><span class="n">value</span><span class="p">)</span></div>
+        <span class="k">return</span> <span class="n">msg</span>
+
+    <span class="k">def</span> <span class="nf">disconnect</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">_close_port</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">)</span>
+        <span class="k">for</span> <span class="n">com_port_handle</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">communication_port_list</span><span class="p">:</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">_close_port</span><span class="p">(</span><span class="n">com_port_handle</span><span class="p">)</span>
+
+    <span class="c1"># TODO: add an API to close a communication port ?</span>
+
+    <span class="k">def</span> <span class="nf">__del__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">path</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span></div>
+            <span class="bp">self</span><span class="o">.</span><span class="n">disconnect</span><span class="p">()</span>
+</pre></div>
+
+          </div>
+        </div>
+      </div>
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+<div id="searchbox" style="display: none" role="search">
+  <h3>Quick search</h3>
+    <div class="searchformwrapper">
+    <form class="search" action="../../search.html" method="get">
+      <input type="text" name="q" />
+      <input type="submit" value="Go" />
+      <input type="hidden" name="check_keywords" value="yes" />
+      <input type="hidden" name="area" value="default" />
+    </form>
+    </div>
+</div>
+<script type="text/javascript">$('#searchbox').show(0);</script>
+        </div>
+      </div>
+      <div class="clearer"></div>
+    </div>
+    <div class="related" role="navigation" aria-label="related navigation">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="../../genindex.html" title="General Index"
+             >index</a></li>
+        <li class="right" >
+          <a href="../../py-modindex.html" title="Python Module Index"
+             >modules</a> |</li>
+        <li class="nav-item nav-item-0"><a href="../../index.html">PythonForWindows 0.4 documentation</a> &#187;</li>
+          <li class="nav-item nav-item-1"><a href="../index.html" >Module code</a> &#187;</li> 
+      </ul>
+    </div>
+    <div class="footer" role="contentinfo">
+        &#169; Copyright 2015, Clement Rouault.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.7.1.
+    </div>
+  </body>
+</html>

docs/build/html/_modules/windows/com.html

@@ -0,0 +1,335 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <title>windows.com &#8212; PythonForWindows 0.4 documentation</title>
+    <link rel="stylesheet" href="../../_static/classic.css" type="text/css" />
+    <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
+    <link rel="stylesheet" href="../../_static/css/mbasic.css" type="text/css" />
+    <script type="text/javascript" src="../../_static/documentation_options.js"></script>
+    <script type="text/javascript" src="../../_static/jquery.js"></script>
+    <script type="text/javascript" src="../../_static/underscore.js"></script>
+    <script type="text/javascript" src="../../_static/doctools.js"></script>
+    <link rel="index" title="Index" href="../../genindex.html" />
+    <link rel="search" title="Search" href="../../search.html" /> 
+  </head><body>
+    <div class="related" role="navigation" aria-label="related navigation">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="../../genindex.html" title="General Index"
+             accesskey="I">index</a></li>
+        <li class="right" >
+          <a href="../../py-modindex.html" title="Python Module Index"
+             >modules</a> |</li>
+        <li class="nav-item nav-item-0"><a href="../../index.html">PythonForWindows 0.4 documentation</a> &#187;</li>
+          <li class="nav-item nav-item-1"><a href="../index.html" accesskey="U">Module code</a> &#187;</li> 
+      </ul>
+    </div>  
+
+    <div class="document">
+      <div class="documentwrapper">
+        <div class="bodywrapper">
+          <div class="body" role="main">
+            
+  <h1>Source code for windows.com</h1><div class="highlight"><pre>
+<span></span><span class="kn">import</span> <span class="nn">struct</span>
+<span class="kn">import</span> <span class="nn">ctypes</span>
+<span class="kn">import</span> <span class="nn">functools</span>
+<span class="kn">from</span> <span class="nn">ctypes.wintypes</span> <span class="k">import</span> <span class="n">HRESULT</span><span class="p">,</span> <span class="n">byref</span><span class="p">,</span> <span class="n">pointer</span><span class="p">,</span> <span class="n">cast</span>
+
+<span class="kn">import</span> <span class="nn">windows</span>
+<span class="kn">from</span> <span class="nn">windows</span> <span class="k">import</span> <span class="n">winproxy</span>
+<span class="kn">from</span> <span class="nn">windows.generated_def.winstructs</span> <span class="k">import</span> <span class="o">*</span>
+
+<span class="kn">from</span> <span class="nn">windows.generated_def</span> <span class="k">import</span> <span class="n">RPC_C_IMP_LEVEL_IMPERSONATE</span><span class="p">,</span> <span class="n">CLSCTX_INPROC_SERVER</span>
+<span class="kn">from</span> <span class="nn">windows.generated_def</span> <span class="k">import</span> <span class="n">interfaces</span>
+<span class="kn">from</span> <span class="nn">windows.generated_def.interfaces</span> <span class="k">import</span> <span class="n">generate_IID</span><span class="p">,</span> <span class="n">IID</span>
+
+
+<span class="c1"># Simple raw -&gt; UUID</span>
+<span class="c1"># &quot;-&quot;.join(&quot;{:02X}&quot;.format(c) for c in struct.unpack(&quot;&lt;IHHHBBBBBB&quot;, x))</span>
+
+<div class="viewcode-block" id="init"><a class="viewcode-back" href="../../com.html#windows.com.init">[docs]</a><span class="k">def</span> <span class="nf">init</span><span class="p">():</span>
+    <span class="sd">&quot;&quot;&quot;Init COM with some default parameters&quot;&quot;&quot;</span>
+    <span class="k">try</span><span class="p">:</span>
+        <span class="n">t</span> <span class="o">=</span> <span class="n">winproxy</span><span class="o">.</span><span class="n">CoInitializeEx</span><span class="p">()</span>
+    <span class="k">except</span> <span class="ne">WindowsError</span> <span class="k">as</span> <span class="n">e</span><span class="p">:</span>
+        <span class="n">t</span> <span class="o">=</span> <span class="n">e</span><span class="o">.</span><span class="n">winerror</span>
+    <span class="k">if</span> <span class="n">t</span><span class="p">:</span>
+        <span class="k">return</span> <span class="n">t</span></div>
+    <span class="k">return</span> <span class="n">initsecurity</span><span class="p">()</span>
+
+<span class="k">def</span> <span class="nf">initsecurity</span><span class="p">():</span> <span class="c1"># Should take some parameters..</span>
+    <span class="k">return</span> <span class="n">winproxy</span><span class="o">.</span><span class="n">CoInitializeSecurity</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">RPC_C_IMP_LEVEL_IMPERSONATE</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">)</span>
+
+
+<div class="viewcode-block" id="create_instance"><a class="viewcode-back" href="../../com.html#windows.com.create_instance">[docs]</a><span class="k">def</span> <span class="nf">create_instance</span><span class="p">(</span><span class="n">clsiid</span><span class="p">,</span> <span class="n">targetinterface</span><span class="p">,</span> <span class="n">custom_iid</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">context</span><span class="o">=</span><span class="n">CLSCTX_INPROC_SERVER</span> <span class="o">|</span> <span class="n">CLSCTX_LOCAL_SERVER</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;A simple wrapper around ``CoCreateInstance &lt;https://msdn.microsoft.com/en-us/library/windows/desktop/ms686615(v=vs.85).aspx&gt;``&quot;&quot;&quot;</span>
+    <span class="k">if</span> <span class="n">custom_iid</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+        <span class="n">custom_iid</span> <span class="o">=</span> <span class="n">targetinterface</span><span class="o">.</span><span class="n">IID</span></div>
+    <span class="k">return</span> <span class="n">winproxy</span><span class="o">.</span><span class="n">CoCreateInstance</span><span class="p">(</span><span class="n">byref</span><span class="p">(</span><span class="n">clsiid</span><span class="p">),</span> <span class="kc">None</span><span class="p">,</span> <span class="n">context</span><span class="p">,</span> <span class="n">byref</span><span class="p">(</span><span class="n">custom_iid</span><span class="p">),</span> <span class="n">byref</span><span class="p">(</span><span class="n">targetinterface</span><span class="p">))</span>
+
+<span class="c1"># Improved COM object</span>
+<span class="c1"># Todo: ctypes_genertation extended struct ?</span>
+<span class="k">class</span> <span class="nc">ImprovedSAFEARRAY</span><span class="p">(</span><span class="n">SAFEARRAY</span><span class="p">):</span>
+        <span class="nd">@classmethod</span>
+        <span class="k">def</span> <span class="nf">of_type</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">addr</span><span class="p">,</span> <span class="n">t</span><span class="p">):</span>
+            <span class="bp">self</span> <span class="o">=</span> <span class="bp">cls</span><span class="o">.</span><span class="n">from_address</span><span class="p">(</span><span class="n">addr</span><span class="p">)</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">elt_type</span> <span class="o">=</span> <span class="n">t</span>
+            <span class="k">return</span> <span class="bp">self</span>
+
+        <span class="nd">@classmethod</span>
+        <span class="k">def</span> <span class="nf">from_PSAFEARRAY</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">psafearray</span><span class="p">):</span>
+            <span class="n">res</span> <span class="o">=</span> <span class="n">cast</span><span class="p">(</span><span class="n">psafearray</span><span class="p">,</span> <span class="n">POINTER</span><span class="p">(</span><span class="n">ImprovedSAFEARRAY</span><span class="p">))[</span><span class="mi">0</span><span class="p">]</span>
+            <span class="k">return</span> <span class="n">res</span>
+
+        <span class="k">def</span> <span class="nf">to_list</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">t</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
+            <span class="k">if</span> <span class="n">t</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+                <span class="k">if</span> <span class="nb">hasattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="s2">&quot;elt_type&quot;</span><span class="p">):</span>
+                    <span class="n">t</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">elt_type</span>
+                <span class="k">else</span><span class="p">:</span>
+                    <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;Missing type of the array&quot;</span><span class="p">)</span>
+            <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">cDims</span> <span class="o">!=</span>  <span class="mi">1</span><span class="p">:</span>
+                <span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">(</span><span class="s2">&quot;tagSAFEARRAY if dims != 1&quot;</span><span class="p">)</span>
+
+            <span class="n">nb_element</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">rgsabound</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">cElements</span>
+            <span class="n">llbound</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">rgsabound</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">lLbound</span>
+            <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">cbElements</span> <span class="o">!=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">sizeof</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+                <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;Size of elements != sizeof(type)&quot;</span><span class="p">)</span>
+            <span class="n">data</span> <span class="o">=</span> <span class="p">[</span><span class="n">t</span><span class="o">.</span><span class="n">from_address</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">pvData</span> <span class="o">+</span> <span class="p">(</span><span class="n">i</span> <span class="o">+</span> <span class="n">llbound</span><span class="p">)</span> <span class="o">*</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">sizeof</span><span class="p">(</span><span class="n">t</span><span class="p">))</span><span class="o">.</span><span class="n">value</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">nb_element</span><span class="p">)]</span>
+            <span class="k">return</span> <span class="n">data</span>
+
+<span class="c1">#VT_VALUE_TO_TYPE = {</span>
+<span class="c1">#VT_I2 : SHORT,</span>
+<span class="c1">#VT_I4 : LONG,</span>
+<span class="c1">#VT_BSTR : BSTR,</span>
+<span class="c1">#VT_VARIANT : VARIANT,</span>
+<span class="c1">#VT_UI1 : UCHAR,</span>
+<span class="c1">#VT_UI2 : USHORT,</span>
+<span class="c1">#VT_UI4 : DWORD,</span>
+<span class="c1">#VT_I8 : LONGLONG,</span>
+<span class="c1">#VT_UI8 : ULONG64,</span>
+<span class="c1">#VT_INT : INT,</span>
+<span class="c1">#VT_UINT : UINT,</span>
+<span class="c1">#VT_HRESULT : HRESULT,</span>
+<span class="c1">#VT_PTR : PVOID,</span>
+<span class="c1">#VT_LPSTR : LPCSTR,</span>
+<span class="c1">#VT_LPWSTR : LPWSTR,</span>
+<span class="c1">#}</span>
+
+<span class="k">class</span> <span class="nc">ImprovedVariant</span><span class="p">(</span><span class="n">VARIANT</span><span class="p">):</span>
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">asbstr</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">vt</span> <span class="o">!=</span> <span class="n">VT_BSTR</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;asbstr on non-bstr variant&quot;</span><span class="p">)</span>
+        <span class="c1">#import pdb;pdb.set_trace()</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_VARIANT_NAME_3</span><span class="o">.</span><span class="n">bstrVal</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">aslong</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">vt</span> <span class="ow">in</span> <span class="p">[</span><span class="n">VT_I4</span><span class="p">]:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;aslong on non-long variant&quot;</span><span class="p">)</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_VARIANT_NAME_3</span><span class="o">.</span><span class="n">lVal</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">asbool</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">vt</span> <span class="ow">in</span> <span class="p">[</span><span class="n">VT_BOOL</span><span class="p">]:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;get_bstr on non-bool variant&quot;</span><span class="p">)</span>
+        <span class="k">return</span> <span class="nb">bool</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_VARIANT_NAME_3</span><span class="o">.</span><span class="n">boolVal</span><span class="p">)</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">asdispatch</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">vt</span> <span class="ow">in</span> <span class="p">[</span><span class="n">VT_DISPATCH</span><span class="p">]:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;asdispatch on non-VT_DISPATCH variant&quot;</span><span class="p">)</span>
+        <span class="k">return</span> <span class="n">interfaces</span><span class="o">.</span><span class="n">IDispatch</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_VARIANT_NAME_3</span><span class="o">.</span><span class="n">pdispVal</span><span class="p">)</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">asshort</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">vt</span> <span class="ow">in</span> <span class="p">[</span><span class="n">VT_I2</span><span class="p">]:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;asshort on non-VT_I2 variant&quot;</span><span class="p">)</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_VARIANT_NAME_3</span><span class="o">.</span><span class="n">iVal</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">asbyte</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">vt</span> <span class="ow">in</span> <span class="p">[</span><span class="n">VT_UI1</span><span class="p">]:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;asbyte on non-VT_UI1 variant&quot;</span><span class="p">)</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_VARIANT_NAME_3</span><span class="o">.</span><span class="n">bVal</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">asunknown</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">vt</span> <span class="ow">in</span> <span class="p">[</span><span class="n">VT_UNKNOWN</span><span class="p">]:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;asunknown on non-VT_UNKNOWN variant&quot;</span><span class="p">)</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_VARIANT_NAME_3</span><span class="o">.</span><span class="n">punkVal</span>
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">asarray</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">vt</span> <span class="o">&amp;</span> <span class="n">VT_ARRAY</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;asarray on non-VT_ARRAY variant&quot;</span><span class="p">)</span>
+        <span class="c1"># TODO: auto extract VT_TYPE for the array ?</span>
+        <span class="c1">#type = VT_VALUE_TO_TYPE[self.vt &amp; VT_TYPEMASK]</span>
+        <span class="k">return</span> <span class="n">ImprovedSAFEARRAY</span><span class="o">.</span><span class="n">from_PSAFEARRAY</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_VARIANT_NAME_3</span><span class="o">.</span><span class="n">parray</span><span class="p">)</span>
+
+
+    <span class="nd">@property</span>
+    <span class="k">def</span> <span class="nf">aslong_array</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">vt</span> <span class="o">&amp;</span> <span class="n">VT_I4</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;as_bstr_array on non-VT_BSTR variant&quot;</span><span class="p">)</span>
+        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">asarray</span><span class="o">.</span><span class="n">to_list</span><span class="p">(</span><span class="n">LONG</span><span class="p">)</span>
+
+    <span class="k">def</span> <span class="nf">generate_asarray_property</span><span class="p">(</span><span class="n">vttype</span><span class="p">):</span>
+        <span class="nd">@property</span>
+        <span class="k">def</span> <span class="nf">as_array_generated</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+            <span class="c1"># TODO: vt check like the others ?</span>
+            <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">asarray</span><span class="o">.</span><span class="n">to_list</span><span class="p">(</span><span class="n">vttype</span><span class="p">)</span>
+        <span class="k">return</span> <span class="n">as_array_generated</span>
+
+    <span class="n">asbstr_array</span> <span class="o">=</span> <span class="n">generate_asarray_property</span><span class="p">(</span><span class="n">BSTR</span><span class="p">)</span>
+    <span class="n">aslong_array</span> <span class="o">=</span> <span class="n">generate_asarray_property</span><span class="p">(</span><span class="n">LONG</span><span class="p">)</span>
+    <span class="n">asbyte_array</span> <span class="o">=</span> <span class="n">generate_asarray_property</span><span class="p">(</span><span class="n">BYTE</span><span class="p">)</span>
+    <span class="n">asbool_array</span> <span class="o">=</span> <span class="n">generate_asarray_property</span><span class="p">(</span><span class="n">VARIANT_BOOL</span><span class="p">)</span>
+
+    <span class="k">def</span> <span class="nf">to_pyobject</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="c1"># if self.vt &amp; VT_ARRAY:</span>
+            <span class="c1"># # Something better TODO i guess</span>
+            <span class="c1"># if self.vt &amp; VT_TYPEMASK == VT_BSTR:</span>
+                <span class="c1"># import pdb;pdb.set_trace()</span>
+                <span class="c1"># print(&quot;VT_TYPEMASK ARRAY&quot;)</span>
+                <span class="c1"># return self.asarray.to_list(BSTR)</span>
+            <span class="c1"># if self.vt &amp; VT_TYPEMASK == VT_I4:</span>
+                <span class="c1"># import pdb;pdb.set_trace()</span>
+                <span class="c1"># print(&quot;VT_TYPEMASK ARRAY&quot;)</span>
+                <span class="c1"># return self.asarray.to_list(LONG)</span>
+            <span class="c1"># raise NotImplementedError(&quot;Variant of type {0:#x}&quot;.format(self.vt))</span>
+        <span class="c1"># use the ImprovedVariant.MAPPER that dispatch by self.vt</span>
+        <span class="k">try</span><span class="p">:</span>
+            <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">MAPPER</span><span class="p">[</span><span class="bp">self</span><span class="o">.</span><span class="n">vt</span><span class="p">](</span><span class="bp">self</span><span class="p">)</span>
+        <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">(</span><span class="s2">&quot;Variant of type </span><span class="si">{0:#x}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">vt</span><span class="p">))</span>
+
+
+<span class="n">ImprovedVariant</span><span class="o">.</span><span class="n">MAPPER</span> <span class="o">=</span> <span class="p">{</span>
+    <span class="n">VT_UI1</span><span class="p">:</span> <span class="n">ImprovedVariant</span><span class="o">.</span><span class="n">asbyte</span><span class="o">.</span><span class="n">fget</span><span class="p">,</span>
+    <span class="n">VT_I2</span><span class="p">:</span> <span class="n">ImprovedVariant</span><span class="o">.</span><span class="n">asshort</span><span class="o">.</span><span class="n">fget</span><span class="p">,</span>
+    <span class="n">VT_DISPATCH</span><span class="p">:</span> <span class="n">ImprovedVariant</span><span class="o">.</span><span class="n">asdispatch</span><span class="o">.</span><span class="n">fget</span><span class="p">,</span>
+    <span class="n">VT_BOOL</span><span class="p">:</span> <span class="n">ImprovedVariant</span><span class="o">.</span><span class="n">asbool</span><span class="o">.</span><span class="n">fget</span><span class="p">,</span>
+    <span class="n">VT_I4</span><span class="p">:</span> <span class="n">ImprovedVariant</span><span class="o">.</span><span class="n">aslong</span><span class="o">.</span><span class="n">fget</span><span class="p">,</span>
+    <span class="n">VT_BSTR</span><span class="p">:</span> <span class="n">ImprovedVariant</span><span class="o">.</span><span class="n">asbstr</span><span class="o">.</span><span class="n">fget</span><span class="p">,</span>
+    <span class="n">VT_EMPTY</span><span class="p">:</span> <span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="kc">None</span><span class="p">),</span>
+    <span class="n">VT_NULL</span><span class="p">:</span> <span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="kc">None</span><span class="p">),</span>
+    <span class="n">VT_UNKNOWN</span><span class="p">:</span> <span class="n">ImprovedVariant</span><span class="o">.</span><span class="n">asunknown</span><span class="o">.</span><span class="n">fget</span><span class="p">,</span>
+    <span class="p">(</span><span class="n">VT_ARRAY</span> <span class="o">|</span> <span class="n">VT_BSTR</span><span class="p">):</span> <span class="n">ImprovedVariant</span><span class="o">.</span><span class="n">asbstr_array</span><span class="o">.</span><span class="n">fget</span><span class="p">,</span>
+    <span class="p">(</span><span class="n">VT_ARRAY</span> <span class="o">|</span> <span class="n">VT_I4</span><span class="p">):</span> <span class="n">ImprovedVariant</span><span class="o">.</span><span class="n">aslong_array</span><span class="o">.</span><span class="n">fget</span><span class="p">,</span>
+    <span class="p">(</span><span class="n">VT_ARRAY</span> <span class="o">|</span> <span class="n">VT_UI1</span><span class="p">):</span> <span class="n">ImprovedVariant</span><span class="o">.</span><span class="n">asbyte_array</span><span class="o">.</span><span class="n">fget</span><span class="p">,</span>
+    <span class="p">(</span><span class="n">VT_ARRAY</span> <span class="o">|</span> <span class="n">VT_BOOL</span><span class="p">):</span> <span class="n">ImprovedVariant</span><span class="o">.</span><span class="n">asbool_array</span><span class="o">.</span><span class="n">fget</span>
+<span class="p">}</span>
+
+
+
+<div class="viewcode-block" id="COMImplementation"><a class="viewcode-back" href="../../com.html#windows.com.COMImplementation">[docs]</a><span class="k">class</span> <span class="nc">COMImplementation</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;The base class to implements COM object respecting a given interface&quot;&quot;&quot;</span>
+    <span class="n">IMPLEMENT</span> <span class="o">=</span> <span class="kc">None</span>
+
+    <span class="k">def</span> <span class="nf">get_index_of_method</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">method</span><span class="p">):</span>
+        <span class="c1"># This code is horrible but not totally my fault</span>
+        <span class="c1"># the PyCFuncPtrObject-&gt;index is not exposed to Python..</span>
+        <span class="c1"># repr is: &#39;&lt;COM method offset 2: WinFunctionType at 0x035DDBE8&gt;&#39;</span>
+        <span class="n">rpr</span> <span class="o">=</span> <span class="nb">repr</span><span class="p">(</span><span class="n">method</span><span class="p">)</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="n">rpr</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">&quot;&lt;COM method offset &quot;</span><span class="p">)</span> <span class="ow">or</span> <span class="s2">&quot;:&quot;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">rpr</span><span class="p">:</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;Could not extract offset of </span><span class="si">{0}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">rpr</span><span class="p">))</span>
+        <span class="k">return</span> <span class="nb">int</span><span class="p">(</span><span class="n">rpr</span><span class="p">[</span><span class="nb">len</span><span class="p">(</span><span class="s2">&quot;&lt;COM method offset &quot;</span><span class="p">):</span> <span class="n">rpr</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="s2">&quot;:&quot;</span><span class="p">)])</span>
+
+    <span class="k">def</span> <span class="nf">extract_methods_order</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">interface</span><span class="p">):</span>
+        <span class="n">index_and_method</span> <span class="o">=</span> <span class="nb">sorted</span><span class="p">((</span><span class="bp">self</span><span class="o">.</span><span class="n">get_index_of_method</span><span class="p">(</span><span class="n">m</span><span class="p">),</span><span class="n">name</span><span class="p">,</span> <span class="n">m</span><span class="p">)</span> <span class="k">for</span> <span class="n">name</span><span class="p">,</span> <span class="n">m</span> <span class="ow">in</span> <span class="n">interface</span><span class="o">.</span><span class="n">_functions_</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>
+        <span class="k">return</span> <span class="n">index_and_method</span>
+
+    <span class="k">def</span> <span class="nf">verify_implem</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">interface</span><span class="p">):</span>
+        <span class="k">for</span> <span class="n">func_name</span> <span class="ow">in</span> <span class="n">interface</span><span class="o">.</span><span class="n">_functions_</span><span class="p">:</span>
+            <span class="n">implem</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">func_name</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
+            <span class="k">if</span> <span class="n">implem</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
+                <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;&lt;</span><span class="si">{0}</span><span class="s2">&gt; implementing &lt;</span><span class="si">{1}</span><span class="s2">&gt; has no method &lt;</span><span class="si">{2}</span><span class="s2">&gt;&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">IMPLEMENT</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,</span> <span class="n">func_name</span><span class="p">))</span>
+            <span class="k">if</span> <span class="ow">not</span> <span class="n">callable</span><span class="p">(</span><span class="n">implem</span><span class="p">):</span>
+                <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;</span><span class="si">{0}</span><span class="s2"> implementing &lt;</span><span class="si">{1}</span><span class="s2">&gt;: &lt;</span><span class="si">{2}</span><span class="s2">&gt; is not callable&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">IMPLEMENT</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,</span> <span class="n">func_name</span><span class="p">))</span>
+        <span class="k">return</span> <span class="kc">True</span>
+
+    <span class="k">def</span> <span class="nf">_create_vtable</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">interface</span><span class="p">):</span>
+        <span class="n">implems</span> <span class="o">=</span> <span class="p">[]</span>
+        <span class="n">names</span> <span class="o">=</span> <span class="p">[]</span>
+        <span class="k">for</span> <span class="n">index</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">method</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">extract_methods_order</span><span class="p">(</span><span class="n">interface</span><span class="p">):</span>
+            <span class="n">func_implem</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span>
+            <span class="c1">#&#39;this&#39; is a COM-interface of the type we are implementing</span>
+            <span class="n">types</span> <span class="o">=</span> <span class="p">[</span><span class="n">method</span><span class="o">.</span><span class="n">restype</span><span class="p">,</span> <span class="n">interface</span><span class="p">]</span> <span class="o">+</span> <span class="nb">list</span><span class="p">(</span><span class="n">method</span><span class="o">.</span><span class="n">argtypes</span><span class="p">)</span>
+            <span class="n">implems</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">ctypes</span><span class="o">.</span><span class="n">WINFUNCTYPE</span><span class="p">(</span><span class="o">*</span><span class="n">types</span><span class="p">)(</span><span class="n">func_implem</span><span class="p">))</span>
+            <span class="n">names</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
+        <span class="k">class</span> <span class="nc">Vtable</span><span class="p">(</span><span class="n">ctypes</span><span class="o">.</span><span class="n">Structure</span><span class="p">):</span>
+            <span class="n">_fields_</span> <span class="o">=</span> <span class="p">[(</span><span class="n">name</span><span class="p">,</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_void_p</span><span class="p">)</span> <span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">names</span><span class="p">]</span>
+        <span class="k">return</span> <span class="n">Vtable</span><span class="p">(</span><span class="o">*</span><span class="p">[</span><span class="n">ctypes</span><span class="o">.</span><span class="n">cast</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_void_p</span><span class="p">)</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">implems</span><span class="p">]),</span> <span class="n">implems</span>
+
+    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">verify_implem</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">IMPLEMENT</span><span class="p">)</span>
+        <span class="n">vtable</span><span class="p">,</span> <span class="n">implems</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_create_vtable</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">IMPLEMENT</span><span class="p">)</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">vtable</span> <span class="o">=</span> <span class="n">vtable</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">implems</span> <span class="o">=</span> <span class="n">implems</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">vtable_pointer</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">pointer</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">vtable</span><span class="p">)</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">_as_parameter_</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">addressof</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">vtable_pointer</span><span class="p">)</span>
+
+<div class="viewcode-block" id="COMImplementation.QueryInterface"><a class="viewcode-back" href="../../com.html#windows.com.COMImplementation.QueryInterface">[docs]</a>    <span class="k">def</span> <span class="nf">QueryInterface</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">this</span><span class="p">,</span> <span class="n">piid</span><span class="p">,</span> <span class="n">result</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Default ``QueryInterface`` implementation that returns ``self`` if piid is the implemented interface&quot;&quot;&quot;</span>
+        <span class="k">if</span> <span class="n">piid</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="ow">in</span> <span class="p">(</span><span class="n">IUnknown</span><span class="o">.</span><span class="n">IID</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">IMPLEMENT</span><span class="o">.</span><span class="n">IID</span><span class="p">):</span>
+            <span class="n">result</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="n">this</span>
+            <span class="k">return</span> <span class="mi">1</span></div>
+        <span class="k">return</span> <span class="n">E_NOINTERFACE</span>
+
+<div class="viewcode-block" id="COMImplementation.AddRef"><a class="viewcode-back" href="../../com.html#windows.com.COMImplementation.AddRef">[docs]</a>    <span class="k">def</span> <span class="nf">AddRef</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Default ``AddRef`` implementation that returns ``1``&quot;&quot;&quot;</span></div>
+        <span class="k">return</span> <span class="mi">1</span>
+
+<div class="viewcode-block" id="COMImplementation.Release"><a class="viewcode-back" href="../../com.html#windows.com.COMImplementation.Release">[docs]</a>    <span class="k">def</span> <span class="nf">Release</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;Default ``Release`` implementation that returns ``1``&quot;&quot;&quot;</span></div></div>
+        <span class="k">return</span> <span class="mi">0</span>
+</pre></div>
+
+          </div>
+        </div>
+      </div>
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+<div id="searchbox" style="display: none" role="search">
+  <h3>Quick search</h3>
+    <div class="searchformwrapper">
+    <form class="search" action="../../search.html" method="get">
+      <input type="text" name="q" />
+      <input type="submit" value="Go" />
+      <input type="hidden" name="check_keywords" value="yes" />
+      <input type="hidden" name="area" value="default" />
+    </form>
+    </div>
+</div>
+<script type="text/javascript">$('#searchbox').show(0);</script>
+        </div>
+      </div>
+      <div class="clearer"></div>
+    </div>
+    <div class="related" role="navigation" aria-label="related navigation">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="right" style="margin-right: 10px">
+          <a href="../../genindex.html" title="General Index"
+             >index</a></li>
+        <li class="right" >
+          <a href="../../py-modindex.html" title="Python Module Index"
+             >modules</a> |</li>
+        <li class="nav-item nav-item-0"><a href="../../index.html">PythonForWindows 0.4 documentation</a> &#187;</li>
+          <li class="nav-item nav-item-1"><a href="../index.html" >Module code</a> &#187;</li> 
+      </ul>
+    </div>
+    <div class="footer" role="contentinfo">
+        &#169; Copyright 2015, Clement Rouault.
+      Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.7.1.
+    </div>
+  </body>
+</html>